1 | <?php |
---|
2 | /** |
---|
3 | * Déclaration des pipelines utilisés par le plugin |
---|
4 | * |
---|
5 | * @plugin Pages |
---|
6 | * @copyright 2013 |
---|
7 | * @author RastaPopoulos |
---|
8 | * @licence GNU/GPL |
---|
9 | * @package SPIP\Pages\Pipelines |
---|
10 | * @link https://contrib.spip.net/Pages-uniques |
---|
11 | */ |
---|
12 | |
---|
13 | if (!defined('_ECRIRE_INC_VERSION')) { |
---|
14 | return; |
---|
15 | } |
---|
16 | |
---|
17 | // Change l'entête du formulaire des articles pour montrer que c'est une page |
---|
18 | function pages_affiche_milieu_ajouter_page($flux) { |
---|
19 | if ($flux['args']['exec'] == 'article_edit') { |
---|
20 | include_spip('base/abstract_sql'); |
---|
21 | if ( |
---|
22 | _request('modele') == 'page' |
---|
23 | or |
---|
24 | ( |
---|
25 | isset($flux['args']['id_article']) |
---|
26 | and ($id_article = $flux['args']['id_article']) > 0 |
---|
27 | and (sql_getfetsel('page', 'spip_articles', 'id_article='.intval($id_article))) |
---|
28 | ) |
---|
29 | ) { |
---|
30 | //On force l'id parent à -1 |
---|
31 | //Par principe une page nouvelle ou existante est dans la rubrique parent -1 |
---|
32 | $cherche = "/(<input[^>]*name=('|\")id_parent[^>]*>)/is"; |
---|
33 | if (!preg_match($cherche, $flux['data'])) { |
---|
34 | $cherche = "/(<input[^>]*name=('|\")id_rubrique[^>]*>)/is"; |
---|
35 | $remplace = "$1<input type=\"hidden\" name=\"id_parent\" value=\"-1\" />\n"; |
---|
36 | $flux['data'] = preg_replace($cherche, $remplace, $flux['data']); |
---|
37 | } |
---|
38 | |
---|
39 | // On cherche et remplace l'entete de la page : "modifier la page" |
---|
40 | $cherche = "/(<div[^>]*class=('|\")entete-formulaire.*?<\/span>).*?(<h1>.*?<\/h1>.*?<\/div>)/is"; |
---|
41 | $surtitre = _T('pages:modifier_page'); |
---|
42 | $remplace = "$1$surtitre$3"; |
---|
43 | $flux['data'] = preg_replace($cherche, $remplace, $flux['data']); |
---|
44 | |
---|
45 | // Si c'est une nouvelle page, on remplace le lien de retour dans l'entete |
---|
46 | if (_request('new') == 'oui') { |
---|
47 | $cherche = "/(<span[^>]*class=(?:'|\")icone[^'\"]*retour[^'\"]*(?:'|\")>" |
---|
48 | . "<a[^>]*href=(?:'|\"))[^'\"]*('|\")/is"; |
---|
49 | $retour = generer_url_ecrire('pages_tous'); |
---|
50 | $remplace = "$1$retour$2"; |
---|
51 | $flux['data'] = preg_replace($cherche, $remplace, $flux['data']); |
---|
52 | } |
---|
53 | } |
---|
54 | } |
---|
55 | |
---|
56 | return $flux; |
---|
57 | } |
---|
58 | |
---|
59 | |
---|
60 | /** |
---|
61 | * Saisie de l'identifiant de la page sur la fiche d'une page |
---|
62 | * |
---|
63 | * @param array $flux |
---|
64 | * Le contexte du pipeline |
---|
65 | * @return array $flux |
---|
66 | * Le contexte du pipeline modifié |
---|
67 | */ |
---|
68 | function pages_affiche_milieu_identifiant($flux) { |
---|
69 | $texte = ''; |
---|
70 | $e = trouver_objet_exec($flux['args']['exec']); |
---|
71 | |
---|
72 | // Si on est sur la fiche d'un article... |
---|
73 | if ($e and !$e['edition'] and $e['type']=='article') { |
---|
74 | include_spip('base/abstract_sql'); |
---|
75 | $id_article = isset($flux['args'][$e['id_table_objet']]) ? $flux['args'][$e['id_table_objet']] : false; |
---|
76 | // ... et s'il s'agit d'une page |
---|
77 | if ( |
---|
78 | _request('modele') == 'page' |
---|
79 | or |
---|
80 | ( |
---|
81 | intval($id_article) > 0 |
---|
82 | and |
---|
83 | (sql_getfetsel('page', 'spip_articles', 'id_article='.intval($id_article))) |
---|
84 | ) |
---|
85 | ) { |
---|
86 | $texte .= recuperer_fond( |
---|
87 | 'prive/objets/editer/identifiant_page', |
---|
88 | array('id_article' => $id_article), |
---|
89 | array('ajax' => true) |
---|
90 | ); |
---|
91 | } |
---|
92 | } |
---|
93 | |
---|
94 | if ($texte) { |
---|
95 | if ($p=strpos($flux['data'], '<!--affiche_milieu-->')) { |
---|
96 | $flux['data'] = substr_replace($flux['data'], $texte, $p, 0); |
---|
97 | } else { |
---|
98 | $flux['data'] .= $texte; |
---|
99 | } |
---|
100 | } |
---|
101 | |
---|
102 | return $flux; |
---|
103 | } |
---|
104 | |
---|
105 | |
---|
106 | // Vérifier que la page n'est pas vide |
---|
107 | function pages_formulaire_charger($flux) { |
---|
108 | // Si on est dans l'édition d'un article |
---|
109 | if (is_array($flux) and is_array($flux['data']) and $flux['args']['form'] == 'editer_article') { |
---|
110 | // Si on est dans un article de modele page |
---|
111 | if (_request('modele') == 'page' or ($flux['data']['page'] and _request('modele') != 'article')) { |
---|
112 | $flux['data']['modele'] = 'page'; |
---|
113 | $flux['data']['champ_page'] = $flux['data']['page']; |
---|
114 | } |
---|
115 | unset($flux['data']['page']); |
---|
116 | } |
---|
117 | |
---|
118 | return $flux; |
---|
119 | } |
---|
120 | |
---|
121 | |
---|
122 | /** |
---|
123 | * Vérifications de l'identifiant d'une page |
---|
124 | * |
---|
125 | * L'identifiant doit être unique, sauf en cas de traduction |
---|
126 | * |
---|
127 | * @param array $flux |
---|
128 | * Le contexte du pipeline |
---|
129 | * @return array $flux |
---|
130 | * Le contexte du pipeline modifié |
---|
131 | */ |
---|
132 | function pages_formulaire_verifier($flux) { |
---|
133 | // Si on est dans l'édition d'un article/page ou dans le formulaire d'édition d'un identifiant page |
---|
134 | if ( |
---|
135 | is_array($flux) |
---|
136 | and ( |
---|
137 | ( $flux['args']['form'] == 'editer_article' and _request('modele') == 'page' ) |
---|
138 | or $flux['args']['form'] == 'editer_identifiant_page' |
---|
139 | ) |
---|
140 | ) { |
---|
141 | $erreur = ''; |
---|
142 | $page = _request('champ_page'); |
---|
143 | $page = strtolower($page); |
---|
144 | $page = preg_replace(',\\s+,', '_', $page); |
---|
145 | set_request('champ_page', $page); |
---|
146 | $id_page = $flux['args']['args'][0]; |
---|
147 | // champ vide |
---|
148 | $lang = sql_getfetsel('lang', 'spip_articles', 'id_article='.intval($id_page)); |
---|
149 | if (!$lang) { |
---|
150 | $lang = $GLOBALS['spip_lang']; |
---|
151 | } |
---|
152 | if (!$page) { |
---|
153 | $erreur .= _T('info_obligatoire'); |
---|
154 | } elseif (strlen($page) > 255) { |
---|
155 | $erreur = _T('pages:erreur_champ_page_taille'); |
---|
156 | } elseif (!preg_match('/^[a-z0-9_]+$/', $page)) { |
---|
157 | // format : charactères alphanumériques en minuscules ou "_" |
---|
158 | $erreur = _T('pages:erreur_champ_page_format'); |
---|
159 | // doublon ? |
---|
160 | } elseif (sql_countsel('spip_articles', array( |
---|
161 | 'page=' . sql_quote($page), |
---|
162 | 'id_article != ' . intval($id_page), |
---|
163 | 'lang = ' . sql_quote($lang), |
---|
164 | 'statut != ' .sql_quote("poubelle"))) |
---|
165 | ) { |
---|
166 | $erreur = _T('pages:erreur_champ_page_doublon'); |
---|
167 | } |
---|
168 | |
---|
169 | if ($erreur) { |
---|
170 | if (!isset($flux['data']['champ_page'])) { |
---|
171 | $flux['data']['champ_page'] = ''; |
---|
172 | } |
---|
173 | $flux['data']['champ_page'] .= $erreur; |
---|
174 | } |
---|
175 | } |
---|
176 | return $flux; |
---|
177 | } |
---|
178 | |
---|
179 | |
---|
180 | /** |
---|
181 | * Insertion dans le pipeline editer_contenu_objet (SPIP) |
---|
182 | * |
---|
183 | * Sur les articles considérés comme pages uniques, on remplace l'élément de choix de rubriques par : |
---|
184 | * -* un input hidden id_rubrique et id_parent avec pour valeur -1 |
---|
185 | * -* un input hidden modele avec comme valeur "page" |
---|
186 | * -* un champ d'édition de l'identifiant de la page unique |
---|
187 | * |
---|
188 | * @param array $flux |
---|
189 | * Le contexte du pipeline |
---|
190 | * @return array $flux |
---|
191 | * Le contexte du pipeline modifié |
---|
192 | */ |
---|
193 | function pages_editer_contenu_objet($flux) { |
---|
194 | $args = $flux['args']; |
---|
195 | if ($args['type'] == 'article' && isset($args['contexte']['modele']) && $args['contexte']['modele'] == 'page') { |
---|
196 | $erreurs = $args['contexte']['erreurs']; |
---|
197 | // On cherche et remplace l'édition de la rubrique |
---|
198 | $cherche = "/(<(li|div)[^>]*class=(?:'|\")editer editer_parent.*?<\/\\2>)\s*(<(li|div)[^>]*class=(?:'|\")editer)/is"; |
---|
199 | $remplace = '<\\2 class="editer editer_page obligatoire' . (empty($erreurs['champ_page']) ? '' : ' erreur') . '">'; |
---|
200 | $remplace .= '<input type="hidden" name="id_parent" value="-1" />'; |
---|
201 | $remplace .= '<input type="hidden" name="id_rubrique" value="-1" />'; |
---|
202 | $remplace .= '<input type="hidden" name="modele" value="page" />'; |
---|
203 | $remplace .= '<label for="id_page">'._T('pages:titre_page').'</label>'; |
---|
204 | if (!empty($erreurs['champ_page'])) { |
---|
205 | $remplace .= '<span class="erreur_message">' . $erreurs['champ_page'] . '</span>'; |
---|
206 | } |
---|
207 | |
---|
208 | if (!empty($args['contexte']['champ_page'])) { |
---|
209 | $value = $args['contexte']['champ_page']; |
---|
210 | } elseif (!empty($args['contexte']['page'])) { |
---|
211 | $value = $args['contexte']['page']; |
---|
212 | } else { |
---|
213 | $value = ''; |
---|
214 | } |
---|
215 | |
---|
216 | $remplace .= '<input type="text" class="text" name="champ_page" id="id_page" value="'.$value.'" />'; |
---|
217 | $remplace .= '</\\2>$3'; |
---|
218 | if (preg_match($cherche, $flux['data'], $m)) { |
---|
219 | $flux['data'] = preg_replace($cherche, $remplace, $flux['data'], 1); |
---|
220 | $flux['data'] = preg_replace($cherche, '', $flux['data']); |
---|
221 | } else { |
---|
222 | $cherche = "/(<(li|div)[^>]*class=(?:'|\")editer editer_soustitre.*?<\/\\2>)\s*(<(li|div)[^>]*class=(?:'|\")editer)/is"; |
---|
223 | if (preg_match($cherche, $flux['data'])) { |
---|
224 | $flux['data'] = preg_replace($cherche,'$1'.$remplace, $flux['data']); |
---|
225 | } else { |
---|
226 | $cherche = "/(<(li|div)[^>]*class=(?:'|\")editer editer_titre.*?<\/\\2>)\s*(<(li|div)[^>]*class=(?:'|\")editer)/is"; |
---|
227 | $flux['data'] = preg_replace($cherche, '$1'.$remplace, $flux['data']); |
---|
228 | } |
---|
229 | } |
---|
230 | } |
---|
231 | return $flux; |
---|
232 | } |
---|
233 | |
---|
234 | /** |
---|
235 | * Insertion dans le pipeline pre_edition (SPIP) |
---|
236 | * |
---|
237 | * Si on édite un article : |
---|
238 | * - Si on récupère un champ "champ_page" dans les _request() et qu'il est différent de "article", |
---|
239 | * on transforme l'article en page unique, id_rubrique devient -1 |
---|
240 | * - Si on ne récupère pas de champ_page et que id_parent est supérieur à 0, on le passe en article et on vide |
---|
241 | * son champ page pour pouvoir réaliser le processus inverse dans le futur |
---|
242 | * |
---|
243 | * @param array $flux Le contexte du pipeline |
---|
244 | * @return array $flux Le contexte modifié |
---|
245 | */ |
---|
246 | function pages_pre_edition_ajouter_page($flux) { |
---|
247 | if (is_array($flux) and isset($flux['args']['type']) && $flux['args']['type'] == 'article') { |
---|
248 | if ((($page = _request('champ_page')) != '') and ($page != 'article')) { |
---|
249 | /** |
---|
250 | * On ajoute le "champ_page" du formulaire qui deviendra "page" dans la table |
---|
251 | * On force l'id_rubrique à -1 |
---|
252 | */ |
---|
253 | $flux['data']['page'] = $page; |
---|
254 | $flux['data']['id_rubrique'] = '-1'; |
---|
255 | $flux['data']['id_secteur'] = '0'; |
---|
256 | } |
---|
257 | /** |
---|
258 | * si l'id_parent est supérieur à 0 on que l'on ne récupère pas de champ_page, |
---|
259 | * on pense à vider le champ "page", pour pouvoir revenir après coup en page |
---|
260 | */ |
---|
261 | if (!_request('champ_page') && (_request('id_parent') > 0)) { |
---|
262 | $flux['data']['page'] = ''; |
---|
263 | } |
---|
264 | } |
---|
265 | return $flux; |
---|
266 | } |
---|
267 | |
---|
268 | /** |
---|
269 | * Insertion dans le pipeline boite_infos (SPIP) |
---|
270 | * |
---|
271 | * Ajouter un lien pour transformer un article éditorial en page ou inversement |
---|
272 | * |
---|
273 | * @param array $flux |
---|
274 | * Le contexte du pipeline |
---|
275 | * @return array $flux |
---|
276 | * Le contexte modifié |
---|
277 | */ |
---|
278 | function pages_boite_infos($flux) { |
---|
279 | if ($flux['args']['type'] == 'article') { |
---|
280 | include_spip('inc/presentation'); |
---|
281 | if (sql_getfetsel('page', 'spip_articles', 'id_article='. intval($flux['args']['id'])) == '') { |
---|
282 | if (autoriser('creer', 'page', $flux['args']['id']) && autoriser('convertir', 'page', $flux['args']['id'])) { |
---|
283 | $flux['data'] .= icone_horizontale(_T('pages:convertir_page'), parametre_url(parametre_url(generer_url_ecrire('article_edit'), 'id_article', $flux['args']['id']), 'modele', 'page'), 'page'); |
---|
284 | } |
---|
285 | } else { |
---|
286 | if (autoriser('modifier', 'page', $flux['args']['id']) && autoriser('convertir', 'page', $flux['args']['id'])) { |
---|
287 | $flux['data'] .= icone_horizontale(_T('pages:convertir_article'), parametre_url(parametre_url(generer_url_ecrire('article_edit'), 'id_article', $flux['args']['id']), 'modele', 'article'), 'article'); |
---|
288 | } |
---|
289 | } |
---|
290 | } |
---|
291 | return $flux; |
---|
292 | } |
---|
293 | |
---|
294 | |
---|
295 | /** |
---|
296 | * Insertion dans le pipeline affiche_hierarchie (SPIP) |
---|
297 | * Pour les pages, faire pointer la racine vers la liste des pages au lieux des rubriques |
---|
298 | * Pour savoir si on se trouve sur une page, on vérifie que le champ "page" existe, faute de mieux |
---|
299 | * |
---|
300 | * @param array $flux |
---|
301 | * Le contexte du pipeline |
---|
302 | * @return array $flux |
---|
303 | * Le contexte modifié |
---|
304 | */ |
---|
305 | function pages_affiche_hierarchie($flux) { |
---|
306 | $objet = $flux['args']['objet']; |
---|
307 | $id_article = $flux['args']['id_objet']; |
---|
308 | if ( |
---|
309 | $objet == 'article' |
---|
310 | and sql_getfetsel('page', 'spip_articles', 'id_article='.intval($id_article)) |
---|
311 | ) { |
---|
312 | $cherche = '<a href="'. generer_url_ecrire('rubriques') . '">' . _T('info_racine_site') . '</a>'; |
---|
313 | $remplace = '<a href="'. generer_url_ecrire('pages') . '">' . _T('pages:pages_uniques') . '</a>'; |
---|
314 | $flux['data'] = str_replace($cherche, $remplace, $flux['data']); |
---|
315 | } |
---|
316 | return $flux; |
---|
317 | } |
---|
318 | |
---|
319 | |
---|
320 | /** |
---|
321 | * Insertion dans le pipeline pre_boucle (SPIP) |
---|
322 | * Pour les listes d'articles purement éditoriaux, il faut exclure les pages uniques afin d'éviter la confusion des genres |
---|
323 | * ainsi que les liens vers des pages parfois inaccessibles en fonction de l'autorisation de l'auteur. |
---|
324 | * |
---|
325 | * @param array $flux |
---|
326 | * Le contexte du pipeline |
---|
327 | * @return array $flux |
---|
328 | * Le contexte modifié |
---|
329 | */ |
---|
330 | function pages_pre_boucle($boucle) { |
---|
331 | // On ne s'intéresse qu'à la boucle ARTICLES |
---|
332 | if ($boucle->type_requete == 'articles' and empty($boucle->modificateur['tout'])) { |
---|
333 | // On n'insère le filtre {id_rubriques>0} pour exclure les pages uniques que si aucune des conditions |
---|
334 | // suivantes n'est vérifiée: |
---|
335 | // - pas de critère page autre que {page=''} |
---|
336 | // - pas de critère explicite {id_rubrique=-1} ou {id_rubrique<0} |
---|
337 | // - pas de critère {id_rubrique?} pour lequel l'environnement renvoie -1 pour l'id de la rubrique |
---|
338 | // pas de critère {id_article=XX} ou {id_article} ou {id_article?} |
---|
339 | $boucle_articles = true; |
---|
340 | $critere_page = false; |
---|
341 | |
---|
342 | // On cherche les critères id_rubrique, id_article ou page |
---|
343 | foreach ($boucle->criteres as $_critere) { |
---|
344 | if ($_critere->op == 'page' and !$_critere->not) { // {page} ou {page?} mais pas {!page} |
---|
345 | // On considère qu'on cherche toujours des pages uniques donc on force le filtre id_rubrique=-1 |
---|
346 | $boucle_articles = false; |
---|
347 | $critere_page = true; |
---|
348 | break; |
---|
349 | } |
---|
350 | // Aucun filtre du tout quand on cherche des traductions |
---|
351 | elseif ($_critere->op == 'traduction' or $_critere->op == 'origine_traduction') { |
---|
352 | $boucle_articles = false; |
---|
353 | break; |
---|
354 | } |
---|
355 | elseif (isset($_critere->param[0][0]->texte) and $_critere->param[0][0]->texte == 'page') { // {page=x} |
---|
356 | if ( |
---|
357 | ($_critere->op == '=') |
---|
358 | and ($_critere->param[1][0]->texte == '') |
---|
359 | and empty($_critere->param[1][1]) |
---|
360 | or $_critere->not |
---|
361 | ) { |
---|
362 | // On veut exclure explicitement les pages |
---|
363 | break; |
---|
364 | } else { |
---|
365 | // on désigne bien des pages par leur champ 'page' |
---|
366 | $boucle_articles = false; |
---|
367 | $critere_page = true; |
---|
368 | break; |
---|
369 | } |
---|
370 | } |
---|
371 | elseif (($_critere->op == 'id_article') // {id_article} ou {id_article?} |
---|
372 | or (isset($_critere->param[0][0]->texte) and $_critere->param[0][0]->texte == 'id_article')) { // {id_article=x} |
---|
373 | // On pointe sur un article précis, il est donc inutile de rajouter un test sur la rubrique |
---|
374 | // Pour le critère {id_article?} on considère que pour sélectionner des pages uniques |
---|
375 | // ou des articles éditoriaux on doit préciser le critère {id_rubrique} |
---|
376 | $boucle_articles = false; |
---|
377 | } |
---|
378 | elseif (((isset($_critere->param[0][0]->texte) and $_critere->param[0][0]->texte == 'id_rubrique') // {id_rubrique=-1} |
---|
379 | and ($_critere->op == '=') |
---|
380 | and ($_critere->param[1][0]->texte == '-1')) |
---|
381 | or ((isset($_critere->param[0][0]->texte) and $_critere->param[0][0]->texte == 'id_rubrique') // {id_rubrique<0} |
---|
382 | and ($_critere->op == '<') |
---|
383 | and ($_critere->param[1][0]->texte == '0'))) { |
---|
384 | // On cherche explicitement des pages uniques |
---|
385 | $boucle_articles = false; |
---|
386 | break; |
---|
387 | } |
---|
388 | elseif (($_critere->op == 'id_rubrique')) { |
---|
389 | // On connait pas à ce stade la valeur de id_rubrique qui est passé dans le env. |
---|
390 | // Aussi, on créer une condition where qui se compile différemment suivant la valeur de l'id_rubrique. |
---|
391 | // En fait, il suffit de tester si l'id_rubrique est null. Dans ce cas il faut bien rajouter id_rubrique>0 |
---|
392 | // pour éliminer les pages uniques. |
---|
393 | $boucle_articles = false; |
---|
394 | $env_id = "\$Pile[0]['id_rubrique']"; |
---|
395 | $boucle->where[] = |
---|
396 | array("'?'", "(isset($env_id)?(is_array($env_id)?count($env_id):strlen($env_id)):'')", "''", "'articles.id_rubrique>0'"); |
---|
397 | break; |
---|
398 | } |
---|
399 | } |
---|
400 | |
---|
401 | // Si on est en présence d'une boucle article purement éditoriale, on ajoute le filtre id_rubrique>0 |
---|
402 | if ($boucle_articles) { |
---|
403 | $boucle->where[] = array("'>'", "'articles.id_rubrique'", "'\"0\"'"); |
---|
404 | } |
---|
405 | |
---|
406 | // Si on est en présence d'un critère {page} quelconque, on force le filtre id_rubrique=-1 |
---|
407 | if ($critere_page) { |
---|
408 | $boucle->where[] = array("'='", "'articles.id_rubrique'", "'\"-1\"'"); |
---|
409 | } |
---|
410 | } |
---|
411 | |
---|
412 | return $boucle; |
---|
413 | } |
---|
414 | |
---|
415 | /** |
---|
416 | * On cherche s'il existe un squelette article-NOMDELAPAGE pour l'utiliser en priorité |
---|
417 | * |
---|
418 | * @param array $flux |
---|
419 | * Le contexte du pipeline |
---|
420 | * @return array $flux |
---|
421 | * Le contexte modifié |
---|
422 | */ |
---|
423 | function pages_styliser($flux) { |
---|
424 | $bloc_principal = ''; |
---|
425 | |
---|
426 | // Quand il y a Z, on cherche le bloc principal |
---|
427 | if (defined('_DIR_PLUGIN_ZCORE')) { |
---|
428 | if (!function_exists("z_blocs")) { |
---|
429 | $styliser_par_z = charger_fonction('styliser_par_z', 'public'); |
---|
430 | } |
---|
431 | $z_blocs = z_blocs(test_espace_prive()); |
---|
432 | $bloc_principal = reset($z_blocs) . '/'; |
---|
433 | } |
---|
434 | |
---|
435 | // Si c'est un article de type page et qu'il existe un squelette du bon nom |
---|
436 | if ( |
---|
437 | $flux['args']['fond'] == $bloc_principal . 'article' |
---|
438 | and $contexte = isset($flux['args']['contexte'])?$flux['args']['contexte']:$GLOBALS['contexte'] |
---|
439 | and $id_article = intval($contexte['id_article']) |
---|
440 | and $page = sql_getfetsel('page', 'spip_articles', 'id_article = ' . $id_article) |
---|
441 | and $ext = $flux['args']['ext'] |
---|
442 | and $f = find_in_path($bloc_principal."article=$page.$ext") |
---|
443 | ) { |
---|
444 | $flux['data'] = substr($f, 0, - strlen(".$ext")); |
---|
445 | } |
---|
446 | |
---|
447 | return $flux; |
---|
448 | } |
---|