[ZF 1.11] Problème de routage avec Zend_Controller_Router_Route_Regex [Résolu]

[bpdelavega]

Bonjour,

Dans une application disposant de plusieurs modules, j'ai paramétré sur le module Frontend un certain nombre de routes de type Zend_Controller_Router_Route_Regex. Chaque route appelle son propre controlleur et sa propre action.
Le problème c'est toujours le même controlleur qui est rendu (le dernier) voici le contenu du fichier de configuration (j'utilise Zend_Application).

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
; Rewrite
;Home
resources.router.routes.home.type = "Zend_Controller_Router_Route_Regex"
resources.router.routes.home.route = "(.+)"
resources.router.routes.home.defaults.module = "frontend"
resources.router.routes.home.defaults.controller = "index"
resources.router.routes.home.defaults.action = "index"
resources.router.routes.home.map.l = "label"
resources.router.routes.home.map.l.default = "toto.html"
resources.router.routes.home.reverse = "index.html"
 
;Rooms
resources.router.routes.rooms.type = "Zend_Controller_Router_Route_Regex"
resources.router.routes.rooms.route = "(.+)"
resources.router.routes.rooms.defaults.module = "frontend"
resources.router.routes.rooms.defaults.controller = "rooms"
resources.router.routes.rooms.defaults.action = "index"
resources.router.routes.rooms.map.1 = "label"
resources.router.routes.rooms.reverse = "chambre.html"
 
;Features
resources.router.routes.features.type = "Zend_Controller_Router_Route_Regex"
resources.router.routes.features.route = "(.+)"
resources.router.routes.features.defaults.module = "frontend"
resources.router.routes.features.defaults.controller = "features"
resources.router.routes.features.action = "index"
resources.router.routes.features.map.1 = "label"
resources.router.routes.features.reverse = "prestations.html"
 
;Location
resources.router.routes.location.type = "Zend_Controller_Router_Route_Regex"
resources.router.routes.location.route = "(.+)"
resources.router.routes.location.defaults.module = "frontend"
resources.router.routes.location.defaults.controller = "location"
resources.router.routes.location.defaults.action = "index"
resources.router.routes.location.map.1 = "label"
resources.router.routes.location.reverse = "acces.html"

Quand j'appelle mes routes via mon objet Zend_Navigation, l'url est bonne mais le rendu correspond toujours au controlleur "location"

Je ne sais pas comment faire pour corriger ce problème.

[Nighty]

De la façon dont tu as configuré tes routes (resources.router.routes.home.route = "(.+)") elles "matchent" n'importe quel appel, donc quel que soit l'url saisie, cette route sera donc valide.

Comme tes trois routes sont dans ce cas, c'est la dernière dans la liste qui "matche" en premier dans tous les cas, les autres sont ignorées.

Qu'est-ce que tu voulais exactement comme url pour chacun de tes contrôleurs ?

[bpdelavega]

Merci Nighty pour ta réponse :
En fait j'ai bien compris le problème, la recherche se fait en LIFO, et il scane les "routes" donc comme toutes matches, il s'arrête à la première.

Je t'explique mon problème : je te précise déjà que je connais plutôt bien ZF, mais j'ai du mal avec le Router.

J'ai fait un site avec un Frontend et un Backend, qui ressemble un peu à un CMS, au début de l'application, pour aller vite, et m'occuper de cela plus tard, je rentrais mes URLS en dur dans mon fichier de config. Depuis j'ai fait un module de gestion des pages, et j'aimerai lui passer l'url stockée en BD.

Cela est important pour moi, car ce n'est pas moi qui administrerai le site, donc je veux pouvoir laisser la main aux gens pour spécifier l'url voulue.

Donc j'ai commencé à modifier mon fichier de config pour permettre cette possibilité et c'est là que ça coince. Faire en sorte que l'url soit dynamique car provenant de la BD.

Voici ce que j'avais fait au départ :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
; Rewrite
;Home
resources.router.routes.home.route = "/index.html"
resources.router.routes.home.defaults.module = "frontend"
resources.router.routes.home.defaults.controller = "index"
resources.router.routes.home.defaults.action = "index"
 
;Rooms
resources.router.routes.rooms.route = "/chambre.html"
resources.router.routes.rooms.defaults.module = "frontend"
resources.router.routes.rooms.defaults.controller = "rooms"
resources.router.routes.rooms.defaults.action = "index"
 
;Features
resources.router.routes.features.route = "/prestations.html"
resources.router.routes.features.defaults.module = "frontend"
resources.router.routes.features.defaults.controller = "features"
resources.router.routes.features.defaults.action = "index"
 
;Location
resources.router.routes.location.route = "/acces.html"
resources.router.routes.location.defaults.module = "frontend"
resources.router.routes.location.defaults.controller = "location"
resources.router.routes.location.defaults.action = "index"
 
;Contact
resources.router.routes.contact.route = "/contact.html"
resources.router.routes.contact.defaults.module = "frontend"
resources.router.routes.contact.defaults.controller = "contact"
resources.router.routes.contact.defaults.action = "index"
 
;Sitemap HTML
resources.router.routes.sitemaphtml.route = "/sitemap.html"
resources.router.routes.sitemaphtml.defaults.module = "frontend"
resources.router.routes.sitemaphtml.defaults.controller = "sitemap"
resources.router.routes.sitemaphtml.defaults.action = "index"
 
;Sitemap XML
resources.router.routes.sitemapxml.route = "/sitemap.xml"
resources.router.routes.sitemapxml.defaults.module = "frontend"
resources.router.routes.sitemapxml.defaults.controller = "sitemap"
resources.router.routes.sitemapxml.defaults.action = "sitemap"

[Nighty]

Comme tu as pu le constater, le Zend Framework fournit les outils pour écrire des routes personnalisées mais laisse libre d'implémenter soi même les mécanismes pour automatiser la création de route via une interface.

A mon avis tu as, dans les grandes lignes, deux solutions :

Soit créer ta propre route en implémentant Zend_Controller_Router_Route_Interface, qui se chargera de trouver le module / contrôleur / action / paramètres dans la base de données. Cette solution peut à mon avis poser des soucis de performances, il faudrait faire quelques benchs...

Soit tu peux permettre à ton interface de modifier le fichier de configuration de tes routes : stocke les en dehors de ton application.ini, et écrit dans ce fichier à chaque fois que quelqu'un modifie les routes. Ensuite fait en sorte que ce fichier de configuration soit bien chargé par l'application au démarrage... Il se peut que si il y a beaucoup de routes différentes les performances soient aussi impactées (si il y a 150 routes, ça veut dire jusqu'à 150 appels à la méthode match() par page, contre un seul pour le cas précédent).

[bpdelavega]

Merci pour ta réponse,

j'avais pensé à la solution 1 que je préfère, je peux passer par du cache pour optimiser les perfs, je voulais juste être sûr qu'il n'y avait pas déjà une solution ZF qui existait avant de m'engager dans le dev.

donc j'implémente la classe Zend_Controller_Router_Route_Interface :
je précise que j'ai fait en sorte d'avoir toutes les infos dans la BD et ils sont également contenues dans le Registre (pour construire ma nav). Donc je peux parcourir le registre pour construire à la volée mes routes, je vais utiliser un plugin sur le RouteShutdown, qu'en penses tu ?

[bpdelavega]

En voulant créer moi-même mon propre routeur, je rencontre d'énormes difficultés, voici mon code :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
 
<?php
 
class App_Controller_Router extends Zend_Controller_Router_Abstract implements Zend_Controller_Router_Interface 
{
    public function route(Zend_Controller_Request_Abstract $dispatcher)
    {
        /**
         * @todo Replace with Zend_Request object
         */
        $path = $_SERVER['REQUEST_URI'];
        if (strstr($path, '?')) {
            $path = substr($path, 0, strpos($path, '?'));
        }
 
		//Une fois qu'on a l'url on va la chercher en DB
		//print_r($path);exit;
 
        $path = explode('/', trim($path, '/'));
 
        /**
         * The controller is always the first piece of the URI, and
         * the action is always the second:
         *
         * http://zend.com/controller-name/action-name/
         */
        $controller = $path[1];
        $action     = isset($path[2]) ? $path[2] : null;
 
        /**
         * If no controller has been set, IndexController::index()
         * will be used.
         */
        if (!strlen($controller)) {
           $module = 'frontend';
           $controller = 'index';
           $action = 'index';
        }
 
        /**
         * Any optional parameters after the action are stored in
         * an array of key/value pairs:
         *
         * http://www.zend.com/controller-name/action-name/param-1/3/param-2/7
         *
         * $params = array(2) {
         *              ["param-1"]=> string(1) "3"
         *              ["param-2"]=> string(1) "7"
         * }
         */
        $params = array();
        for ($i=3; $i<sizeof($path); $i=$i+3) {
            $params[$path[$i]] = isset($path[$i+1]) ? $path[$i+1] : null;
        }
 
        $actionObj = new Zend_Controller_Dispatcher_Standard($module, $controller, $action, $params);
 
        if (!$dispatcher->isDispatchable($actionObj)) {
            /**
             * @todo error handling for 404's
             */
           throw new Zend_Controller_Router_Exception('Request could not be mapped to a route.');
       } else {
           return $actionObj;
       }
    }
 
    public function assemble($userParams, $name = null, $reset = false, $encode = true)
	{}
 
    public function getFrontController()
	{}
 
    public function setFrontController(Zend_Controller_Front $controller)
	{}
 
    public function setParam($name, $value)
	{}
 
    public function setParams(array $params)
	{}
 
    public function getParam($name)
	{}
 
    public function getParams()
	{}
 
    public function clearParams($name = null)
	{}
 
    public function addRoute($name, Zend_Controller_Router_Route_Interface $route)
	{}
}

J'ai le message d'erreur suivant

Fatal error: Call to undefined method Zend_Controller_Request_Http::isDispatchable()

Quand je mets en commentaires la ligne fautive, j'ai des erreurs sur le dossier des controllers, des layouts, enfin bref, tout part en "sucette" !!
Quelqu'un a t'il déjà fait ce travail ?

[bpdelavega]

Je n'ai pas réussi à réécrire le routeur, cela entrainait trop de modifications dans mon appli, du coup, j'ai contourné le problème de ma route regexp en rajoutant un chiffre à la fin de chaque route afin de les différencier, et cela fonctionne nickel.

J'arrive bien à récupérer les url qui proviennent de la BD, les bons controlleurs et les bonnes actions sont chargées. Par contre en poussant un peu plus loin, j'ai voulu mettre des "fr/index-1.html" et en fait le "/" est remplacé par des "%252F", quelqu'un a-t'il une idée pour résoudre ce problème ?

D'avance merci pour votre aide.

[bpdelavega]

Bonjour,

J'ai des URLS stockées en BD, qui ont la forme "mot/mot2.html" et chose bizarre, dans le code source, le "mot1/mot2.html" est remplacé par "mot1%2Fmot2.html et quand on clique sur le lien, il y a une sorte de redirection qui est faite avec au final l'url suivante : "mot1%252Fmot2.html" avec bien-sûr une belle erreur 404 qui sort complètement du site !

Je ne sais pas si le problème vient de mod_rewrite d'Apache, ou d'un traitement à faire en PHP, d'avance merci pour votre aide. (désolé pour les modérateurs, j'ai posté dans Apache et ZF car je ne sais pas d'où vient le souci).

Je précise que j'utilse Zend Framework, PHP 5.2, Apache 2 et Zend_Server 5 et MySQL5.1

[bpdelavega]

Je me réponds à moi même :

Il s'agit un comportement du composent Zend_Navigation_Page_Mvc, qui encore dans le méthode $page->getHref() les caractères spéciaux.

J'ai utilisé l'autre compostant Zend_Navigation_Page_Uri et je n'ai plus ce problème.

[Nighty]

Réponse tardive, je n'ai pas pu repasser sur le forum plus tôt.

Deux choses :
- La première, je pense que tu te complique énormément la vie : ton besoin est au final assez simple, et tu n'as à mon avis pas besoin ni d'un registre, ni d'un plugin quelconque, simplement d'une route adaptée.
- La seconde, tu as confondu définir une classe de route personnalisée (implémentant Zend_Controller_Router_Route_Interface de façon générale, ou Zend_Controller_Router_Route_Abstract si tu veux utiliser un début d'implémentation fournit par le Zend Framework) et implémenter un routeur personnalisé (implémentant Zend_Controller_Router_Interface).

Implémenter un routeur maison est un travail beaucoup plus complexe, qui ne se justifie que si le système de routage du Zend Framework ne convient pas pour ton application. Autant dire qu'avant de se lancer dans l'aventure, il vaut mieux savoir vers quoi on se dirige car tu n'es plus capable d'utiliser le système "historique" du Zend Framework.

Je ne suis pas sûr d'être hyper clair à me relire, dis le moi si je suis obscur j'essayerais de répondre en moins de 3 jours cette fois

[bpdelavega]

Effectivement j'étais pendu à ta réponse
Du coup j'ai procédé autrement, je passe par un plugin en en preDispatch, et je construit des Zend_Navigation_Page_Uri à la volée :

je parcours mes pages en BD, je construit un tableau qui au lieu d'avoir les valeurs MVC classiques (module/controlleur/action) a les valeurs URI : j'en déduis un objet Zend_Navication (container), que je mets en registre.

Quand j'ai besoin de générer le menu, le breadcrumbs, le sitemap, j'appelle le container en Registre.

Le petit travail supplémentaire à faire, c'est de détecter la page active, car comme tu dois le savoir, les objets Zend_Navigation_Page_Uri ne sont pas capables de détecter la page active, du coup, je parse la request URI et je fais un "findOneBy" dans mon container et c'est bon. Voici le code mon plugin :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
 
class Plugin_SetFrontendUrl 
    extends Zend_Controller_Plugin_Abstract
{
 
	public function preDispatch(Zend_Controller_Request_Abstract $request)
    {    
    	$controller = $request->getControllerName();
		$module     = $request->getModuleName();
 
		//Cas particuliers 
		$requestUri = $request->getRequestUri();
 
		if('frontend' == $module){
 
		    //Index en Anglais
			if($requestUri == DOSSIER_SITE){
				$langage = 'en_US';
				$model = new Frontend_Model_Vinfospage();
		        $mapper = new Frontend_Model_VinfospageMapper();	              
		        $arrPages = $mapper->findByLangue($langage, $model, true);   
		        $mapPage = self::mapPagesURI($arrPages, $langage); 
		        $container = new Zend_Navigation($mapPage);
 
		        $idPage = (int) App_Tools::getIdPageFrontByRouteAndByLangue('home', $langage);
		        $pageActive = $container->findOneBy('id_page', $idPage);
		        $pageActive->setActive();
 
				//MAJ de la locale dans le registre
				$translate = Zend_Registry::get('Zend_Translate');        	
	            $session = Zend_Registry::get('Session');           
	            $translate->setLocale($langage);              
	            Zend_Registry::set('Zend_Translate', $translate);
	            Zend_Registry::set('Zend_Locale', $langage);
 
		        Zend_Registry::set('navigation_front', $container);
		        return true;
			}
 
			//Index en Anglais
			if($requestUri == DOSSIER_SITE . 'index.html'){
				$langage = 'en_US';
				$model = new Frontend_Model_Vinfospage();
		        $mapper = new Frontend_Model_VinfospageMapper();	              
		        $arrPages = $mapper->findByLangue($langage, $model, true);   
		        $mapPage = self::mapPagesURI($arrPages, $langage); 
		        $container = new Zend_Navigation($mapPage);
 
		        $pageActive = App_Tools::getActivePage($request, $container);
 
				//MAJ de la locale dans le registre
				$translate = Zend_Registry::get('Zend_Translate');        	
	            $session = Zend_Registry::get('Session');           
	            $translate->setLocale($langage);              
	            Zend_Registry::set('Zend_Translate', $translate);
	            Zend_Registry::set('Zend_Locale', $langage);
 
		        Zend_Registry::set('navigation_front', $container);
		        return true;
			}
 
		    //Index en Francais
			if($requestUri == DOSSIER_SITE . '/fr/'){
				$langage = 'fr_FR';
				$model = new Frontend_Model_Vinfospage();
		        $mapper = new Frontend_Model_VinfospageMapper();	              
		        $arrPages = $mapper->findByLangue($langage, $model, true);   
		        $mapPage = self::mapPagesURI($arrPages, $langage); 
		        $container = new Zend_Navigation($mapPage);
 
		        $pageActive = App_Tools::getActivePage($request, $container);
 
				//MAJ de la locale dans le registre
				$translate = Zend_Registry::get('Zend_Translate');        	
	            $session = Zend_Registry::get('Session');           
	            $translate->setLocale($langage);              
	            Zend_Registry::set('Zend_Translate', $translate);
	            Zend_Registry::set('Zend_Locale', $langage);
 
		        Zend_Registry::set('navigation_front', $container);
		        return true;
			}
 
		    //Index en Francais
			if($requestUri == DOSSIER_SITE . 'fr/index.html'){
 
			    $langage = 'fr_FR';
				$model = new Frontend_Model_Vinfospage();
		        $mapper = new Frontend_Model_VinfospageMapper();	              
		        $arrPages = $mapper->findByLangue($langage, $model, true);   
		        $mapPage = self::mapPagesURI($arrPages, $langage); 
		        $container = new Zend_Navigation($mapPage);
 
		        $pageActive = App_Tools::getActivePage($request, $container);
 
				//MAJ de la locale dans le registre
				$translate = Zend_Registry::get('Zend_Translate');        	
	            $session = Zend_Registry::get('Session');           
	            $translate->setLocale($langage);              
	            Zend_Registry::set('Zend_Translate', $translate);
	            Zend_Registry::set('Zend_Locale', $langage);
 
		        Zend_Registry::set('navigation_front', $container);
		        return true;
			}		
 
			$langage = App_Tools::getPageActiveLangue($request);       
 
	    	if(Zend_Registry::isRegistered('Zend_Locale')){
 
	        	$model = new Frontend_Model_Vinfospage();
		        $mapper = new Frontend_Model_VinfospageMapper();	              
		        $arrPages = $mapper->findByLangue($langage, $model, true);   
		        $mapPage = self::mapPagesURI($arrPages, $langage); 
		        $container = new Zend_Navigation($mapPage);
 
		        $pageActive = App_Tools::getActivePage($request, $container);
 
				//MAJ de la locale dans le registre
				$translate = Zend_Registry::get('Zend_Translate');        	
	            $session = Zend_Registry::get('Session');
	            $locale = $session->locale = $langage;
 
	            $translate->setLocale($langage);        
	            Zend_Registry::set('Session', $session);        
	            Zend_Registry::set('Zend_Translate', $translate);
	            Zend_Registry::set('Zend_Locale', $langage);
 
		        Zend_Registry::set('navigation_front', $container);
	        }
		}
    }
 
    protected function mapPagesURI(array $listePages, $langue)
    {
    	$count = count($listePages);
 
    	$locale = $langue;
        $langUrl = substr($locale, 0,2);
 
    	if($count){
    		foreach($listePages as $line):
 
    			if($line->getNom_page()!='Contact'){
 
    			$baseUrl = DOSSIER_SITE;               
    			if($langUrl != 'en'){
            		$baseUrl = DOSSIER_SITE . $langUrl . '/';
            	}
 
    				$arrPages[] = array(
	    					'label' => $line->getNom_page(),
		    				'uri' => (trim($line->getUrl_page()) != '') ? ($baseUrl . $line->getUrl_page()) : $baseUrl . 'index.html',	    				
		    				'ordre' => $line->getOrdre(),
		    				'visible' => $line->getMenu(),
		    				'changefreq' => $line->getXml_changefreq(),
		    				'priority' => $line->getXml_priority(),
		    				'lastmod' => $line->getXml_lastmod(),
	    					'langue' => $line->getKey_langue(),
	    					'id_page' => $line->getId_page()
	    				);
    			}else{
        			$baseUrl = DOSSIER_SITE;
    			    if($langUrl != 'en'){
                		$baseUrl = DOSSIER_SITE . $langUrl . '-';
                	}
    				$arrPages[] = array(
	    					'label' => $line->getNom_page(),
		    				'uri' => (trim($line->getUrl_page()) != '') ? ($baseUrl . $line->getUrl_page()) : $baseUrl . 'index.html',	    				
		    				'ordre' => $line->getOrdre(),
		    				'visible' => $line->getMenu(),
		    				'changefreq' => $line->getXml_changefreq(),
		    				'priority' => $line->getXml_priority(),
		    				'lastmod' => $line->getXml_lastmod(),
	    					'langue' => $line->getKey_langue(),
    						'id_page' => $line->getId_page()
	    				);
    			}
    		endforeach;    		
    	}
 
    	$result[0] = array(
    				'label' => 'home',
    				'uri' => 'index.html',
    				'ordre' => '0',
    				'visible' => '1',
    				'changefreq' => 'always',
    				'priority' => '1',
    				'lastmod' => '2011-06-10', 
    				'langue' => $langue,   				
    				'pages' => $arrPages,
    				'id_page' => (int) App_Tools::getIdPageFrontByRouteAndByLangue('home', $langue)
    			  );
 
    	return $result;
    }

Par ailleurs j'utilise aussi ce plugin pour 'loader' la bonne valeur de locale directement en fonction de l'url de la page, car auparavant, je déclenchais le swap de langue par action de l'utilisateur, sur un switcheur de langues classique. Or pour le référencement, pour éviter des contenus dupliqués, j'ai absolument besoin de détecter la langue (qui est paramétrée pour chaque page) et de modifier la valeur du registre Zend_Locale. Si bien que si on tape une URL directement, le site se charge dans la bonne langue.

Enfin, il me reste un petit souci à régler, certaines pages (une page en particulier) plante, car elle n'arrive pas à charger le menu provenant du registre, je suis en train de plancher dessus.

Dis moi si tu remarques des choses qui vont pas dans mon plugin, je précise qu'il fonctionne bien, mais peut-être vois tu des choses non optimisées ...

Dans tous les cas, merci pour avoir pris la peine de m'aider

[Nighty]

Je t'avouerais que je n'ai pas décortiqué ton code à 300%, mais outre le fait qu'en créant une route "maison" ça serait je pense plus élégant, si la solution fonctionne en l'état, n'est pas un gouffre de performance et convient à l'utilisation qui en fait c'est l'essentiel.

Le principal problème que je vois c'est que tu perds la possibilité d'utiliser le routeur pour générer des liens dynamiquement à partir des routes.


Par contre quelques remarques sur le code :

Tes tests pour détecter la langue, tu cours droit à de gros soucis à chaque fois que tu vas remettre en question quelles urls concernent quelles locales, et je ne te parle pas à chaque fois que tu ajouteras une lange supplémentaire... Je serais toi, j'isolerais ce test dans une méthode à part avec un switch pour tester le requestUri : ça sera déjà plus simple à maintenir et à faire évoluer.


Tu pourrais aussi factorise un bon 60% de la méthode direct() : il y a beaucoup de code dupliqué, jusqu'à 4 fois, tu pourrais rendre ça beaucoup plus simple pour le coup

Après, c'est peut-être un premier jet et tu t'apprêtais à faire un refactoring...

[bpdelavega]

En fait c'est surtout parce que je suis pressé, et c'est effectivement une V0
mais je suis bien intéressé par ton histoire de route, mais j'ai besoin d'un exemple
quand j'ai essayé, c'est parti dans tous les sens...
Au départ j'ai utilisé les routes MVC qui m'allaient très bien sauf que lorsque j'ai commencé à mettre des url personnalisées, cela ne fonctionnait plus du tout, concernant les perfs, j'ai pas encore eu le temps de travailler sur la mise en cache des datas, mais je vais le faire, concernant le contrôle des langues, comment gère tu la bonne sélection de la template en fct de l'url ?

D'avance merci pour tes réponses

[Nighty]

Concernant la gestion des langues, c'est un problème que je n'ai jamais vraiment eut l'occasion d'approfondir avec le Zend Framework, donc je ne peux pas t'apporter d'informations très concrètes.

Par contre c'est gérable en utilisant un plugin très simple et en "chaînant" les routes, comme tu peux le voir ici : http://www.m4d3l-network.com/develop...ework-project/

Par contre je ne comprends pas trop le besoin de changer de template en fonction de la langue ? A moins que tu ais une présentation différente pour chaque pays, ce qui m'étonnerait, il vaut mieux utiliser Zend_Translate pour traduire les chaînes au sein d'un template que de dupliquer les templates pour chaque langue.


Pour un exemple de route, j'essaye de trouver le temps cette semaine pour en écrire un, des urgences m'ont un peu pris de cours ce week-end

[Nighty]

Avec à peine une semaine de retard, chose promise... Bien entendu la route est très basique, à peaufiner avec plus de contrôle, une mise en cache, elle ne gère pas les paramètres...

Soit la table MySQL :

Code :

1
2
3
4
5
6
7
8
9
CREATE TABLE route(
    id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
    route VARCHAR(50) NOT NULL,
    module VARCHAR(50) NOT NULL,
    controller VARCHAR(50) NOT NULL,
    action VARCHAR(50) NOT NULL
);
 
INSERT INTO route(route, module, controller, action) VALUES('article.html', 'default', 'article', 'index');

Soit l'objet Zend_Db_Table :

Code :

1
2
3
4
class Application_Model_DbTable_Route extends Zend_Db_Table_Abstract
{
    protected $_name = 'route';
}

Et la configuration de la route dans l'application.ini :

Code :

1
2
autoloaderNamespaces.my = "My"
resources.router.routes.db.type = "My_Controller_Router_Route_Db"

Voici la route qui permet d'accéder à /default/article/index via /article.html :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
class My_Controller_Router_Route_Db
extends Zend_Controller_Router_Route_Abstract
{   
    /**
     * 
     * @var Zend_Db_Table_Abstract
     */
    protected $_table;
 
    /**
     * 
     * @var array
     */
    protected $_variables = array();
 
    /**
     * 
     * @return Zend_Db_Table_Abstract
     */
    public function getTable()
    {
        if (null === $this->_table) {
            $this->_table = new Application_Model_DbTable_Route();
        }
 
        return $this->_table;
    }
 
    /**
     * @param Zend_Db_Table_Abstract $table
     * @return My_Controller_Router_Route_Db
     */
    public function setTable($table)
    {
        $this->_table = $table;
        return $this;
    }
 
	static public function getInstance(Zend_Config $config)
    {   
        return new My_Controller_Router_Route_Db();
    }
 
    public function assemble($data = array(), $reset = false, $encode = false)
    {
        $table = $this->getTable();        
        $select = $table->select();
 
        if ($reset) {
            $variables = array();
        } else {
            $variables = $this->_variables;
        }
 
        foreach ($data as $key => $value) {
            $variables[$key] = $value;
        }
 
        $select->where('module = ?', $variables['module'])
               ->where('controller = ?', $variables['controller'])
               ->where('action = ?', $variables['action']);
 
        $route = $select->fetchAll()
                        ->current();
 
        if (null === $route) {
            throw new InvalidArgumentException("Cette route n'existe pas");
        }
 
        return $route->route;
    }
 
    public function match($path)
    {
        $path = trim($path->getRequestUri(), '/');
        $table = $this->getTable();
 
        $select = $table->select()
                        ->where('route = ?', $path);
 
        $route = $table->fetchAll($select)
                       ->current();
 
        if (null === $route) {
            return false;
        }
 
        $this->_variables['module'] = $route->module;
        $this->_variables['controller'] = $route->controller;
        $this->_variables['action'] = $route->action;
        return $this->_variables;
    }
}

Le fonctionnement est assez simple, on implémente les 3 méthodes de l'interface Zend_Controller_Router_Route_Interface :
* getInstance retourne une instance de la route.
* assemble récupère des données et assemble une route à partir de celles-ci (utilisé notamment par Zend_Navigation et l'helper de vue url()).
* match retourne les variables qui correspondent à la requête courante (controller, module, action...) ou false si la requête ne "matche" pas la route.

Je pense que sur cette base, en améliorant et en éprouvant considérablement cette route et en utilisant les fonctionnalités de "chaining", tu pourras réussir à mettre en place tout ce que tu veux sans t'empêcher d'utiliser les "Pages MVC".