Zend FR

Consultez la FAQ sur le ZF avant de poster une question

Vous n'êtes pas identifié.

Pages: 1

 

#1 03-10-2010 22:17:24

Denis. Beurive
Membre
Date d'inscription: 06-06-2009
Messages: 35

[Résolu] [Greffon de ressource] Pourquoi et comment les utiliser?

Bonjour à tous,

J'ai écrit une classe d'amorçage ("bootstrap") un peu complexe qui fonctionne. Poussé par un élan perfectionniste, je me suis dit que j'allais me lancer dans le développement d'un greffon ("plugin") de ressource. Mais voilà, je n'arrive pas à me dépatouiller avec ce greffon.

L'URL vers la documentation des greffons de ressource est la suivante : http://framework.zend.com/manual/en/zen … ation.html

Voici une partie de ma classe d'amorçage (volontairement allégée) :

Code:

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
    protected function _initTerminal()
    {
        $this->bootstrap('frontController');
        $this->bootstrap('view');
        $this->bootstrap('layout');

        $front  = Zend_Controller_Front::getInstance();
        $view   = $this->getResource('view');
        $layout = $this->getResource('layout');
                    
        $terminalViewDir   = null;
        $terminalHelperDir = null;
        $terminalLayoutDir = null;
        $terminalCssDir    = null;
        $terminalJsDir     = null;

        $terminal = 'standard';
      
        // Configuration des paramètres associés aux vues.
        switch ($terminal)
        {
            case 'iphone': {
            $terminalViewDir   = $front->getModuleDirectory() . '/views/iphone/scripts';
            $terminalHelperDir = APPLICATION_PATH. '/helpers/iphone';
            $terminalLayoutDir = APPLICATION_PATH. '/layouts/iphone';
            $terminalCssDir    = '/css/iphone';
            $terminalJsDir     = '/js/iphone';
            } break;
            
            default: {
            $terminalLayoutDir = APPLICATION_PATH. '/layouts/standard/scripts';
            $terminalCssDir    = '/css/standard';
            $terminalJsDir     = '/css/standard';
            }
        }
         
        $view->setScriptPath($front->getModuleDirectory() . '/views/standard/scripts');
        $view->setHelperPath(APPLICATION_PATH. '/helpers/standard');
        if (! is_null($terminalViewDir)) { $view->addScriptPath($terminalViewDir); }
        if (! is_null($terminalHelperDir)) { $view->addHelperPath($terminalHelperDir); }
        $layout->setLayoutPath($terminalLayoutDir);
   }
}

Note: Vous l'avez deviné, l'objectif de cette procédure d'amorçage est d'adapter l'application au terminal utilisé par l'internaute pour consulter le site.

Ma première question est la suivante :

Je désire créer un greffon de ressource pour amorcer la ressource que j'ai appelée "terminal" (amorcer par la méthode _initTerminal()).

Les greffons de ressources sont-ils conçus pour cette application?

Si oui, alors l'idée d'externaliser l'amorçage de la ressource "terminal" est-elle bonne?

Ma deuxième question est la suivante :

Pour créer mon greffon de ressource, j'ai procédé comme suit :

1. Initialisation du chargeur de greffon, juste avant l'amorçage de l'application :

Code:

$loader = new Zend_Loader_PluginLoader();
$loader->addPrefixPath('My_Resources', 'My/Resources/');
// Pour tester: $loader->load('terminal'); exit;

$application->bootstrap()->run();

2. Je crée le fichier PHP qui implémente le greffon (library/My/Resources/terminal.php):

Code:

class My_Resources_Terminal extends Zend_Application_Resource_ResourceAbstract
{
    protected $_terminal = null;

    public function init()
    {
        // Return terminal, so bootstrap will store it in the registry
        return $this->getTerminal();
    }

    public function getTerminal()
    {
        // Détermination du type de terminal utilisé par l'internaute.
        $this->_terminal = 'standard';
              
        // Configuration des chemins vers les gabarits, les vues et les aides de vue.
        if (null === $this->_view)
        {
            $this->bootstrap('frontController');
            $this->bootstrap('terminal');
            $this->bootstrap('layout');
        
            $front  = Zend_Controller_Front::getInstance();
            $view   = $this->getResource('terminal');
            $layout = $this->getResource('layout');
                            
            $terminalViewDir   = null;
            $terminalHelperDir = null;
            $terminalLayoutDir = null;
            $terminalCssDir    = null;
            $terminalJsDir     = null;
        
            $terminal = 'standard';
              
            // Configuration des paramètres associés aux vues.
            switch ($terminal)
            {
                case 'iphone': {
                $terminalViewDir   = $front->getModuleDirectory() . '/views/iphone/scripts';
                $terminalHelperDir = APPLICATION_PATH. '/helpers/iphone';
                $terminalLayoutDir = APPLICATION_PATH. '/layouts/iphone';
                $terminalCssDir    = '/css/iphone';
                $terminalJsDir     = '/js/iphone';
                } break;
                    
                default: {
                $terminalLayoutDir = APPLICATION_PATH. '/layouts/standard/scripts';
                $terminalCssDir    = '/css/standard';
                $terminalJsDir     = '/css/standard';
                }
            }
                 
            $view->setScriptPath($front->getModuleDirectory() . '/views/standard/scripts');
            $view->setHelperPath(APPLICATION_PATH. '/helpers/standard');
            if (! is_null($terminalViewDir)) { $view->addScriptPath($terminalViewDir); }
            if (! is_null($terminalHelperDir)) { $view->addHelperPath($terminalHelperDir); }
            $layout->setLayoutPath($terminalLayoutDir);
        }
                
        return $this->_terminal;
    }
}

Pour information, le code ci-dessous fonctionne :

Code:

$loader = new Zend_Loader_PluginLoader();
$loader->addPrefixPath('My_Resources', 'My/Resources/');
$loader->load('terminal');

=> OK.

Le problème est que ce greffon n'est pas "chargé" lors de l'amorçage de l'application ($application->bootstrap()->run()).

Et, si je "force" l'amorçage de cette ressource, je reçois un message d'erreur ($application->bootstrap('terminal')->run()).

Ai-je loupé quelque chose?


Merci,

Denis

Dernière modification par Denis. Beurive (05-10-2010 19:40:59)

Hors ligne

 

#2 04-10-2010 09:37:00

Delprog
Administrateur
Date d'inscription: 29-09-2008
Messages: 670

Re: [Résolu] [Greffon de ressource] Pourquoi et comment les utiliser?

Salut,

Tout à l'air pourtant correcte.

Tu dis que php lache une erreur sur $application->bootstrap('terminal'), quelle erreur exactement ?

Sinon, une indication, tu peux ajouter autant de chemins vers des plugins de ressources perso directement dans le fichier de configuration :

pluginPaths.Tight_Application_Resource = APPLICATION_PATH "/../lib/Tight/Application/Resource"
pluginPaths.App_Application_Resource =  APPLICATION_PATH "/../lib/App/Application/Resource"

La classe bootstrap va de toute façon charger l'autoloader, autant ne le faire qu'une seule fois. Je pense d'ailleurs que c'est de là que vient ton problème, le bootstrap instancie lui même un autoloader et l'utilise par la suite, donc effectivement ça fonctionne quand tu charges toi même un autoloader mais le Bootstrap lui n'en a pas connaissance.


A+ benjamin.

http://www.anonymation.com/ - anonymation - Studio de création.
http://code.anonymation.com/ - anonymation - blog - développement et architecture web

Hors ligne

 

#3 04-10-2010 13:56:30

Denis. Beurive
Membre
Date d'inscription: 06-06-2009
Messages: 35

Re: [Résolu] [Greffon de ressource] Pourquoi et comment les utiliser?

Delprog a écrit:

Salut,

Tout à l'air pourtant correcte.

Tu dis que php lache une erreur sur $application->bootstrap('terminal'), quelle erreur exactement ?

Sinon, une indication, tu peux ajouter autant de chemins vers des plugins de ressources perso directement dans le fichier de configuration :

pluginPaths.Tight_Application_Resource = APPLICATION_PATH "/../lib/Tight/Application/Resource"
pluginPaths.App_Application_Resource =  APPLICATION_PATH "/../lib/App/Application/Resource"

La classe bootstrap va de toute façon charger l'autoloader, autant ne le faire qu'une seule fois. Je pense d'ailleurs que c'est de là que vient ton problème, le bootstrap instancie lui même un autoloader et l'utilise par la suite, donc effectivement ça fonctionne quand tu charges toi même un autoloader mais le Bootstrap lui n'en a pas connaissance.


A+ benjamin.

Salut Delprog,

Je te remercie pour ton aide.


Dans le fichier d'initialisation de l'application :

Code:

includePaths.library = APPLICATION_PATH "/../library"
pluginPaths.My_Resources = APPLICATION_PATH "/../library/My/Resources"

J'ai bien vérifié que ces deux répertoires existent. Ils existent.

Code:

C:>dir "C:\Documents and Settings\Denis Beurive\Zend\workspaces\DefaultWorkspace7\ExampleProject\ex\application/../library"
 Le volume dans le lecteur C n'a pas de nom.
 Le numéro de série du volume est CC82-6585

 Répertoire de C:\Documents and Settings\Denis Beurive\Zend\workspaces\DefaultWorkspace7\ExampleProject\ex\library

04/10/2010  10:51    <REP>          .
04/10/2010  10:51    <REP>          ..
04/10/2010  10:51    <REP>          My
               0 fichier(s)                0 octets
               3 Rép(s)  24 512 667 648 octets libres

Code:

C:>dir "C:\Documents and Settings\Denis Beurive\Zend\workspaces\DefaultWorkspace7\ExampleProject\ex\application/../library/My/Resources"
 Le volume dans le lecteur C n'a pas de nom.
 Le numéro de série du volume est CC82-6585

 Répertoire de C:\Documents and Settings\Denis Beurive\Zend\workspaces\DefaultWorkspace7\ExampleProject\ex\library\My\Resources

04/10/2010  10:51    <REP>          .
04/10/2010  10:51    <REP>          ..
04/10/2010  11:20             2 324 terminal.php
               1 fichier(s)            2 324 octets
               2 Rép(s)  24 512 663 552 octets libres

Voici l'erreur :

Code:

$application->bootstrap('terminal');

Génère le message suivant :

Code:

Fatal error: Uncaught exception 'Zend_Application_Bootstrap_Exception' with message 'Resource matching "terminal" not found' in C:\Documents and Settings\Denis Beurive\Bureau\dev\ZendFramework-1.10.8\library\Zend\Application\Bootstrap\BootstrapAbstract.php:691 Stack trace: #0 C:\Documents and Settings\Denis Beurive\Bureau\dev\ZendFramework-1.10.8\library\Zend\Application\Bootstrap\BootstrapAbstract.php(626): Zend_Application_Bootstrap_BootstrapAbstract->_executeResource('terminal') #1 C:\Documents and Settings\Denis Beurive\Bureau\dev\ZendFramework-1.10.8\library\Zend\Application\Bootstrap\BootstrapAbstract.php(583): Zend_Application_Bootstrap_BootstrapAbstract->_bootstrap('terminal') #2 C:\Documents and Settings\Denis Beurive\Bureau\dev\ZendFramework-1.10.8\library\Zend\Application.php(355): Zend_Application_Bootstrap_BootstrapAbstract->bootstrap('terminal') #3 C:\Documents and Settings\Denis Beurive\Zend\workspaces\DefaultWorkspace7\ExampleProject\ex\www\index.php(61): Zend_Application->bootstrap('terminal') #4 in C:\Documents and Settings\Denis Beurive\Bureau\dev\ZendFramework-1.10.8\library\Zend\Application\Bootstrap\BootstrapAbstract.php on line 691

Dans un premier temps, je pensais que l'application cherchait à charger le greffon depuis un répertoire déclaré dans la directive "include_path" du serveur PHP.

Code:

include_path = ".;C:\Documents and Settings\Denis Beurive\Bureau\dev\ZendFramework-1.10.8\library"

J'ai alors ajouté, pour voir, le chemin du répertoire qui contient mes greffons de ressources à la liste des répertoires déclarés dans la directive "include_path" du serveur PHP.

Code:

include_path = ".;C:\Documents and Settings\Denis Beurive\Bureau\dev\ZendFramework-1.10.8\library;C:\Documents and Settings\Denis Beurive\Zend\workspaces\DefaultWorkspace7\ExampleProject\ex\library"

Mais cela ne change rien.

En fait, le chemin qui apparaît dans le message d'erreur est tout simplement relatif à la classe mère qui lance l'exception.

J'en conclus donc que le chargeur de greffon ne sait pas où chercher le fichier à charger (en l'occurence, "terminal.php").

À tout hasard, je retire le caractère "s" (pluginPath"s") dans la directive de configuration du chargeur de greffon (au sein du fichier d'initialisation de l'application).

Code:

; pluginPaths.My_Resources = APPLICATION_PATH "/../library/My/Resources"
pluginPath.My_Resources = APPLICATION_PATH "/../library/My/Resources"

Cela ne change rien.

Dans l'exemple fourni dans la documentation, l'application est créée en utilisant une méthode différente de celle que j'utilise. Les paramètres de configuration sont fournis via un tableau, et non via un fichier d'initialisation.

Code:

      $application = new Zend_Application(APPLICATION_ENV, array(
          'pluginPaths' => array(
              'My_Resource' => APPLICATION_PATH . '/resources/',
          ),
          'resources' => array(
              'FrontController' => array(
                  'controllerDirectory' => APPLICATION_PATH . '/controllers',
              ),
          ),
      ));

Je n'ai pas trouvé de moyen pour "mixer" une configuration : Une partie de la configuration est fournie via un tableau, et l'autre partie via un fichier.

Cela dit, j'ai vérifié que la configuration issue du fichier d'initialisation est valide, de la façon suivante :

Code:

$application = new Zend_Application(
    APPLICATION_ENV,
    APPLICATION_PATH . '/configuration/application.ini'
);
var_dump($application->getOptions());

On a bien :

Code:

["pluginPaths"]=>  array(1) { ["My_Resources"]=>  string(13) "My/Resources/" }

Se pourrait-il que la directive de configuration ci-dessous ne soit pas prise en compte (dans le fichier d'initilaisation de l'application)?

Code:

pluginPaths.My_Resources = APPLICATION_PATH "/../library/My/Resources"

Remarque :

J'ai tenté de renommer le fichier PHP qui implémente le greffon ("terminal.php") de ressource de la façon suivante :

Code:

rename terminal.php Terminal.php

En effet, je me suis rendu compte que les noms des fichiers PHP des ressources prédéfinies dans le framework commencent tous par une majuscule (c'est d'ailleurs logique si l'on considère le fonctionnement du chargement automatique).

Code:

$$library/Zend/Application/Resource$ more Db.php

...
class Zend_Application_Resource_Db extends Zend_Application_Resource_ResourceAbstract
{
...

Le changement de casse ne change rien.

J'ai aussi essayé cette technique :

Code:

$loader = new Zend_Loader_PluginLoader();
$loader->addPrefixPath('My_Resources',
                       'My/Resources/');
// $res = $loader->load('terminal');  // Cette instruction fonctionne !!!

$application->getBootstrap()->setPluginLoader($loader);

$application->bootstrap('Terminal');

Mais, cela ne fonctionne pas non plus (même erreur).



A+

Dernière modification par Denis. Beurive (04-10-2010 16:02:08)

Hors ligne

 

#4 04-10-2010 16:21:13

Denis. Beurive
Membre
Date d'inscription: 06-06-2009
Messages: 35

Re: [Résolu] [Greffon de ressource] Pourquoi et comment les utiliser?

En désespoir de cause, j'ai tenté un truc dégueulasse.

J'ai créé le fichier suivant :

C:\Documents and Settings\Denis Beurive\Bureau\dev\ZendFramework-1.10.8\library\Zend\Application\Resource\Terminal.php

Code:

C:\>dir "C:\Documents and Settings\Denis Beurive\Bureau\dev\ZendFramework-1.10.8\library\Zend\Application\Resource\"
 Le volume dans le lecteur C n'a pas de nom.
 Le numéro de série du volume est CC82-6585

 Répertoire de C:\Documents and Settings\Denis Beurive\Bureau\dev\ZendFramework-
1.10.8\library\Zend\Application\Resource

04/10/2010  16:12    <REP>          .
04/10/2010  16:12    <REP>          ..
06/01/2010  05:05             2 085 Cachemanager.php
02/02/2010  00:13             3 813 Db.php
02/02/2010  00:13             2 102 Dojo.php
17/07/2010  12:49             1 284 Exception.php
03/02/2010  22:36             5 039 Frontcontroller.php
02/02/2010  00:13             1 928 Layout.php
02/02/2010  00:13             2 623 Locale.php
02/02/2010  00:13             1 994 Log.php
12/02/2010  04:00             4 871 Mail.php
02/02/2010  00:13             4 530 Modules.php
23/05/2010  02:48             5 065 Multidb.php
02/02/2010  00:13             3 371 Navigation.php
06/01/2010  05:05             2 196 Resource.php
06/01/2010  05:05             4 284 ResourceAbstract.php
02/02/2010  00:13             2 602 Router.php
02/02/2010  00:13             3 743 Session.php
04/10/2010  16:12             2 371 Terminal.php
06/04/2010  00:16             3 745 Translate.php
02/02/2010  00:13             2 226 View.php
              19 fichier(s)           59 872 octets

Et :

Code:

<?php

class Zend_Application_Resource_Terminal extends Zend_Application_Resource_ResourceAbstract
{
    protected $_terminal = null;
    public $_explicitType = 'Terminal';

    public function init()
    {
        // Return terminal, so bootstrap will store it in the registry
        return $this->getTerminal();
    }

    public function getTerminal()
    {
        // Détermination du type de terminal utilisé par l'internaute.
        $this->_terminal = 'standard';
        
        // Configuration des chemins vers les gabarits, les vues, les aides de vue, les librairies JavaScript et les CSS.
        if (null === $this->_terminal)
        {
            $this->bootstrap('frontController');
            $this->bootstrap('terminal');
            $this->bootstrap('layout');
        
            $front  = Zend_Controller_Front::getInstance();
            $view   = $this->getResource('terminal');
            $layout = $this->getResource('layout');
                            
            $terminalViewDir   = null;
            $terminalHelperDir = null;
            $terminalLayoutDir = null;
            $terminalCssDir    = null;
            $terminalJsDir     = null;
        
            $terminal = 'standard';
              
            // Configuration des paramètres associés aux vues.
            switch ($terminal)
            {
                case 'iphone': {
                $terminalViewDir   = $front->getModuleDirectory() . '/views/iphone/scripts';
                $terminalHelperDir = APPLICATION_PATH. '/helpers/iphone';
                $terminalLayoutDir = APPLICATION_PATH. '/layouts/iphone';
                $terminalCssDir    = '/css/iphone';
                $terminalJsDir     = '/js/iphone';
                } break;
                    
                default: {
                $terminalLayoutDir = APPLICATION_PATH. '/layouts/standard/scripts';
                $terminalCssDir    = '/css/standard';
                $terminalJsDir     = '/css/standard';
                }
            }
                 
            // Dans tous les cas, on spécifie les chemins vers les ressources communes à tous les terminaux.
            $view->setScriptPath($front->getModuleDirectory() . '/views/standard/scripts');
            $view->setHelperPath(APPLICATION_PATH. '/helpers/standard');
        
            // Si l'internaute utilise un terminal spécial, alors on spécifie les chemins vers les répertoires qui contiennent les ressources dédiées à ce terminal.
            if (! is_null($terminalViewDir))   { $view->addScriptPath($terminalViewDir); }
            if (! is_null($terminalHelperDir)) { $view->addHelperPath($terminalHelperDir); }
            $layout->setLayoutPath($terminalLayoutDir);
        }
                
        return $this->_terminal;
    }
}

Malgré cela, la méthode d'amorçage ne parvient pas à trouver la ressource.

Je crois que je vais jeter l'éponge... J'aimerais trouver un exemple simple qui fonctionne.

A+

Hors ligne

 

#5 04-10-2010 17:32:32

Denis. Beurive
Membre
Date d'inscription: 06-06-2009
Messages: 35

Re: [Résolu] [Greffon de ressource] Pourquoi et comment les utiliser?

Bon, je crois que j'ai trouvé une piste!

http://blog.log2e.com/2009/06/01/creati … mework-18/

J'ai ajouté une ligne à mon fichier d'initialisation, et les choses se présentent mieux :

Code:

pluginPaths.My_Resources = APPLICATION_PATH "/../library/My/Resources"
resources.terminal =

La ligne ajoutée est :

resources.terminal =

Le greffon ne s'amorce pas à cause d'une erreur dans le code. Mais, au moins, il est chargé!

Je cite l'auteur du très bon tutoriel :

Finally, there is a possible pitfall that you should be aware of. Even if your plugins do not read any options from the configuration file, you still have to provide the key in the configuration file, otherwise the plugins won’t get initialized. For example:

; Resource Plugins
resources.appinfo =
resources.view =

Par contre, je suis obligé de préciser explicitement le nom de la ressource lors de l'amorçage de l'application :

Code:

$application->bootstrap('Terminal')->run();

Je continue à explorer dans cette voie... En tous les cas, la documentation officielle, sur le site de ZEND, n'est pas suffisante. Un petit exemple simple, éventuellement accompagné, d'un fichier ".ZIP", serait aide appréciable (et ferait gagner un temps considérable au débutant) :-)

En tous les cas : Merci à l'auteur du tutoriel http://blog.log2e.com/2009/06/01/creati … mework-18/ !

A+

Dernière modification par Denis. Beurive (04-10-2010 19:20:54)

Hors ligne

 

#6 04-10-2010 21:03:08

Delprog
Administrateur
Date d'inscription: 29-09-2008
Messages: 670

Re: [Résolu] [Greffon de ressource] Pourquoi et comment les utiliser?

Denis. Beurive a écrit:

La ligne ajoutée est :

resources.terminal =

Haha oui, ça j'aurais pu te le dire en fait smile

Pour ne pas charger les ressources pour rien, zend_application requiert au moins un paramètre dans le fichier de configuration pour indiquer que la ressource doit être chargée. Donc effectivement l'astuce c'est de passer une chaine vide ou un tableau vide ([]) pour les ressources qui attendant des array.

Pour le reste, il suffit de vérifier point par point, il n'y a pas de raison que ça ne fonctionne pas.

Pour la casse des fichiers attention, dans windows tu n'auras pas de pb mais une fois sur un système unix tu t'arracheras les cheveux avant de trouver d'où vient ton erreur parce que ça fonctionnera sur ta machine de dév smile

Dans l'ordre:

1- Ajoute ton dossier library à l'include_path depuis le fichier index.php (ne passe pas par le fichier ini) :

Code:

set_include_path(implode(PATH_SEPARATOR, array(
    get_include_path(),
    realpath(APPLICATION_PATH . '/../library')
)));

2- Ajoute le namespace de ta librairie, le chemin vers tes plugins de ressources et active la ressource dans application.ini :

Code:

;====== Autoload namespaces prefix
autoloaderNamespaces[] = "My_"

;====== Plugin resources
; Chemin vers les classes perso d'initialisation de resources (prioritaires sur celles de Zend)
pluginPaths.My_Application_Resource = APPLICATION_PATH "/../library/My/Application/Resource"

resources.terminal =

3- Le nom de la classe doit être My_Application_Resource_Terminal et le fichier:
library/
    My/
        Application/
            Resource/
                Terminal.php

4-

Code:

$application->bootstrap()
                 ->run();

Ça ne peut pas ne pas fonctionner smile


A+ benjamin.

http://www.anonymation.com/ - anonymation - Studio de création.
http://code.anonymation.com/ - anonymation - blog - développement et architecture web

Hors ligne

 

#7 05-10-2010 09:01:25

Denis. Beurive
Membre
Date d'inscription: 06-06-2009
Messages: 35

Re: [Résolu] [Greffon de ressource] Pourquoi et comment les utiliser?

Delprog a écrit:

Denis. Beurive a écrit:

La ligne ajoutée est :

resources.terminal =

Haha oui, ça j'aurais pu te le dire en fait smile

Pour ne pas charger les ressources pour rien, zend_application requiert au moins un paramètre dans le fichier de configuration pour indiquer que la ressource doit être chargée. Donc effectivement l'astuce c'est de passer une chaine vide ou un tableau vide ([]) pour les ressources qui attendant des array.

Pour le reste, il suffit de vérifier point par point, il n'y a pas de raison que ça ne fonctionne pas.

Pour la casse des fichiers attention, dans windows tu n'auras pas de pb mais une fois sur un système unix tu t'arracheras les cheveux avant de trouver d'où vient ton erreur parce que ça fonctionnera sur ta machine de dév smile

Dans l'ordre:

1- Ajoute ton dossier library à l'include_path depuis le fichier index.php (ne passe pas par le fichier ini) :

Code:

set_include_path(implode(PATH_SEPARATOR, array(
    get_include_path(),
    realpath(APPLICATION_PATH . '/../library')
)));

2- Ajoute le namespace de ta librairie, le chemin vers tes plugins de ressources et active la ressource dans application.ini :

Code:

;====== Autoload namespaces prefix
autoloaderNamespaces[] = "My_"

;====== Plugin resources
; Chemin vers les classes perso d'initialisation de resources (prioritaires sur celles de Zend)
pluginPaths.My_Application_Resource = APPLICATION_PATH "/../library/My/Application/Resource"

resources.terminal =

3- Le nom de la classe doit être My_Application_Resource_Terminal et le fichier:
library/
    My/
        Application/
            Resource/
                Terminal.php

4-

Code:

$application->bootstrap()
                 ->run();

Ça ne peut pas ne pas fonctionner smile


A+ benjamin.

Salut Benjamin,

Je te remercie pour tes conseils. Effectivement, j'ai remarqué que la casse du fichier est importante (car je transfère mes développements sous une machine Linux, pour tester).

J'ai développé un "projet d'exemple" (à destination des débutants) qui illustre l'utilisation des greffons de ressources. Je désire fournir l'archive du projet : C'est motivant d'avoir quelque chose qui fonctionne sous la main. Cela permet de faire des expériences pour "mieux comprendre". Quel est le meilleur site pour déposer ce tutoriel?

A+

Hors ligne

 

#8 05-10-2010 19:39:41

Denis. Beurive
Membre
Date d'inscription: 06-06-2009
Messages: 35

Re: [Résolu] [Greffon de ressource] Pourquoi et comment les utiliser?

Salut,

Je reviens pour exposer la solution finale, qui fonctionne parfaitement.

Le greffon de ressource est destiné à configurer l'application afin d'adapter le rendu au terminal utilisé par l'internaute pour naviguer sur le site. Exemples de terminaux de navigation : Un Iphone, un Ipad, un PC,...

En fonction du terminal utilisé par l'internaute, il est nécessaire d'adapter la présentation des pages afin que le site soit aisément lisible et utilisable. Il est aussi utile d'adapter les technologies utilisées pour le rendu du site. Typiquement, si l'internaute utilise Iphone, il ne faut pas lui envoyer du Flash. Une solution de contournement éventuelle réside dans l'utilisation d'une librairie JavaScript.

Organisation des répertoires

Code:

+---application
¦   ¦   Bootstrap.php
¦   ¦
¦   +---configs
¦   ¦       application.ini
¦   ¦
¦   +---controllers
¦   ¦       ErrorController.php
¦   ¦       IndexController.php
¦   ¦
¦   +---layouts
¦   ¦   +---iphone
¦   ¦   ¦       plain.phtml
¦   ¦   ¦
¦   ¦   +---standard
¦   ¦           plain.phtml
¦   ¦
¦   +---views
¦       +---iphone
¦       ¦   +---helpers
¦       ¦   ¦       Tagger.php
¦       ¦   ¦
¦       ¦   +---scripts
¦       ¦       +---error
¦       ¦       ¦       error.phtml
¦       ¦       ¦
¦       ¦       +---index
¦       ¦               index.phtml
¦       ¦
¦       +---standard
¦           +---helpers
¦           ¦       Special.php
¦           ¦       Tagger.php
¦           ¦
¦           +---scripts
¦               +---error
¦               ¦       error.phtml
¦               ¦
¦               +---index
¦                       index.phtml
¦
+---docs
¦       README.txt
¦
+---library
¦   +---My
¦       +---Resources
¦       ¦       TerminalViews.php
¦       ¦
¦       +---ResourcesHelpers
¦               TerminalViews.php
¦
+---public
¦       .htaccess
¦       index.php
¦
+---tests
    ¦   phpunit.xml
    ¦
    +---application
    ¦       bootstrap.php
    ¦
    +---library
            bootstrap.php

Fichier d'initialisation de l'application

Code:

[production]

phpSettings.display_startup_errors = 0
phpSettings.display_errors = 1
includePaths.library = APPLICATION_PATH "/../library"
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"
appnamespace = "Application"
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"
resources.frontController.params.displayExceptions = 0

;;;
;;; Configuration associée aux gabarits. 
;;;

resources.layout.contentKey = content

;;;
;;; Configuration du greffon de ressource.
;;;
;;; Le mot clé "standard" est réservé. Il désigne le terminal "standard".
;;; Les gabarits, vues et les aides de vues associées au terminal "standard" sont des ressources "par défaut" pour tous les terminaux.
;;;
;;; Les ressources de l'application sont paramétrées de façon à produire le fonctionnement suivant :
;;;
;;; 1. L'utilisation de la ressource "RSC" (vue ou aide de vue) est requise.
;;;    Un chemin vers un répertoire de ressource spécifique est-il défini pour le terminal courant?
;;;    o Si oui, alors la ressource est recherchée dans le répertoire spécifique au terminal courant.
;;;      La ressource "RSC" a-t-elle été trouvée dans le répertoire "spécifique" (au terminal courant)?
;;;         o Si oui, la ressource est utilisée.
;;;         o Si non, la ressource est recherchée dans le répertoire de ressource commun à toutes les vues (celui du terminal "standard").
;;;    o Si non, la ressource "RSC" est recherchée dans le répertoire de ressource commun à toutes les vues (le répertoire de ressource "par défaut").
;;;
;;; 2. L'utilisation du gabarit "GBT" est requise.
;;;    Un chemin vers un répertoire de gabarits spécifique au terminal courant est-il spécifié?
;;;    o Si oui, le gabarit "GBT" est-il présent dans ce répertoire spécifique?
;;;         o Si oui, le gabarit trouvé est utilisé.
;;;         o Si non, on recherche le gabarit "GBT" dans le répertoire spécifique au terminal par défaut (le terminal "standard").  
;;;    o Si non, on recherche le gabarit "GBT" dans le répertoire spécifique au terminal par défaut (le terminal "standard").
;;;
;;; ATTENTION: Même si vous ne désirez pas configurer une ressource, vous devez obligatoirement la référencer dans la liste des ressources.
;;;            Si la ressource n'est pas référencée, elle ne sera pas initialisée lors de l'amorçage de l'application.
;;;            Dans le présent exemple, le greffon doit être configuré (car il ne dispose pas de valeur de configuration par défaut).
;;;            Toutefois, si tel n'est pas le cas (ie: paramétrage optionnel), il est tout de même indispensable de déclarer la ressource, de la façon suivante :
;;;            resources.terminalViews =     
;;;

; Seules les lignes qui se terminent par "; Obligatoire" sont obligatoires.

resources.terminalViews.standard.viewPath     = APPLICATION_PATH "/views/standard/scripts"  ; Obligatoire
resources.terminalViews.standard.layoutPath   = APPLICATION_PATH "/layouts/standard"        ; Obligatoire
resources.terminalViews.standard.helperPath   = APPLICATION_PATH "/views/standard/helpers"  ; Obligatoire
resources.terminalViews.standard.helperPrefix = "Standard_View_Helper"                      ; Obligatoire
resources.terminalViews.standard.cssPath      = "/css/standard.css"
resources.terminalViews.standard.jsPath       = "/js/standard.css"

resources.terminalViews.iphone.viewPath     = APPLICATION_PATH "/views/iphone/scripts"
resources.terminalViews.iphone.layoutPath     = APPLICATION_PATH "/layouts/iphone"
resources.terminalViews.iphone.helperPath     = APPLICATION_PATH "/views/iphone/helpers"
resources.terminalViews.iphone.helperPrefix   = "Iphone_View_Helper"
resources.terminalViews.iphone.cssPath        = "/css/iphone.css"
resources.terminalViews.iphone.jsPath         = "/js/iphone.css"

;;; 
;;; Configuration associée aux vues. 
;;; 
;;; Note: CF mise en garde de la section "Configuration du greffon de ressource".
;;;

resources.view =

;;;
;;; Configuration du chargeur de greffon.
;;;
;;; ATTENTION: Ce paramètre est extrêmement important.
;;;            Il indique le chemin vers le répertoire qui contient le fichier qui implémente le greffon de ressource.
;;;            Fichier "TerminalViews.php".
;;;            Classe "My_Resources_TerminalViews extends Zend_Application_Resource_ResourceAbstract".
;;;

pluginPaths.My_Resources = APPLICATION_PATH "/../library/My/Resources"

;;;
;;; Configuration du chargeur automatique de classe.
;;; 
;;; Note: Les aides associées aux ressources sont placées dans le répertoire "Library/My/ResourcesHepers".
;;;

autoloadernamespaces.0 = "My"

;;;
;;; Configuration spécifique à l'environnement de développement.
;;; 

[development : production]

phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1
resources.frontController.params.displayExceptions = 1

Code Source du greffon de ressource (library\My\Resources\TerminalViews.php)

Code:

<?php

/**
 * Cette classe implémente un greffon qui initialise les chemins vers les gabarits, les vues, les aides de vues, les librairies Javascript et le CSS, en fonction du type de terminal utilisé pour naviguer sur le site.
 * Cette ressource est configurée dans le fichier d'initialisation de l'application ("resources.terminalViews... = ...").
 * @warning La casse du nom du fichier ("TerminalView.php") est importante.
 * @remark La détection du terminal est effectuée dans la classe "Bootstrap".
 */

class My_Resources_TerminalViews extends Zend_Application_Resource_ResourceAbstract
{
    /** Objet de type "My_ResourcesHelpers_TerminalViews".
     */
    protected $_terminalViews = null;
    
    /** Cette propriété définit, explicitement, la valeur de la clé qui sera utilisée pour stocker la valeur de la ressource dans le registre.
     */
    public $_explicitType = 'terminalViews';

    /** Initialise la ressource.
     *  @return La méthode retourne la "valeur" de la ressource.
     */
    public function init()
    {
        // La valeur de la ressource sera automatiquement stockée dans le registre, associée à la clé "$this->_explicitType".
        return $this->getTerminalViews();
    }

    /** Inialise la structure de répertoire, associée au terminal courant.
     *  @return La méthode retourne la "valeur" de la ressource.
     */
    private function getTerminalViews()
    {
        // Configuration des chemins vers les gabarits et des vues.
        if (null === $this->_terminalViews)
        {
            $terminalViewDir          = null;
            $terminalLayoutDir        = null;
            $terminalViewHelperDir    = null;
            $terminalViewHelperPrefix = null;
            $terminalJsDir            = null;
            $terminalCssDir           = null;
            $options                  = array();
            $bootStart                = $this->getBootstrap();
            
            $this->_terminalViews = new My_ResourcesHelpers_TerminalViews();
            
            // On s'assure que les ressources utilisées ont été initialisées au préalable.
            $bootStart->bootstrap('terminal');
            $bootStart->bootstrap('layout');
            $bootStart->bootstrap('view');
            
            // On récupère une référence vers les ressources nécessaires à l'initialisation du présent greffon.
            $terminal = $bootStart->getResource('terminal');
            $layout   = $bootStart->getResource('layout');
            $view     = $bootStart->getResource('view');
            
            // On récupère la configuration associée à la présente ressource ("resources.terminalViews...").
            $options = $this->getOptions();
            
            // On vérifie que les paramètres obligatoires sont présents.
            if (! isset($options['standard'])) { throw new Exception("Resource terminalView: Mandatory parameter 'standard' is missing!"); }
            foreach (array('viewPath', 'layoutPath', 'helperPath', 'helperPrefix') as $param)
            { if (! isset($options['standard'][$param])) { throw new Exception("Resource terminalView: Mandatory parameter 'standard.$param' is missing!"); } }
            
            // Configuration des paramètres associés aux vues.
            foreach ($options as $terminalName => $parameters)
            {
                if ($terminal == $terminalName)
                {
                    if (isset($parameters['viewPath']))     { $terminalViewDir          = $parameters['viewPath']; }
                    if (isset($parameters['layoutPath']))   { $terminalLayoutDir        = $parameters['layoutPath']; }
                    if (isset($parameters['helperPath']))   { $terminalViewHelperDir    = $parameters['helperPath']; }
                    if (isset($parameters['helperPrefix'])) { $terminalViewHelperPrefix = $parameters['helperPrefix']; }
                    if (isset($parameters['jsPath']))        { $terminalJsDir            = $parameters['jsPath']; }
                    if (isset($parameters['cssPath']))      { $terminalCssDir           = $parameters['cssPath']; }                   
                    break;
                }
            }
                 
            // Dans tous les cas, on spécifie les chemins vers les ressources communes à tous les terminaux.
            $view->setScriptPath($options['standard']['viewPath']);
            $this->_terminalViews->addViewPath($options['standard']['viewPath']);
            $view->setHelperPath($options['standard']['helperPath'], $options['standard']['helperPrefix']);
            $this->_terminalViews->addViewHelperPath($options['standard']['helperPath']);
            $this->_terminalViews->addViewHelperPrefix($options['standard']['helperPrefix']);
            
            // Si l'internaute utilise un terminal spécial, alors on spécifie les chemins vers les répertoires qui contiennent les ressources dédiées à ce terminal.
            if (! is_null($terminalViewDir)) { $view->addScriptPath($terminalViewDir);
                                               $this->_terminalViews->addViewPath($terminalViewDir); }
            if (! is_null($terminalViewHelperDir)) { $view->addHelperPath($terminalViewHelperDir, $terminalViewHelperPrefix);
                                                     $this->_terminalViews->addViewHelperPath($terminalViewHelperDir);
                                                     $this->_terminalViews->addViewHelperPrefix($terminalViewHelperPrefix); }
            
            // Si aucun chemin vers les gabarits n'a été spécifié, on spécifie le chemin vers les gabarits communs à tous les terminaux.
            if (is_null($terminalLayoutDir)) { $terminalLayoutDir = $options['standard']['layoutPath']; }
            $layout->setLayoutPath($terminalLayoutDir);
            $this->_terminalViews->setLayoutPath($terminalLayoutDir);
            
            // Si aucun chemin vers les librairies Javacript et CSS n'est spécifié, alors on spécifie les chemins vers les librairies utilisées par défaut.
            if (is_null($terminalJsDir))  { $terminalJsDir  = $options['standard']['jsPath'];  }
            if (is_null($terminalCssDir)) { $terminalCssDir = $options['standard']['cssPath']; }
            $this->_terminalViews->setJsPath($terminalJsDir);   // Eventuellement null.
            $this->_terminalViews->setCssPath($terminalCssDir); // Eventuellement null.
        }
                
        return $this->_terminalViews;
    }
}

Code source de l'aide associée au greffon de ressource (library\My\ResourcesHelpers)

Code:

<?php

/**
 * Cette classe implémente l'aide associée à la ressource "erminalView".
 * @warning Dans le fichier d'initialisation de l'application, il faut ajouter la ligne "autoloadernamespaces.0 = "My"".
 */

class My_ResourcesHelpers_TerminalViews
{
    protected $_viewPathes         = array();
    protected $_viewHelperPathes   = array();
    protected $_viewHelperPrefixes = array();
    protected $_layoutPathes       = null;
    protected $_jsPath             = null;
    protected $_cssPathes          = null;
    
    // SET
    
    public function setViewPathes($inPathes) { $this->_viewPathes = $inPathes; }
    
    public function setViewHelperPathes($inPathes) { $this->_viewHelperPathes = $inPathes; }
    
    public function setViewHelperPrefixes($inPrefixes) { $this->_viewHelperPrefixes = $inPrefixes; }
    
    public function setLayoutPath($inPathes) { $this->_layoutPathes = $inPathes; }
    
    public function setJsPath($inPathes) { $this->_jsPath = $inPathes; }
    
    public function setCssPath($inPathes) { $this->_cssPath = $inPathes; }
    
    // ADD
    
    public function addViewPath($inPath) { $this->_viewPathes[] = $inPath; }
    
    public function addViewHelperPath($inPath) { $this->_viewHelperPathes[] = $inPath; }
    
    public function addViewHelperPrefix($inPrefix) { $this->_viewHelperPrefixes[] = $inPrefix; }
    
    // GET
    
    public function getViewPathes() { return $this->_viewPathes; }
    
    public function getViewHelperPathes() { return $this->_viewHelperPathes; }
    
    public function getViewHelperPrefixes() { return $this->_viewHelperPrefixes; }
    
    public function getLayoutPath() { return $this->_layoutPathes; }
    
    public function getJsPath() { return $this->_jsPath; }
    
    public function getCssPath() { return $this->_cssPathes; }
}

Code source du fichier de démarrage (public\index.php)

Code:

<?php

// Define path to application directory
defined('APPLICATION_PATH')
    || define('APPLICATION_PATH', realpath(dirname(__FILE__) . '/../application'));

// Define application environment
defined('APPLICATION_ENV')
    || define('APPLICATION_ENV', (getenv('APPLICATION_ENV') ? getenv('APPLICATION_ENV') : 'production'));

// Ensure library/ is on include_path
set_include_path(implode(PATH_SEPARATOR, array(
    realpath(APPLICATION_PATH . '/../library'),
    get_include_path(),
)));

/** Zend_Application */
require_once 'Zend/Application.php';

// Create application, bootstrap, and run
$application = new Zend_Application(
    APPLICATION_ENV,
    APPLICATION_PATH . '/configs/application.ini'
);

$application->bootstrap()
            ->run();

Code source de la classe d'amorçage (application\Bootstrap.php)

Code:

<?php

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
    /**
     * Cette méthode identifie le type de terminal utilisé par l'internaute.
     * @return La méthode retourne le type de terminal: 'standard', ou n'importe quelle valeur configurée dans le fichier d'initialisation de l'application ("application.ini").
     * @remark Le code a été volontairement allégé.
     *         Évidemment, la détection du terminal devrait être dynamique.
     */
    protected function _initTerminal()
    {
        // Plus réaliste:
        // $useragent = get_browser($_SERVER['HTTP_USER_AGENT'], true);
        // ...
        $terminal = 'iphone';
        
        // Retourne le type de terminal détecté.
        // Le type de terminal sera stocké dans le registre, associé à la clé "terminal".
        return $terminal;
    }
}

Code source du contrôleur d'index (application\controllers\IndexController.php)

Code:

<?php

class IndexController extends Zend_Controller_Action
{
    private $__boostrap = null;
    
    public function init()
    {
        $this->__boostrap = $this->getInvokeArg('bootstrap'); 
    }

    public function indexAction()
    {
        // On extrait le type de terminal qui a été stocké dans le registre lors de la phase d'amorçage de l'application. (Bootstrap/_initTerminal()).
        // http://framework.zend.com/manual/fr/zend.application.theory-of-operation.html
        // Note: CF fichier Bootstrap.php.
        $terminal = $this->__boostrap->getResource('terminal');
        $this->view->terminal = $terminal;
        
        // On extrait les paramètres de configuration des vues.
        $terminalView = $this->__boostrap->getResource('terminalViews');
        // var_dump($terminalView); // Pour tester que l'objet assicié à la resource est accessible.

        // On spécifie que l'on désire utiliser un gabarit "simple" (une page non découpée en zones).
        // Il est possible de choisir parmi différents gabarits, suivant l'organisation que l'on souhaite donner à la page.
        // Tous les gabarits utilisés doivent, évidemment, être présents dans le répertoire des gabarits associé au terminal courant.
        $this->_helper->layout->setLayout('plain');
    }
}

Code source du gabarit associé à l'Iphone (application\layouts\iphone\plain.phtml)

Code:

<?php echo $this->doctype() ?>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>

  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> 
  <?php echo $this->headTitle('Page title'); ?>

</head>
<body>

<h1><?php echo $this->escape('Gabarit "plein" pour terminal Iphone.')?></h1>

<?php echo $this->layout()->content; ?>

</body>
</html>

Code source du gabarit associé au terminal standard (application\layouts\standard\plain.phtml)

Code:

<?php echo $this->doctype() ?>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>

  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> 
  <?php echo $this->headTitle('Page title'); ?>

</head>
<body>

<h1><?php echo $this->escape('Gabarit "plein" pour terminal standard.')?></h1>

<?php echo $this->layout()->content; ?><p/>


</body>
</html>

Code source de la vue "application\views\standard\scripts\index\index.phtml"

Code:

<?php echo $this->escape('Ceci est la vue "index.phtml" du controleur "index" STANDARD.'); ?><p/>

<b>Terminal = <?php echo $this->terminal; ?></b><p/>
<?php echo $this->tagger(); ?><p/>
<?php echo $this->special(); ?>

Code source de la vue "application\views\iphone\scripts\index\index.phtml"

Code:

<?php echo $this->escape('Ceci est la vue "index.phtml" du controleur "index" IPHONE.'); ?><p/>

<b>Terminal = <?php echo $this->terminal; ?></b><p/>
<?php echo $this->tagger(); ?><p/>

<!-- L'aide de vue "special" n'est définie que pour le terminal standard. -->
<?php echo $this->special(); ?>

Code source de l'aide de vue "application\views\standard\helpers\Tagger.php"

Code:

<?php

class Standard_View_Helper_Tagger
{
    public function tagger() { return 'This is the view helper for the Standard terminal!'; }
}

Code source de l'aide de vue "application\views\standard\helpers\Special.php"

Code:

<?php

class Standard_View_Helper_Special
{
    public function special() { return 'This is the special view helper for the Standard terminal!'; }
}

Code source de l'aide de vue "application\views\iphone\helpers\Tagger.php"

Code:

<?php

class Iphone_View_Helper_Tagger
{
    public function tagger() { return 'This is the view helper for the Iphone terminal!'; }
}

Les autres fichiers sont standards.

Les points importants sont :

Dans le fichier ".ini":

resources.view =
pluginPaths.My_Resources = APPLICATION_PATH "/../library/My/Resources"
autoloadernamespaces.0 = "My"

Même si une ressource ne nécessite pas de paramétrage, elle doit toutefois être déclarée dans le fichier d'initialisation de l'application. Si le greffon de ressource n'avait pas besoin de paramétrage, il aurait été obligatoire d'ajouter la ligne suivante ci-dessous :

Code:

resources.terminalViews =

Bon, voici qui devrait éclaircir l'utilisation des greffons de ressource, et d'autres composant de la trousse à outils ZF.


Maintenant, je vais intégrer au greffon le support des modules.

A+

Dernière modification par Denis. Beurive (05-10-2010 19:44:10)

Hors ligne

 

#9 05-10-2010 21:15:16

Delprog
Administrateur
Date d'inscription: 29-09-2008
Messages: 670

Re: [Résolu] [Greffon de ressource] Pourquoi et comment les utiliser?

Salut,

Quelques remarques.

Tu pourrais automatiser la détection du User Agent directement dans le plugin de ressource pour privilégier l'utilisation du fichier de configuration plutôt qu'une méthode d'initialisation du bootstrap.

Dans ce cas on peut imaginer un paramètre dans la configuration qui forcerait le type de terminal si nécessaire.

Concernant l'initialisation du layout depuis le contrôleur d'actions, c'est typiquement le genre de code qui va être redondant d'un contrôleur à l'autre. Tu pourrais évidemment créer un contrôleur d'actions générique qui inclue ces opérations, mais l'utilisation d'un plugin de contrôleur, ou d'un helper d'action permettrait d'automatiser ce traitement. J'opterais pour un plugin puisqu'il s'agit d'une initialisation plus que d'une opération du ressort des contrôleurs d'actions.

Mis à part ça, je suis sur que cet exemple servira à certains d'entre nous, merci de le partager et c'est très appréciable de voir comme tu t'appliques dans tes explications (suffisamment rare pour être souligné) smile


A+ benjamin.

http://www.anonymation.com/ - anonymation - Studio de création.
http://code.anonymation.com/ - anonymation - blog - développement et architecture web

Hors ligne

 

#10 05-10-2010 22:21:55

Denis. Beurive
Membre
Date d'inscription: 06-06-2009
Messages: 35

Re: [Résolu] [Greffon de ressource] Pourquoi et comment les utiliser?

Delprog a écrit:

Salut,

Quelques remarques.

Tu pourrais automatiser la détection du User Agent directement dans le plugin de ressource pour privilégier l'utilisation du fichier de configuration plutôt qu'une méthode d'initialisation du bootstrap.

Dans ce cas on peut imaginer un paramètre dans la configuration qui forcerait le type de terminal si nécessaire.

Concernant l'initialisation du layout depuis le contrôleur d'actions, c'est typiquement le genre de code qui va être redondant d'un contrôleur à l'autre. Tu pourrais évidemment créer un contrôleur d'actions générique qui inclue ces opérations, mais l'utilisation d'un plugin de contrôleur, ou d'un helper d'action permettrait d'automatiser ce traitement. J'opterais pour un plugin puisqu'il s'agit d'une initialisation plus que d'une opération du ressort des contrôleurs d'actions.

Mis à part ça, je suis sur que cet exemple servira à certains d'entre nous, merci de le partager et c'est très appréciable de voir comme tu t'appliques dans tes explications (suffisamment rare pour être souligné) smile


A+ benjamin.

Salut,

Effectivement, j'avais l'intention d'intégrer au greffon la procédure de détection du terminal. Il n'y a aucune raison de l'externaliser de la sorte. En fait, je l'ai externalisé pour tester l'initialisation de ressource, non pas au sein d'un greffon, mais directement dans la classe d'amorçage.

L'idée d'un paramètre de configuration pour forcer un terminal particulier est une bonne idée. Cele faciliterait les tests. Je me demande d'ailleurs s'il existe un "simulateur de navigateur d'Iphone", qui tournerait sur PC.

En ce qui concerne les contrôleurs et les aides d'action, je n'ai pas encore abordé cet aspect de l'implémentation de patron de conception MVC de ZEND. Mais, effectivement, la mise à disposition d'un outil pour effectuer la configuration du gabarit associé à l'action est indispensable.

Pour information, cette organisation en "vues dédiées à certains types de terminaux" est inspirée de l'implémentation de ELGG. Du "point de vue MVC", ELGG est exemplaire. L'implémentation MVC de ZEND est beaucoup plus souple, mais nécessite d'être adaptée (c'est normal car le framework ZEND est découplé de toute utilisation particulière).

Il serait bon que ZEND propose un composant dédié au paramétrage d'une application, en fonction du terminal utilisé par l'internaute. Aujourd'hui cette problématique est incontournable.

A+

Hors ligne

 

 

Pages: 1

Pied de page des forums

Propulsé par PunBB
© Copyright 2002–2005 Rickard Andersson
Traduction par punbb.fr

Graphisme réalisé par l'agence Rodolphe Eveilleau
Développement par Kitpages