source: spip-zone/_plugins_/ezREST/trunk/ezrest/ezrest.php @ 118365

Last change on this file since 118365 was 118365, checked in by eric@…, 3 months ago

Correction de l'appel d'un service de plugin utilisateur : il manquait l'argument erreur.
Ne pas fournir de type d'erreur pour la vérification d'une ressource.
Suppression d'un item de langue devenu inutile

  • Property svn:eol-style set to native
File size: 22.9 KB
Line 
1<?php
2/**
3 * Ce fichier contient l'ensemble des services de gestion des requêtes, des réponses et de traitement
4 * des données des collections et des ressources.
5 * Certains de ces services peuvent être personnalisés par l'appel d'un service spécifique du plugin utilisateur.
6 *
7 * @package SPIP\EZREST\SERVICE
8 */
9if (!defined('_ECRIRE_INC_VERSION')) {
10        return;
11}
12
13
14// -----------------------------------------------------------------------
15// --------------- SERVICES DE GESTION DU CONTEXTE SERVEUR ---------------
16// -----------------------------------------------------------------------
17
18/**
19 * Détermine si le serveur est capable de répondre aux requêtes.
20 * Par défaut, l'API ezREST ne fait aucune vérification. C'est donc au plugin utilisateur de fournir
21 * un service spécifique si une vérification globale doit être effectuée afin d'assurer le fonctionnement de
22 * l'API.
23 *
24 * Si une erreur est détectée, le plugin utilisateur ne renvoie le type, l'élément et la valeur qui provoque l'erreur
25 * sachant que c'est le service par défaut qui positionne le code.
26 *
27 * @param string $plugin Préfixe du plugin utilisateur de ezrest et donc fournisseur de la collection.
28 * @param &array $erreur Tableau initialisé avec les index identifiant l'erreur ou vide si pas d'erreur.
29 *
30 * @return bool
31 *        `true` si la valeur est valide, `false` sinon.
32 */
33function ezrest_api_verifier_contexte($plugin, &$erreur) {
34
35        // Initialise le retour à true par défaut.
36        $est_valide = true;
37
38        // Appel d'un service spéficique au plugin fournisseur pour vérifier si le contexte permet l'utilisation de l'API.
39        if ($verifier = ezrest_service_chercher($plugin, 'api_verifier_contexte')) {
40                // On initialise l'erreur avec son code 501 et son module, le plugin utilisateur.
41                // Par contre, le type est passé à vide parce que c'est au plugin de choisir son identifiant d'erreur 501.
42                $erreur = ezrest_erreur_initialiser($plugin, 501, '');
43                $est_valide = $verifier($erreur);
44        }
45
46        // S'assurer que le bloc d'erreur est vide si aucune erreur n'a été détectée.
47        if ($est_valide) {
48                $erreur = array();
49        }
50
51        return $est_valide;
52}
53
54
55// -----------------------------------------------------------------------
56// ------------------ SERVICES DE GESTION DES REPONSES -------------------
57// -----------------------------------------------------------------------
58
59/**
60 * Initialise le contenu d'une réponse qui se présente comme un tableau associatif.
61 * En particulier, la fonction stocke les éléments de la requête et positionne le bloc d'erreur
62 * par défaut à ok.
63 *
64 * Ce service standard n'est pas personnalisable par un plugin utilisateur.
65 *
66 * @param Symfony\Component\HttpFoundation\Request $requete
67 *      Objet requête fourni par le plugin Serveur HTTP abstrait.
68 *
69 * @return array
70 *      Le contenu initial de l'API `ezrest` est un tableau associatif à 3 entrées:
71 *      - `requete` : sous-tableau des éléments de la requête
72 *      - `erreur`  : sous-tableau des éléments descriptifs d'une erreur (status 200 par défaut)
73 *      - `donnees` : le tableau des objets demandés fonction de la requête (vide)
74 */
75function ezrest_reponse_initialiser_contenu($requete) {
76
77        // Stockage des éléments de la requête
78        // -- La méthode
79        $demande = array('methode' => $requete->getMethod());
80        // -- Les éléments format, collection et ressource
81        $demande = array_merge($demande, $requete->attributes->all());
82        // -- Les critères de filtre fournis comme paramètres de l'url.
83        //    Si on utilise une URL classique avec spip.php il faut exclure certains paramètres.
84        $demande['filtres'] = $requete->query->all();
85        $demande['filtres'] = array_diff_key(
86                $demande['filtres'],
87                array_flip(array('action', 'arg', 'lang', 'var_zajax'))
88        );
89        // -- Le format du contenu de la réponse est toujours le JSON
90        $demande['format_contenu'] = 'json';
91
92        // Initialisation du bloc d'erreur à ok par défaut
93        $erreur = ezrest_erreur_initialiser('ezrest', 200, 'ok');
94        $erreur = ezrest_reponse_expliquer_erreur('ezrest', $erreur, '');
95
96        // On intitialise le contenu avec les informations collectées.
97        // A noter que le format de sortie est initialisé par défaut à json indépendamment de la demande, ce qui permettra
98        // en cas d'erreur sur le format demandé dans la requête de renvoyer une erreur dans un format lisible.
99        $contenu = array(
100                'requete' => $demande,
101                'erreur'  => $erreur,
102                'donnees' => array()
103        );
104
105        return $contenu;
106}
107
108/**
109 * Complète l'initialisation du contenu d'une réponse avec des informations sur le plugin utilisateur.
110 * REST Factory remplit de façon standard un nouvel index `plugin` du contenu et permet ensuite au plugin
111 * utilisateur de personnaliser encore le contenu initialisé, si besoin.
112 *
113 * @param string $plugin Préfixe du plugin utilisateur de ezrest et donc fournisseur de la collection.
114 * @param $contenu
115 *
116 * @return array
117 *      Le contenu initial de l'API `ezrest` est un tableau associatif à 3 entrées:
118 *      - `requete` : sous-tableau des éléments de la requête
119 */
120function ezrest_reponse_informer_plugin($plugin, $contenu) {
121
122        // On met à jour les informations sur le plugin utilisateur maintenant qu'il est connu.
123        // -- A minima on enregistre le préfixe et la version du plugin.
124        include_spip('inc/filtres');
125        $informer = charger_filtre('info_plugin');
126        $version = $informer($plugin, 'version', true);
127
128        $contenu = array_merge(
129                array(
130                        'fournisseur' => array(
131                                'plugin'  => strtoupper($plugin),
132                                'version' => $version,
133                        )
134                ),
135                $contenu
136        );
137
138        // -- On ajoute le schéma de données du plugin si il existe.
139        include_spip('inc/config');
140        $schema = lire_config("${plugin}_base_version", null);
141        if (!is_null($schema)) {
142                $contenu['fournisseur']['schema'] = $schema;
143        }
144
145        // Appel d'un service spécifique au plugin utilisateur pour compléter l'initialisation si besoin.
146        if ($completer = ezrest_service_chercher($plugin, 'reponse_informer_plugin')) {
147                $contenu = $completer($contenu);
148        }
149
150        return $contenu;
151}
152
153
154/**
155 * Complète le bloc d'erreur avec le titre et l'explication de l'erreur.
156 *
157 * @param string $plugin Préfixe du plugin utilisateur de ezrest et donc fournisseur de la collection.
158 * @param array  $erreur Tableau initialisé avec les éléments de base de l'erreur (`status`, `type`, `element` et `valeur`).
159 * @param string $collection
160 *
161 * @return array
162 *        Tableau de l'erreur complété avec le titre (index `title`) et le descriptif (index `detail`).
163 */
164function ezrest_reponse_expliquer_erreur($plugin, $erreur, $collection = '') {
165
166        // Calcul des paramètres qui seront passés à la fonction de traduction.
167        // -- on passe toujours la collection qui est vide uniquement pour l'erreur de serveur et l'extra qui peut aussi
168        //    être vide parfois.
169        $parametres = array(
170                'element'    => $erreur['element'],
171                'valeur'     => $erreur['valeur'],
172                'collection' => $collection,
173                'extra'      => $erreur['extra']
174        );
175        // -- inutile de conserver l'extra dans le bloc d'erreur
176        unset($erreur['extra']);
177
178        // Traduction du libellé de l'erreur.
179        $item = $erreur['module']['titre'] . ':erreur_' . $erreur['status'] . '_' . $erreur['type'] . '_titre';
180        $erreur['titre'] = _T($item, $parametres);
181        // Traduction du message complémentaire.
182        $item = $erreur['module']['detail'] . ':erreur_' . $erreur['status'] . '_' . $erreur['type'] . '_message';
183        $erreur['detail'] = _T($item, $parametres);
184        // -- inutile de conserver l'information sur les modules fournissant les items de langue.
185        unset($erreur['module']);
186
187        // Appel d'un service spécifique au plugin utilisateur pour compléter le bloc d'erreur si besoin.
188        if ($expliquer = ezrest_service_chercher($plugin, 'reponse_expliquer_erreur')) {
189                $erreur = $expliquer($erreur);
190        }
191
192        return $erreur;
193}
194
195
196/**
197 * Finalise la réponse à la requête en complétant le header et le contenu mis au préalable
198 * au format JSON.
199 *
200 * Ce service standard n'est pas personnalisable par un plugin utilisateur.
201 *
202 * @param Symfony\Component\HttpFoundation\Response $reponse
203 *      Objet réponse tel qu'initialisé par le serveur HTTP abstrait.
204 * @param array                                     $contenu
205 *              Tableau du contenu de la réponse qui sera retourné en JSON.
206 *
207 * @return Symfony\Component\HttpFoundation\Response $reponse
208 *      Retourne l'objet réponse dont le contenu et certains attributs du header sont mis à jour.
209 */
210function ezrest_reponse_construire($reponse, $contenu) {
211
212        // Charset UTF-8 et statut de l'erreur.
213        $reponse->setCharset('utf-8');
214        $reponse->setStatusCode($contenu['erreur']['status']);
215
216        // Format JSON exclusif pour les réponses.
217        $reponse->headers->set('Content-Type', 'application/json');
218        $reponse->setContent(json_encode($contenu));
219
220        return $reponse;
221}
222
223
224// -----------------------------------------------------------------------
225// ------------------ SERVICES DE GESTION DES REQUETES -------------------
226// -----------------------------------------------------------------------
227
228/**
229 * Détermine si la collection demandée est valide. Par défaut, REST Factory vérifie que la collection est bien
230 * déclarée dans la liste des collections. Si c'est le cas, la fonction permet ensuite au plugin utilisateur de
231 * compléter la vérification, si besoin.
232 *
233 * @param string $collection
234 *        La valeur de la collection demandée
235 * @param array  $collections
236 *        Configuration des collections disponibles.
237 * @param &string   $plugin Préfixe du plugin fournisseur de la collection. Chaine vide en entrée et en sortie si
238 *                          une erreur est détectée.
239 * @param &array    $erreur
240 *        Tableau initialisé avec les index identifiant l'erreur ou vide si pas d'erreur.
241 *        Les index mis à jour sont:
242 *        - `status`  : le code de l'erreur HTTP, soit 400
243 *        - `type`    : chaine identifiant l'erreur plus précisément, soit collection_nok
244 *        - `element` : type d'objet sur lequel porte l'erreur, soit collection
245 *        - `valeur`  : la valeur de la collection
246 *
247 * @return bool
248 *        `true` si la valeur est valide, `false` sinon.
249 */
250function ezrest_collection_verifier($collection, $collections, &$plugin, &$erreur) {
251
252        // Initialise le retour à false par défaut.
253        $est_valide = false;
254
255        // Vérification de la disponibilité de la collection demandée.
256        foreach ($collections as $_collection => $_configuration) {
257                if ($collection == $_collection) {
258                        // la collection est déclarée, on renvoie le plugin fournisseur et aucune erreur.
259                        $est_valide = true;
260                        $plugin = $_configuration['module'];
261                        break;
262                }
263        }
264
265        // La collection n'est pas déclarée, on renvoie une erreur et pas de plugin.
266        if (!$est_valide) {
267                $erreur = ezrest_erreur_initialiser(
268                        'ezrest',
269                        400,
270                        'collection_indisponible',
271                        'collection',
272                        $collection,
273                        implode(', ', array_keys($collections))
274                );
275        } else {
276                // Appel d'un service spécifique au plugin utilisateur pour compléter la vérification si besoin.
277                if ($verifier = ezrest_service_chercher($plugin, 'verifier', $collection)) {
278                        $erreur = ezrest_erreur_initialiser(
279                                $plugin,
280                                400,
281                                'collection_nok',
282                                'collection',
283                                $collection
284                        );
285                        $est_valide = $verifier($erreur);
286                }
287        }
288
289        // S'assurer que le bloc d'erreur est vide si aucune erreur n'a été détectée.
290        if ($est_valide) {
291                $erreur = array();
292        }
293
294        return $est_valide;
295}
296
297
298/**
299 * Détermine si la valeur de chaque critère de filtre d'une collection est valide.
300 * Si plusieurs critères sont fournis, la fonction s'interromp dès qu'elle trouve un
301 * critère non admis ou dont la valeur est invalide.
302 *
303 * @param string $plugin Préfixe du plugin utilisateur de ezrest et donc fournisseur de la collection.
304 * @param array  $filtres
305 *        Tableau associatif des critères de filtre (couple nom du critère, valeur du critère)
306 * @param string $collection
307 *        La collection concernée.
308 * @param array  $configuration
309 *        Configuration de la collection concernée. L'index `filtres` contient la liste des critères admissibles
310 *        et l'index `module` contient le nom du fichier des fonctions de service.
311 * @param &array $erreur
312 *        Tableau initialisé avec les index identifiant l'erreur ou vide si pas d'erreur.
313 *        Les index mis à jour sont:
314 *        - `status`  : le code de l'erreur HTTP, soit 400
315 *        - `type`    : chaine identifiant l'erreur plus précisément, soit critere_nok
316 *        - `element` : nom du critère en erreur
317 *        - `valeur`  : valeur du critère
318 *
319 * @return bool
320 *        `true` si la valeur est valide, `false` sinon.
321 */
322function ezrest_collection_verifier_filtre($plugin, $filtres, $collection, $configuration, &$erreur) {
323
324        // Initialise le retour à true par défaut.
325        $est_valide = true;
326
327        // 1- Vérification de l'absence de critère obligatoire.
328        foreach ($configuration['filtres'] as $_filtre) {
329                if (!empty($_filtre['est_obligatoire'])
330                and (!isset($filtres[$_filtre['critere']]))) {
331                        $erreur = ezrest_erreur_initialiser(
332                                'ezrest',
333                                400,
334                                'critere_obligatoire_nok',
335                                'critere',
336                                $_filtre['critere']
337                        );
338                        $est_valide = false;
339                        break;
340                }
341        }
342
343        // 2- Vérification des critères fournis
344        if ($est_valide and $filtres) {
345                // On arrête dès qu'une erreur est trouvée et on la reporte.
346                foreach ($filtres as $_critere => $_valeur) {
347                        $extra = '';
348                        // On vérifie si le critère est admis.
349                        $criteres = array_column($configuration['filtres'], null, 'critere');
350                        if (!in_array($_critere, array_keys($criteres))) {
351                                $erreur = ezrest_erreur_initialiser(
352                                        'ezrest',
353                                        400,
354                                        'critere_nom_nok',
355                                        'critere',
356                                        $_critere,
357                                        implode(', ', array_keys($criteres))
358                                );
359                                $est_valide = false;
360                                break;
361                        } else {
362                                // On vérifie si la valeur du critère est valide :
363                                // -- le critère est vérifié par une fonction spécifique qui est soit liée au critère soit globale à
364                                //    la fonction. Si cette fonction n'existe pas le critère est réputé valide.
365                                $module = !empty($criteres[$_critere]['module'])
366                                        ? $criteres[$_critere]['module']
367                                        : $plugin;
368                                if ($verifier = ezrest_service_chercher($module, 'verifier_filtre', $collection, $_critere)) {
369                                        $erreur = ezrest_erreur_initialiser(
370                                                $module,
371                                                400,
372                                                '',
373                                                $_critere,
374                                                $_valeur
375                                        );
376                                        if (!$verifier($_valeur, $erreur)) {
377                                                $est_valide = false;
378                                                break;
379                                        }
380                                }
381                        }
382                }
383        }
384
385        // S'assurer que le bloc d'erreur est vide si aucune erreur n'a été détectée.
386        if ($est_valide) {
387                $erreur = array();
388        }
389
390        return $est_valide;
391}
392
393
394/**
395 * Détermine si le type de ressource demandée est valide.
396 * Le service ne fournit que des ressources de type plugin (`plugins`).
397 *
398 * @param string $plugin Préfixe du plugin utilisateur de ezrest et donc fournisseur de la collection.
399 * @param string $ressource
400 *        La valeur de la ressource demandée. La ressource appartient à une collection.
401 * @param string $collection
402 *        La collection concernée.
403 * @param array  $configuration
404 *        Configuration de la collection de la ressource. L'index `ressource` identifie le champ attendu pour désigner
405 *        la ressource et l'index `module` contient le nom du fichier des fonctions de service.
406 * @param &array    $erreur
407 *        Tableau initialisé avec les index identifiant l'erreur ou vide si pas d'erreur.
408 *        Les index mis à jour sont:
409 *        - `status`  : le code de l'erreur HTTP, soit 400
410 *        - `type`    : chaine identifiant l'erreur plus précisément, soit ressource_nok
411 *        - `element` : type d'objet sur lequel porte l'erreur, soit ressource
412 *        - `valeur`  : la valeur de la ressource
413 *
414 * @return bool
415 *        `true` si la valeur est valide, `false` sinon.
416 */
417function ezrest_collection_verifier_ressource($plugin, $ressource, $collection, $configuration, &$erreur) {
418
419        // Initialise le retour à true par défaut.
420        $est_valide = true;
421
422        // Vérification de la disponibilité de l'accès à une ressource pour la collection concernée
423        if (empty($configuration['ressource'])) {
424                // Récupération de la liste des collections disponibles pour lister celles avec ressources dans le message.
425                $declarer = charger_fonction('ezrest_declarer_collections', 'inc');
426                $collections = $declarer();
427                $ressources = array();
428                foreach ($collections as $_collection => $_config) {
429                        if (!empty($_config['ressource'])) {
430                                $ressources[] = $_collection;
431                        }
432                }
433                $erreur = ezrest_erreur_initialiser(
434                        'ezrest',
435                        400,
436                        'ressource_indisponible',
437                        'ressource',
438                        $ressource,
439                        implode(', ', $ressources)
440                );
441                $est_valide = false;
442        } else {
443                // Vérification de la validité de la ressource demandée.
444                // -- la ressource est vérifiée par une fonction spécifique. Si elle n'existe pas la ressource est
445                //    réputée valide.
446                if ($verifier = ezrest_service_chercher($plugin, 'verifier_ressource', $collection, $configuration['ressource'])) {
447                        $erreur = ezrest_erreur_initialiser(
448                                $plugin,
449                                400,
450                                '',
451                                'ressource',
452                                $ressource,
453                                $configuration['ressource']
454                        );
455                        if (!$verifier($ressource, $erreur)) {
456                                $est_valide = false;
457                        }
458                }
459        }
460
461        // S'assurer que le bloc d'erreur est vide si aucune erreur n'a été détectée.
462        if ($est_valide) {
463                $erreur = array();
464        }
465
466        return $est_valide;
467}
468
469
470// -----------------------------------------------------------------------
471// ------------------ SERVICES DE GESTION DES DONNEES --------------------
472// -----------------------------------------------------------------------
473
474/**
475 * @param $plugin
476 *
477 * @return array
478 */
479function ezrest_indexer($collections) {
480
481        // Initialisation des données de la collection à retourner
482        $contenu = array();
483
484        // On contruit la liste des collections disponibles en présentant leur configuration d'une façon la plus
485        // explicite pour les utilisateurs. Les collections sont présentées sous chaque plugin fournisseur.
486        foreach ($collections as $_collection => $_configuration) {
487                // Détermination du plugin fournisseur
488                $plugin = $_configuration['module'];
489
490                // Si c'est la première fois qu'on rencontre le plugin alors on stocke quelques informations sur le plugin.
491                if (!isset($contenu[$plugin])) {
492                        include_spip('inc/filtres');
493                        $informer = charger_filtre('info_plugin');
494                        $version = $informer($plugin, 'version', true);
495                        $nom = $informer($plugin, 'nom', true);
496
497                        $contenu[$plugin]['fournisseur'] = array(
498                                'nom'  => extraire_multi($nom),
499                                'version' => $version,
500                        );
501                }
502
503                // On initialise le contenu de la collection sous l'index du plugin
504                $contenu[$plugin]['collections'][$_collection] = array();
505
506                // -- Informer sur la possibilité de demander une ressource
507                $contenu[$plugin]['collections'][$_collection]['ressource'] = isset($_configuration['ressource'])
508                        ? _T('ezrest:collection_ressource_oui', array('ressource' => $_configuration['ressource']))
509                        : _T('ezrest:collection_ressource_non');
510
511                // -- Informer sur les filtres autorisés
512                if ($_configuration['filtres']) {
513                        foreach ($_configuration['filtres'] as $_filtre) {
514                                $obligatoire = empty($_filtre['est_obligatoire'])
515                                        ? _T('ezrest:collection_filtre_facultatif')
516                                        : _T('ezrest:collection_filtre_obligatoire');
517                                $fournisseur = empty($_filtre['module'])
518                                        ? ''
519                                        : ', ' . _T('ezrest:collection_filtre_fournisseur', array('module' => strtoupper($_filtre['module'])));
520                                $contenu[$plugin]['collections'][$_collection]['filtres'][$_filtre['critere']] = $obligatoire . $fournisseur;
521                        }
522                }
523        }
524
525        return $contenu;
526}
527
528/**
529 * @param $plugin
530 * @param $collection
531 * @param $filtres
532 * @param $configuration
533 *
534 * @return array
535 */
536function ezrest_collectionner($plugin, $collection, $filtres, $configuration) {
537
538        // Initialisation des données de la collection à retourner
539        $contenu = array();
540
541        // Détermination de la fonction de service permettant de récupérer la collection spécifiée
542        // filtrée sur les critères éventuellement fournis.
543        if ($collectionner = ezrest_service_chercher($plugin, 'collectionner', $collection)) {
544                $contenu = $collectionner($filtres, $configuration);
545        }
546
547        return $contenu;
548}
549
550/**
551 * @param $plugin
552 * @param $collection
553 * @param $ressource
554 *
555 * @return array
556 */
557function ezrest_ressourcer($plugin, $collection, $ressource) {
558
559        // Initialisation des données de la collection à retourner
560        $contenu = array();
561
562        // Détermination de la fonction de service permettant de récupérer la collection spécifiée
563        // filtrée sur les critères éventuellement fournis.
564        if ($ressourcer = ezrest_service_chercher($plugin, 'ressourcer', $collection)) {
565                $contenu = $ressourcer($ressource);
566        }
567
568        return $contenu;
569}
570
571
572// -----------------------------------------------------------------------
573// -------------------- UTILITAIRE PROPRE AU PLUGIN ----------------------
574// -----------------------------------------------------------------------
575
576/**
577 * Cherche une fonction donnée en se basant sur le plugin appelant.
578 * Si le plugin utilisateur ne fournit pas la fonction demandée la chaîne vide est renvoyée.
579 *
580 * @internal
581 *
582 * @param string $plugin Préfixe du plugin utilisateur de ezrest et donc fournisseur de la collection.
583 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
584 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
585 * @param string $fonction
586 *        Nom de la fonction de service à chercher.
587 * @param string $prefixe
588 *        Nom de la fonction de service à chercher.
589 * @param string $suffixe
590 *        Nom de la fonction de service à chercher.
591 *
592 * @return string
593 *        Nom complet de la fonction si trouvée ou chaine vide sinon.
594 */
595function ezrest_service_chercher($plugin, $fonction, $prefixe = '', $suffixe = '') {
596
597        $fonction_trouvee = '';
598
599        // Eviter la réentrance si on demande explicitement le plugin ezrest.
600        if ($plugin != 'ezrest') {
601                include_spip("ezrest/${plugin}");
602                $fonction_trouvee = $prefixe ? ($suffixe ? "${prefixe}_${fonction}_${suffixe}" : "${prefixe}_${fonction}") : "${plugin}_${fonction}";
603                if (!function_exists($fonction_trouvee)) {
604                        $fonction_trouvee = '';
605                }
606        }
607
608        return $fonction_trouvee;
609}
610
611/**
612 * Initilise le bloc d'erreur complet.
613 *
614 * @internal
615 *
616 * @param string $plugin  Préfixe du plugin utilisateur de ezrest.
617 * @param int    $code    Code d'erreur standard d'une requête HTTP
618 * @param string $type    Identifiant unique de l'erreur
619 * @param string $element Elément sur lequel porte l'erreur
620 * @param string $valeur  Valeur de l'élément en erreur
621 *
622 * @return array
623 *        Bloc d'erreur complet initialisé avec le code, le plugin et le type.
624 */
625function ezrest_erreur_initialiser($plugin, $code, $type, $element = '', $valeur = '', $extra = '') {
626
627        // On initialise tous les index d'un bloc d'erreur
628        $erreur['status'] = $code;
629        $erreur['type'] = $type;
630        $erreur['element'] = $element;
631        $erreur['valeur'] = $valeur;
632        $erreur['extra'] = $extra;
633        $erreur['titre'] = '';
634        $erreur['detail'] = '';
635
636        // Si le type est précisé c'est que son item de langue est fourni par ezREST.
637        // Sinon, c'est que son item de langue est fourni par le plugin passé en paramètre.
638        $erreur['module']['titre'] = $type ? 'ezrest' : $plugin;
639        $erreur['module']['detail'] = $plugin;
640
641        return $erreur;
642}
Note: See TracBrowser for help on using the repository browser.