source: spip-zone/_core_/plugins/urls_etendues/urls/arbo.php @ 93427

Last change on this file since 93427 was 93427, checked in by cedric@…, 5 years ago

Report de r93426 : bugfix sur les URLs des pages uniques (id_parent=-1) : on ne pouvait pas les supprimer, et leur id_parent les faisait passer devant une rubrique racine dans une recherche d'URL

File size: 22.5 KB
Line 
1<?php
2
3/***************************************************************************\
4 *  SPIP, Systeme de publication pour l'internet                           *
5 *                                                                         *
6 *  Copyright (c) 2001-2015                                                *
7 *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
8 *                                                                         *
9 *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
10 *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
11\***************************************************************************/
12
13if (!defined("_ECRIRE_INC_VERSION")) return; // securiser
14
15# donner un exemple d'url pour le formulaire de choix
16define('URLS_ARBO_EXEMPLE', '/article/titre');
17# specifier le form de config utilise pour ces urls
18define('URLS_ARBO_CONFIG', 'arbo');
19
20// TODO: une interface permettant de verifier qu'on veut effectivment modifier
21// une adresse existante
22defined('CONFIRMER_MODIFIER_URL') || define('CONFIRMER_MODIFIER_URL', false);
23
24/**
25 * - Comment utiliser ce jeu d'URLs ?
26 * Recopiez le fichier "htaccess.txt" du repertoire de base du site SPIP sous
27 * le sous le nom ".htaccess" (attention a ne pas ecraser d'autres reglages
28 * que vous pourriez avoir mis dans ce fichier) ; si votre site est en
29 * "sous-repertoire", vous devrez aussi editer la ligne "RewriteBase" ce fichier.
30 * Les URLs definies seront alors redirigees vers les fichiers de SPIP.
31 *
32 * Choisissez "arbo" dans les pages de configuration d'URL
33 *
34 * SPIP calculera alors ses liens sous la forme "Mon-titre-d-article".
35 * Variantes :
36 *
37 * Terminaison :
38 * les terminaisons ne *sont pas* stockees en base, elles servent juste
39 * a rendre les url jolies ou conformes a un usage
40 * pour avoir des url terminant par html
41 * define ('_terminaison_urls_arbo', '.html');
42 *
43 * pour preciser des terminaisons particulieres pour certains types
44 * $GLOBALS['url_arbo_terminaisons']=array(
45 * 'rubrique' => '/',
46 * 'mot' => '',
47 * 'groupe' => '/',
48 * 'defaut' => '.html');
49 *
50 * pour avoir des url numeriques (id) du type 12/5/4/article/23
51 * define ('_URLS_ARBO_MIN',255);
52 *
53 *
54 * pour conserver la casse des titres dans les url
55 * define ('_url_arbo_minuscules',0);
56 *
57 * pour choisir le caractere de separation titre-id en cas de doublon
58 * (ne pas utiliser '/')
59 * define ('_url_arbo_sep_id','-');
60 *
61 * pour modifier la hierarchie apparente dans la constitution des urls
62 * ex pour que les mots soient classes par groupes
63 * $GLOBALS['url_arbo_parents']=array(
64 *                        'article'=>array('id_rubrique','rubrique'),
65 *                        'rubrique'=>array('id_parent','rubrique'),
66 *                        'breve'=>array('id_rubrique','rubrique'),
67 *                        'site'=>array('id_rubrique','rubrique'),
68 *                              'mot'=>array('id_groupe','groupes_mot'));
69 *
70 * pour personaliser les types
71 * $GLOBALS['url_arbo_types']=array(
72 * 'rubrique'=>'', // pas de type pour les rubriques
73 * 'article'=>'a',
74 * 'mot'=>'tags'
75 * );
76 *
77 */
78
79include_spip('inc/xcache');
80if (!function_exists('Cache')) {
81        function Cache(){return null;}
82}
83
84$config_urls_arbo = isset($GLOBALS['meta']['urls_arbo'])?unserialize($GLOBALS['meta']['urls_arbo']):array();
85if (!defined('_debut_urls_arbo')) define('_debut_urls_arbo', '');
86if (!defined('_terminaison_urls_arbo')) define('_terminaison_urls_arbo', '');
87// pour choisir le caractere de separation titre-id en cas de doublon
88// (ne pas utiliser '/')
89if (!defined('_url_arbo_sep_id')) define('_url_arbo_sep_id',isset($config_urls_arbo['url_arbo_sep_id'])?$config_urls_arbo['url_arbo_sep_id']:'-');
90// option pour tout passer en minuscules
91if (!defined('_url_arbo_minuscules')) define('_url_arbo_minuscules',isset($config_urls_arbo['url_arbo_minuscules'])?$config_urls_arbo['url_arbo_minuscules']:1);
92if (!defined('_URLS_ARBO_MAX')) define('_URLS_ARBO_MAX', isset($config_urls_arbo['URLS_ARBO_MAX'])?$config_urls_arbo['URLS_ARBO_MAX']:80);
93if (!defined('_URLS_ARBO_MIN')) define('_URLS_ARBO_MIN', isset($config_urls_arbo['URLS_ARBO_MIN'])?$config_urls_arbo['URLS_ARBO_MIN']:3);
94
95if (!defined('_url_sep_id')) define('_url_sep_id',_url_arbo_sep_id);
96
97// Ces chaines servaient de marqueurs a l'epoque ou les URL propres devaient
98// indiquer la table ou les chercher (articles, auteurs etc),
99// et elles etaient retirees par les preg_match dans la fonction ci-dessous.
100// Elles sont a present definies a "" pour avoir des URL plus jolies
101// mais les preg_match restent necessaires pour gerer les anciens signets.
102
103#define('_MARQUEUR_URL', serialize(array('rubrique1' => '-', 'rubrique2' => '-', 'breve1' => '+', 'breve2' => '+', 'site1' => '@', 'site2' => '@', 'auteur1' => '_', 'auteur2' => '_', 'mot1' => '+-', 'mot2' => '-+')));
104if (!defined('_MARQUEUR_URL')) define('_MARQUEUR_URL', false);
105
106/**
107 * Definir les parentees utilisees pour construire des urls arborescentes
108 *
109 * @param string $type
110 * @return string
111 */
112function url_arbo_parent($type){
113        static $parents = null;
114        if (is_null($parents)){
115                $parents = array(
116                          'article'=>array('id_rubrique','rubrique'),
117                          'rubrique'=>array('id_parent','rubrique'),
118                          'breve'=>array('id_rubrique','rubrique'),
119                          'site'=>array('id_rubrique','rubrique'));
120                if (isset($GLOBALS['url_arbo_parents']) AND !isset($_REQUEST['url_arbo_parents'])){
121                        $parents = array_merge($parents,$GLOBALS['url_arbo_parents']);
122                }                         
123        }
124        return (isset($parents[$type])?$parents[$type]:'');
125}
126
127/**
128 * Definir les terminaisons des urls :
129 * / pour une rubrique
130 * .html pour une page etc..
131 *
132 * @param string $type
133 * @return string
134 */
135function url_arbo_terminaison($type){
136        static $terminaison_types = null;
137        if ($terminaison_types==null){
138                $terminaison_types = array('rubrique' => '/','mot' => '','defaut' => defined('_terminaison_urls_arbo')?_terminaison_urls_arbo:'.html');
139                if (isset($GLOBALS['url_arbo_terminaisons']))
140                        $terminaison_types = array_merge($terminaison_types,$GLOBALS['url_arbo_terminaisons']);
141        }
142        // si c'est un appel avec type='' c'est pour avoir la liste des terminaisons
143        if (!$type)
144                return array_unique(array_values($terminaison_types));
145        if (isset($terminaison_types[$type]))
146                return $terminaison_types[$type];
147        elseif (isset($terminaison_types['defaut']))
148                return $terminaison_types['defaut'];
149        return "";
150}
151
152/**
153 * Definir le prefixe qui designe le type et qu'on utilise pour chaque objet
154 * ex : "article"/truc
155 * par defaut les rubriques ne sont pas typees, mais le reste oui
156 *
157 * @param string $type
158 * @return array|string
159 */
160function url_arbo_type($type){
161        static $synonymes_types = null;
162        if (!$synonymes_types){
163                $synonymes_types = array('rubrique'=>'');
164                if (isset($GLOBALS['url_arbo_types']) AND is_array($GLOBALS['url_arbo_types']))
165                        $synonymes_types = array_merge($synonymes_types,$GLOBALS['url_arbo_types']);
166        }
167        // si c'est un appel avec type='' c'est pour avoir la liste inversee des synonymes
168        if (!$type)
169                return array_flip($synonymes_types);
170        return 
171            ($t=(isset($synonymes_types[$type])?$synonymes_types[$type]:$type))  // le type ou son synonyme
172          . ($t?'/':''); // le / eventuel pour separer, si le synonyme n'est pas vide
173}
174
175/**
176 * Pipeline pour creation d'une adresse : il recoit l'url propose par le
177 * precedent, un tableau indiquant le titre de l'objet, son type, son id,
178 * et doit donner en retour une chaine d'url, sans se soucier de la
179 * duplication eventuelle, qui sera geree apres
180 * http://code.spip.net/@creer_chaine_url
181 *
182 * @param array $x
183 * @return array
184 */
185function urls_arbo_creer_chaine_url($x) {
186        // NB: ici url_old ne sert pas, mais un plugin qui ajouterait une date
187        // pourrait l'utiliser pour juste ajouter la
188        $url_old = $x['data'];
189        $objet = $x['objet'];
190        include_spip('inc/filtres');
191
192        include_spip('action/editer_url');
193        if (!$url = url_nettoyer($objet['titre'],_URLS_ARBO_MAX,_URLS_ARBO_MIN,'-',_url_arbo_minuscules?'strtolower':''))
194                $url = $objet['id_objet'];
195       
196        $x['data'] =
197                  url_arbo_type($objet['type']) // le type ou son synonyme
198          . $url; // le titre
199
200        return $x;
201}
202
203/**
204 * Boucler sur le parent pour construire l'url complete a partir des segments
205 * http://code.spip.net/@declarer_url_arbo_rec
206 *
207 * @param string $url
208 * @param string $type
209 * @param string $parent
210 * @param string $type_parent
211 * @return string
212 */
213function declarer_url_arbo_rec($url, $type, $parent, $type_parent){
214        if (is_null($parent)){
215                return $url;
216        }
217        // Si pas de parent ou si son URL est vide, on ne renvoit que l'URL de l'objet en court
218        if ($parent==0 or !($url_parent = declarer_url_arbo($type_parent?$type_parent:'rubrique',$parent))){
219                return rtrim($url,'/');
220        }
221        // Sinon on renvoit l'URL de l'objet concaténée avec celle du parent
222        else {
223                return rtrim($url_parent,'/') . '/' . rtrim($url,'/');
224        }
225}
226
227/**
228 * Renseigner les infos les plus recentes de l'url d'un objet
229 * et de quoi la (re)construire si besoin
230 * @param string $type
231 * @param int $id_objet
232 * @return bool|null|array
233 */
234function renseigner_url_arbo($type, $id_objet){
235        $urls = array();
236        $trouver_table = charger_fonction('trouver_table', 'base');
237        $desc = $trouver_table(table_objet($type));
238        $table = $desc['table'];
239        $col_id =  @$desc['key']["PRIMARY KEY"];
240        if (!$col_id) return false; // Quand $type ne reference pas une table
241        $id_objet = intval($id_objet);
242
243        $champ_titre = $desc['titre'] ? $desc['titre'] : 'titre';
244       
245        // parent
246        $champ_parent = url_arbo_parent($type);
247        $sel_parent = ', 0 as parent';
248        $order_by_parent = "";
249        if ($champ_parent){
250                $sel_parent = ", O.".reset($champ_parent).' as parent';
251                // trouver l'url qui matche le parent en premier
252                $order_by_parent = "O.".reset($champ_parent)."=U.id_parent DESC, ";
253        }
254        //  Recuperer une URL propre correspondant a l'objet.
255        $row = sql_fetsel("U.url, U.date, U.id_parent, U.perma, $champ_titre $sel_parent",
256                                                                                "$table AS O LEFT JOIN spip_urls AS U ON (U.type='$type' AND U.id_objet=O.$col_id)",
257                                                                                "O.$col_id=$id_objet",
258                                                                                '',
259                                                                                $order_by_parent.'U.perma DESC, U.date DESC', 1);
260        if ($row){
261                $urls[$type][$id_objet] = $row;
262                $urls[$type][$id_objet]['type_parent'] = $champ_parent?end($champ_parent):'';
263        }
264        return isset($urls[$type][$id_objet])?$urls[$type][$id_objet]:null;
265}
266
267/**
268 * Retrouver/Calculer l'ensemble des segments d'url d'un objet
269 *
270 * http://code.spip.net/@declarer_url_arbo
271 *
272 * @param string $type
273 * @param int $id_objet
274 * @return string
275 */
276function declarer_url_arbo($type, $id_objet) {
277        static $urls=array();
278        // utiliser un cache memoire pour aller plus vite
279        if(!is_null($C=Cache())) return$C;
280       
281        // Se contenter de cette URL si elle existe ;
282        // sauf si on invoque par "voir en ligne" avec droit de modifier l'url
283
284        // l'autorisation est verifiee apres avoir calcule la nouvelle url propre
285        // car si elle ne change pas, cela ne sert a rien de verifier les autorisations
286        // qui requetent en base
287        $modifier_url = (defined('_VAR_URLS') AND _VAR_URLS);
288       
289        if (!isset($urls[$type][$id_objet]) OR $modifier_url) {
290                $r = renseigner_url_arbo($type,$id_objet);
291                // Quand $type ne reference pas une table
292                if ($r===false)
293                        return false;
294
295                if (!is_null($r))
296                        $urls[$type][$id_objet] = $r;
297        }
298
299        if (!isset($urls[$type][$id_objet])) return ""; # objet inexistant
300
301        $url_propre = $urls[$type][$id_objet]['url'];
302
303        // si on a trouve l'url
304        // et que le parent est bon
305        // et (permanente ou pas de demande de modif)
306        if (!is_null($url_propre)
307          AND $urls[$type][$id_objet]['id_parent'] == $urls[$type][$id_objet]['parent']
308          AND ($urls[$type][$id_objet]['perma'] OR !$modifier_url))
309                return declarer_url_arbo_rec($url_propre,$type,
310                  isset($urls[$type][$id_objet]['parent'])?$urls[$type][$id_objet]['parent']:0,
311                  isset($urls[$type][$id_objet]['type_parent'])?$urls[$type][$id_objet]['type_parent']:null);
312
313        // Si URL inconnue ou maj forcee sur une url non permanente, recreer une url
314        $url = $url_propre;
315        if (is_null($url_propre) OR ($modifier_url AND !$urls[$type][$id_objet]['perma'])) {
316                $url = pipeline('arbo_creer_chaine_url',
317                        array(
318                                'data' => $url_propre,  // le vieux url_propre
319                                'objet' => array_merge($urls[$type][$id_objet],
320                                        array('type' => $type, 'id_objet' => $id_objet)
321                                )
322                        )
323                );
324
325                // Eviter de tamponner les URLs a l'ancienne (cas d'un article
326                // intitule "auteur2")
327                include_spip('inc/urls');
328                $objets = urls_liste_objets();
329                if (preg_match(',^('.$objets.')[0-9]*$,', $url, $r)
330                AND $r[1] != $type)
331                        $url = $url._url_arbo_sep_id.$id_objet;
332        }
333
334
335        // Pas de changement d'url ni de parent
336        if ($url == $url_propre
337          AND $urls[$type][$id_objet]['id_parent'] == $urls[$type][$id_objet]['parent'])
338                return declarer_url_arbo_rec($url_propre,$type,$urls[$type][$id_objet]['parent'],$urls[$type][$id_objet]['type_parent']);
339
340        // verifier l'autorisation, maintenant qu'on est sur qu'on va agir
341        if ($modifier_url) {
342                include_spip('inc/autoriser');
343                $modifier_url = autoriser('modifierurl', $type, $id_objet);
344        }
345        // Verifier si l'utilisateur veut effectivement changer l'URL
346        if ($modifier_url
347                AND CONFIRMER_MODIFIER_URL
348                AND $url_propre
349                // on essaye pas de regenerer une url en -xxx (suffixe id anti collision)
350                AND $url != preg_replace('/'.preg_quote(_url_propres_sep_id,'/').'.*/', '', $url_propre))
351                $confirmer = true;
352        else
353                $confirmer = false;
354
355        if ($confirmer AND !_request('ok')) {
356                die ("vous changez d'url ? $url_propre -&gt; $url");
357        }
358
359        $set = array('url' => $url, 'type' => $type, 'id_objet' => $id_objet, 'id_parent'=>$urls[$type][$id_objet]['parent'],'perma'=>intval($urls[$type][$id_objet]['perma']));
360        include_spip('action/editer_url');
361        if (url_insert($set,$confirmer,_url_arbo_sep_id)){
362                $urls[$type][$id_objet]['url'] = $set['url'];
363                $urls[$type][$id_objet]['id_parent'] = $set['id_parent'];
364        }
365        else {
366                // l'insertion a echoue,
367                //serveur out ? retourner au mieux
368                $urls[$type][$id_objet]['url']=$url_propre;
369        }
370
371        return declarer_url_arbo_rec($urls[$type][$id_objet]['url'],$type,$urls[$type][$id_objet]['parent'],$urls[$type][$id_objet]['type_parent']);
372}
373
374/**
375 * Generer l'url arbo complete constituee des segments + debut + fin
376 *
377 * http://code.spip.net/@_generer_url_arbo
378 *
379 * @param string $type
380 * @param int $id
381 * @param string $args
382 * @param string $ancre
383 * @return string
384 */
385function _generer_url_arbo($type, $id, $args = '', $ancre = '') {
386
387        if ($generer_url_externe = charger_fonction("generer_url_$type",'urls',true)) {
388                $url = $generer_url_externe($id, $args, $ancre);
389                if (NULL != $url) return $url;
390        }
391
392        // Mode propre
393        $propre = declarer_url_arbo($type, $id);
394
395        if ($propre === false) return ''; // objet inconnu. raccourci ?
396
397        if ($propre) {
398                $url = _debut_urls_arbo
399                        . rtrim($propre,'/')
400                        . url_arbo_terminaison($type);
401        } else {
402
403                // objet connu mais sans possibilite d'URL lisible, revenir au defaut
404                include_spip('base/connect_sql');
405                $id_type = id_table_objet($type);
406                $url = get_spip_script('./')."?"._SPIP_PAGE."=$type&$id_type=$id";
407        }
408
409        // Ajouter les args
410        if ($args)
411                $url .= ((strpos($url, '?')===false) ? '?' : '&') . $args;
412
413        // Ajouter l'ancre
414        if ($ancre)
415                $url .= "#$ancre";
416
417        return _DIR_RACINE . $url;
418}
419
420
421/**
422 * API : retourner l'url d'un objet si i est numerique
423 * ou decoder cette url si c'est une chaine
424 * array([contexte],[type],[url_redirect],[fond]) : url decodee
425 *
426 * http://code.spip.net/@urls_arbo_dist
427 *
428 * @param string|int $i
429 * @param string $entite
430 * @param string|array $args
431 * @param string $ancre
432 * @return array|string
433 */
434function urls_arbo_dist($i, $entite, $args = '', $ancre = '') {
435        if (is_numeric($i))
436                return _generer_url_arbo($entite, $i, $args, $ancre);
437
438        // traiter les injections du type domaine.org/spip.php/cestnimportequoi/ou/encore/plus/rubrique23
439        if ($GLOBALS['profondeur_url']>0 AND $entite=='sommaire'){
440                $entite = 'type_urls';
441        }
442
443        // recuperer les &debut_xx;
444        if (is_array($args))
445                $contexte = $args;
446        else
447                parse_str($args,$contexte);
448
449        $url = $i;
450        $id_objet = $type = 0;
451        $url_redirect = null;
452
453        // Migration depuis anciennes URLs ?
454        // traiter les injections domain.tld/spip.php/n/importe/quoi/rubrique23
455        if ($GLOBALS['profondeur_url']<=0
456        AND $_SERVER['REQUEST_METHOD'] != 'POST') {
457                include_spip('inc/urls');
458                $r = nettoyer_url_page($i, $contexte);
459                if ($r) {
460                        list($contexte, $type,,, $suite) = $r;
461                        $_id = id_table_objet($type);
462                        $id_objet = $contexte[$_id];
463                        $url_propre = generer_url_entite($id_objet, $type);
464                        if (strlen($url_propre)
465                        AND !strstr($url,$url_propre)) {
466                                list(,$hash) = array_pad(explode('#', $url_propre), 2, null);
467                                $args = array();
468                                foreach(array_filter(explode('&', $suite)) as $fragment) {
469                                        if ($fragment != "$_id=$id_objet")
470                                                $args[] = $fragment;
471                                }
472                                $url_redirect = generer_url_entite($id_objet, $type, join('&',array_filter($args)), $hash);
473
474                                return array($contexte, $type, $url_redirect, $type);
475                        }
476                }
477        }
478        /* Fin compatibilite anciennes urls */
479
480        // Chercher les valeurs d'environnement qui indiquent l'url-propre
481        $url_propre = preg_replace(',[?].*,', '', $url);
482
483        // Mode Query-String ?
484        if (!$url_propre
485        AND preg_match(',[?]([^=/?&]+)(&.*)?$,', $url, $r)) {
486                $url_propre = $r[1];
487        }
488
489        if (!$url_propre
490          OR $url_propre==_DIR_RESTREINT_ABS
491          OR $url_propre==_SPIP_SCRIPT) return; // qu'est-ce qu'il veut ???
492
493
494        include_spip('base/abstract_sql'); // chercher dans la table des URLS
495
496        // Revenir en utf-8 si encodage type %D8%A7 (farsi)
497        $url_propre = rawurldecode($url_propre);
498
499        // Compatibilite avec .htm/.html et autres terminaisons
500        $t = array_diff(array_unique(array_merge(array('.html','.htm','/'),url_arbo_terminaison(''))),array(''));
501        if (count($t))
502                $url_propre = preg_replace('{('
503                  .implode('|',array_map('preg_quote',$t)).')$}i', '', $url_propre);
504
505        if (strlen($url_propre) AND !preg_match(',^[^/]*[.]php,',$url_propre)){
506                $parents_vus = array();
507               
508                // recuperer tous les objets de larbo xxx/article/yyy/mot/zzzz
509                // on parcourt les segments de gauche a droite
510                // pour pouvoir contextualiser un segment par son parent
511                $url_arbo = explode('/',$url_propre);
512                $url_arbo_new = array();
513                $dernier_parent_vu = false;
514                $objet_segments = 0;
515                while (count($url_arbo)>0){
516                        $type=null;
517                        if (count($url_arbo)>1)
518                                $type = array_shift($url_arbo);
519                        $url_segment = array_shift($url_arbo);
520                        // Rechercher le segment de candidat
521                        // si on est dans un contexte de parent, donne par le segment precedent,
522                        // prefixer le segment recherche avec ce contexte
523                        $cp = "0"; // par defaut : parent racine, id=0
524                        if ($dernier_parent_vu)
525                                $cp = $parents_vus[$dernier_parent_vu];
526                        // d'abord recherche avec prefixe parent, en une requete car aucun risque de colision
527                        $row=sql_fetsel('id_objet, type, url',
528                                                                                        'spip_urls',
529                                                                                        is_null($type)
530                                                                                                ? "url=".sql_quote($url_segment, '', 'TEXT')
531                                                                                                : sql_in('url',array("$type/$url_segment",$type)),
532                                                                                        '',
533                                                                                        // en priorite celui qui a le bon parent et les deux segments
534                                                                                        // puis le bon parent avec 1 segment
535                                                                                        // puis un parent indefini (le 0 de preference) et les deux segments
536                                                                                        // puis un parent indefini (le 0 de preference) et 1 segment
537                                                                                        (intval($cp)?"id_parent=".intval($cp)." DESC, ":"id_parent>=0 DESC, ")."segments DESC, id_parent"
538                        );
539                        if ($row){
540                                if (!is_null($type) AND $row['url']==$type){
541                                        array_unshift($url_arbo,$url_segment);
542                                        $url_segment = $type;
543                                        $type = null;
544                                }
545                                $type = $row['type'];
546                                $col_id = id_table_objet($type);
547                               
548                                // le plus a droite l'emporte pour des objets presents plusieurs fois dans l'url (ie rubrique)
549                                $contexte[$col_id] = $row['id_objet'];
550
551                                $type_parent = '';
552                                if ($p = url_arbo_parent($type))
553                                        $type_parent=end($p);
554                                // l'entite la plus a droite l'emporte, si le type de son parent a ete vu
555                                // sinon c'est un segment contextuel supplementaire a ignorer
556                                // ex : rub1/article/art1/mot1 : il faut ignorer le mot1, la vrai url est celle de l'article
557                                if (!$entite
558                                  OR $dernier_parent_vu == $type_parent){
559                                        if ($objet_segments==0)
560                                                $entite = $type;
561                                }
562                                // sinon on change d'objet concerne
563                                else{
564                                        $objet_segments++;
565                                }
566
567                                $url_arbo_new[$objet_segments]['id_objet'] = $row['id_objet'];
568                                $url_arbo_new[$objet_segments]['objet'] = $type;
569                                $url_arbo_new[$objet_segments]['segment'][] = $row['url'];
570
571                                // on note le dernier parent vu de chaque type
572                                $parents_vus[$dernier_parent_vu = $type] = $row['id_objet'];
573                        }
574                        else {
575                                // un segment est inconnu
576                                if ($entite=='' OR $entite=='type_urls') {
577                                        // on genere une 404 comme il faut si on ne sait pas ou aller
578                                        return array(array(),'404');
579                                }
580                                // ici on a bien reconnu un segment en amont, mais le segment en cours est inconnu
581                                // on pourrait renvoyer sur le dernier segment identifie
582                                // mais de fait l'url entiere est inconnu : 404 aussi
583                                // mais conserver le contexte qui peut contenir un fond d'ou venait peut etre $entite (reecriture urls)
584                                return array($contexte,'404');
585                        }
586                }
587
588                if (count($url_arbo_new)){
589                        $caller = debug_backtrace();
590                        $caller = $caller[1]['function'];
591                        // si on est appele par un autre module d'url c'est du decodage d'une ancienne URL
592                        // ne pas regenerer des segments arbo, mais rediriger vers la nouvelle URL
593                        // dans la nouvelle forme
594                        if (strncmp($caller,"urls_",5)==0 AND $caller!=="urls_decoder_url"){
595                                // en absolue, car assembler ne gere pas ce cas particulier
596                                include_spip('inc/filtres_mini');
597                                $col_id = id_table_objet($entite);
598                                $url_new = generer_url_entite($contexte[$col_id],$entite);
599                                // securite contre redirection infinie
600                                if ($url_new!==$url_propre
601                                        AND rtrim($url_new,"/")!==rtrim($url_propre,"/"))
602                                        $url_redirect = url_absolue($url_new);
603                        }
604                        else {
605                                foreach($url_arbo_new as $k=>$o)
606                                        if ($s = declarer_url_arbo($o['objet'],$o['id_objet']))
607                                                $url_arbo_new[$k] = $s;
608                                        else
609                                                $url_arbo_new[$k] = implode('/',$o['segment']);
610                                $url_arbo_new = ltrim(implode('/',$url_arbo_new),'/');
611
612                                if ($url_arbo_new!==$url_propre){
613                                        $url_redirect = $url_arbo_new;
614                                        // en absolue, car assembler ne gere pas ce cas particulier
615                                        include_spip('inc/filtres_mini');
616                                        $url_redirect = url_absolue($url_redirect);
617                                }
618                        }
619                }
620
621                // gerer le retour depuis des urls propres
622                if (($entite=='' OR $entite=='type_urls')
623                AND $GLOBALS['profondeur_url']<=0){
624                        $urls_anciennes = charger_fonction('propres','urls');
625                        return $urls_anciennes($url_propre, $entite, $contexte);
626                }
627        }
628        if ($entite=='' OR $entite=='type_urls' /* compat .htaccess 2.0 */) {
629                if ($type)
630                        $entite = objet_type ($type);
631                else {
632                        // Si ca ressemble a une URL d'objet, ce n'est pas la home
633                        // et on provoque un 404
634                        if (preg_match(',^[^\.]+(\.html)?$,', $url)) {
635                                $entite = '404';
636                                $contexte['erreur'] = ''; // qu'afficher ici ?  l'url n'existe pas... on ne sait plus dire de quel type d'objet il s'agit
637                        }
638                }
639        }
640        define('_SET_HTML_BASE',1);
641
642        return array($contexte, $entite, $url_redirect, null);
643}
644
645?>
Note: See TracBrowser for help on using the repository browser.