source: spip-zone/_plugins_/spip-pmb/trunk/pmb_fonctions.php @ 70443

Last change on this file since 70443 was 57281, checked in by marcimat@…, 9 years ago

quelques corrections + Passage en 2.0.0-beta1

File size: 36.4 KB
Line 
1<?php
2if (!defined("_ECRIRE_INC_VERSION")) return;
3
4/*************************************************************************************/
5/*                                                                                   */
6/*      Portail web pour PMB                                                         */
7/*                                                                                   */
8/*      Copyright (c) OpenStudio                                                     */
9/*      email : info@openstudio.fr                                                   */
10/*      web : http://www.openstudio.fr                                               */
11/*                                                                                   */
12/*      This program is free software; you can redistribute it and/or modify         */
13/*      it under the terms of the GNU General Public License as published by         */
14/*      the Free Software Foundation; either version 3 of the License, or            */
15/*      (at your option) any later version.                                          */
16/*                                                                                   */
17/*      This program is distributed in the hope that it will be useful,              */
18/*      but WITHOUT ANY WARRANTY; without even the implied warranty of               */
19/*      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                */
20/*      GNU General Public License for more details.                                 */
21/*                                                                                   */
22/*      You should have received a copy of the GNU General Public License            */
23/*      along with this program; if not, write to the Free Software                  */
24/*      Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA    */
25/*                                                                                   */
26/*************************************************************************************/
27
28
29include_spip('inc/config');
30
31// charger les fonctions pour le compilateur SPIP
32// boucles (PMB:NOTICES) ...
33include_spip('public/pmb');
34
35
36
37/**
38 * Recupere les informations de locations racine,
39 * c'est a dire la liste des centres documentaires geres par ce PMB
40 *
41 * @return array
42 *              Tableau contenant pour chaque lieu la liste des champs
43 *              que l'on a pu recuperer.
44**/
45function pmb_extraire_locations_racine() {
46
47        static $locations = array();
48        if (count($locations)) {
49                return $locations;
50        }
51
52        try {
53                $ws = pmb_webservice();
54                $r = $ws->pmbesOPACGeneric_list_locations();
55                if (is_array($r)) {
56                        foreach ($r as $index => $location) {
57                                $locations[] = array(
58                                        'id_location' => $location->location_id,
59                                        'titre'       => $location->location_caption,
60                                );
61                        }
62                }
63        } catch (Exception $e) {
64                 echo 'Exception reçue (3) : ',  $e->getMessage(), "\n";
65        }
66        return $locations;
67}
68
69/**
70 * Retourne la liste de tous les rayonnages d'un lieu racine
71 *
72 * @param array $ids_location
73 *              Les parents
74 *
75 * @return array
76 *              Tableau contenant pour chaque section la liste des champs
77 *              que l'on a pu recuperer.
78**/
79function pmb_extraire_sections_depuis_locations_ids($ids_location) {
80        $res = pmb_extraire_abstract_ids('locations', $ids_location,
81                'pmbesOPACGeneric_get_location_information_and_sections');
82               
83        return pmb_get_enfants($res, 'sections');
84}
85
86/**
87 * Partie d'extraction d'une location
88 * dans un resultat de requete a PMB
89**/
90function pmb_extraire_resultat_locations_id($ws_result) {
91        $r = $ws_result;
92
93        //infos de la location
94        //récupérer les infos sur la localisation parent
95        $l = array();
96        $l['id_location_parent'] = $r->location->location_id;
97        $l['titre_parent']       = $r->location->location_caption;
98        $l['sections'] = array();
99
100        if (count($r->sections)) {
101                foreach ($r->sections as $section) {
102                        // enlever l'image par defaut
103                        $l['sections'][] = $s = pmb_extraire_section($section);
104                        // on ne met pas en cacheces sections ci
105                        // parce qu'on ne sait pas si elles ont ou non des enfants...
106                        // on laissera pmb_extraire_sections_depuis_sections_ids decider...
107                        #pmb_cacher('sections', $section->section_id, $s, true);
108                }
109        }
110        return $l;
111}
112
113
114/**
115 * Retourne la liste de tous les sous rayonnages d'un rayonnage...
116 *
117 * @param array $ids_section
118 *              Les parents
119 *
120 * @return array
121 *              Tableau contenant pour chaque section la liste des champs
122 *              que l'on a pu recuperer.
123**/
124function pmb_extraire_sections_depuis_sections_ids($ids_section) {
125        $res = pmb_extraire_sections_ids($ids_section);
126        return pmb_get_enfants($res, 'sections');
127}
128
129
130/**
131 * Retourne les rayonnages demandes...
132 *
133 * @param array $ids_section
134 *              Les demandes
135 *
136 * @return array
137 *              Tableau contenant pour chaque section la liste des champs
138 *              que l'on a pu recuperer.
139**/
140function pmb_extraire_sections_ids($ids_section) {
141        return pmb_extraire_abstract_ids('sections', $ids_section, 'pmbesOPACGeneric_get_section_information');
142}
143
144/**
145 * Partie d'extraction d'une section
146 * dans un resultat de requete a PMB
147**/
148function pmb_extraire_resultat_sections_id($ws_result, $id_section) {
149        $r = $ws_result;
150        $s = pmb_extraire_section($r);
151        // recherche de sous sections
152        $ws = pmb_webservice();
153        $sections = $ws->pmbesOPACGeneric_list_sections($id_section);
154        if (count($sections)) {
155                foreach ($sections as $section) {
156                        $s['sections'][] = $ss = pmb_extraire_section($section);
157                        #pmb_cacher('sections_simples', $ss['id_section'], $ss, true);
158                }
159        }
160        return $s;
161}
162
163
164/**
165 * Retourne des petites infos sur les sections issues de requetes a pmb
166**/
167function pmb_extraire_section($section) {
168        // enlever l'image par defaut
169        $image = (false !== strpos($section->section_image,'rayonnage') ? '' : $section->section_image);
170        $s = array(
171                'id_section'   => $section->section_id,
172                'titre'        => $section->section_caption,
173                'image'        => $image,
174        );
175        return $s;
176}
177
178
179/**
180 * Recupere les informations de notices
181 * dont les identifiants sont fournis par
182 * le tableau $ids_notices.
183 *
184 * Chaque identifiant calcule est mis en cache
185 * pour eviter des requetes intempestives
186 * sur un hit de page et permettre d'utiliser plusieurs
187 * fois une boucle telle que (PMB:NOTICES){id_notice}
188 * sans avoir besoin de tout recalculer.
189 *
190 * Notons que l'on ne peut recuperer que les champs "exportables"
191 * dans PMB.
192 *
193 * @param array $ids_notices
194 *              Tableau d'id de notices a recupereer
195 * @return array
196 *              Tableau contenant pour chaque notice la liste des champs
197 *              que l'on a pu recuperer.
198**/
199function pmb_extraire_notices_ids($ids_notices) {
200        if (!is_array($ids_notices)) {
201                return array();
202        }
203
204        // retrouver les infos en cache
205        list($res, $wanted) = pmb_cacher('notices', $ids_notices);
206
207        // si on a tout trouve, on s'en va...
208        if (!count($wanted)) {
209                return $res;
210        }
211
212        // sinon on complete ce qui manque en interrogeant PMB
213        try {
214                $ws = pmb_webservice();
215                $r=$ws->pmbesNotices_fetchNoticeListArray($wanted,"utf-8",true,false);
216                if (is_array($r)) {
217                        $r = array_map('pmb_ws_parser_notice', $r);
218
219                        // on complete notre tableau de resultat
220                        // avec nos trouvailles
221                        foreach ($r as $notice) {
222                                $key = array_search($notice['id'], $ids_notices);
223                                if ($key !== false) {
224                                        $res[$key] = $notice;
225                                        pmb_cacher('notices', $notice['id'], $notice, true);
226                                }
227                        }
228                }
229        } catch (Exception $e) {
230                echo 'Exception reçue (14) : ',  $e->getMessage(), "\n";
231        }
232        ksort($res);
233        return $res;
234}
235
236
237
238
239
240/**
241 * Recupere les informations des collections
242 * dont les identifiants sont fournis par
243 * le tableau $ids_collection.
244 *
245 * @param array $ids_collection
246 *              Tableau d'id de collections a recupereer
247 * @return array
248 *              Tableau contenant pour chaque collection la liste des champs
249 *              que l'on a pu recuperer.
250**/
251function pmb_extraire_collections_ids($ids_collection) {
252        return pmb_extraire_abstract_ids('collections', $ids_collection, 'pmbesCollections_get_collection_information_and_notices');
253}
254
255/**
256 * Partie d'extraction d'une collection
257 * dans un resultat de requete a PMB
258**/ 
259function pmb_extraire_resultat_collections_id($ws_result) {
260        $r = $ws_result;
261        //infos de la collection
262        $c = array();
263        $c['id_collection']  = $r->information->collection_id;
264        $c['titre']          = $r->information->collection_name;
265        $c['id_parent']      = $r->information->collection_parent;
266        $c['issn']           = $r->information->collection_issn;
267        $c['web']            = $r->information->collection_web;
268        $c['ids_notice']     = $r->notice_ids;
269        return $c;
270}
271
272
273
274
275/**
276 * Recupere les informations des editeurs
277 * dont les identifiants sont fournis par
278 * le tableau $ids_editeur.
279 *
280 * @param array $ids_editeur
281 *              Tableau d'id des editeurs a recupereer
282 * @return array
283 *              Tableau contenant pour chaque editeur la liste des champs
284 *              que l'on a pu recuperer.
285**/
286function pmb_extraire_editeurs_ids($ids_editeur) {
287        return pmb_extraire_abstract_ids('editeurs', $ids_editeur, 'pmbesPublishers_get_publisher_information_and_notices');
288}
289
290/**
291 * Partie d'extraction d'un editeur
292 * dans un resultat de requete a PMB
293**/ 
294function pmb_extraire_resultat_editeurs_id($ws_result) {
295        $r = $ws_result;
296        $e = array();
297        //infos de l'editeur
298        $e['id_editeur']   = $r->information->publisher_id;
299        $e['nom']          = $r->information->publisher_name;
300        $e['adresse1']     = $r->information->publisher_address1;
301        $e['adresse2']     = $r->information->publisher_address2;
302        $e['code_postal']  = $r->information->publisher_zipcode;
303        $e['ville']        = $r->information->publisher_city;
304        $e['pays']         = $r->information->publisher_country;
305        $e['web']          = $r->information->publisher_web;
306        $e['commentaire']  = $r->information->publisher_comment;
307        $e['ids_notice']   = $r->notice_ids;
308        return $e;
309}
310
311
312
313
314/**
315 * Fonction d'abstraction pour mutualiser les
316 * codes de selections en interrogeant PMB.
317
318 * Chaque identifiant calcule (pour chaque objet) est mis en cache
319 * pour eviter des requetes intempestives
320 * sur un hit de page et permettre d'utiliser plusieurs
321 * fois une boucle telle que (PMB:EDITEURS){id_editeur}
322 * sans avoir besoin de tout recalculer.
323 *
324 * @param string $objet
325 *              L'objet (pluriel) 'auteurs'
326 *              necessite une fonction pmb_extraire_resultat_$objet_id()
327 *              soit donc ici pmb_extraire_resultat_auteur_id()
328 *
329 * @param array $ids_objets
330 *              Les ids a obtenir les infos
331 *
332 * @param string $ws_methode
333 *              Methode la classe de webservice de PMB a interroger
334 *              pour obtenir les resultats
335 *
336 * @param string $extraire_fonction
337 *              Fonction pour parser chaque resultat obtenu
338 *              Par defaut : pmb_extraire_resultat_{$objet}_id
339 *
340 * @return array
341 *              Un tableau cle/valeur par element touve
342 *
343**/
344function pmb_extraire_abstract_ids($objet, $ids_objet, $ws_methode, $extraire_fonction='') {
345        if (!is_array($ids_objet)) {
346                return array();
347        }
348       
349        // retrouver les infos en cache
350        list($res, $wanted) = pmb_cacher($objet, $ids_objet);
351
352        // si on a tout trouve, on s'en va...
353        if (!count($wanted)) {
354                return $res;
355        }
356
357        try {
358                $ws = pmb_webservice();
359                foreach ($wanted as $id_objet) {
360                        // second parametre $id_session n'etait pas utilise... kesako ?
361                        // et pas present partout...
362                        $r = $ws->$ws_methode($id_objet);
363                        if ($r) {
364                                if (!$extraire_fonction) {
365                                        $extraire_fonction = 'pmb_extraire_resultat_' . $objet . '_id';
366                                }
367                                $infos = $extraire_fonction($r, $id_objet); // id_objet, aucasou
368                               
369                                $key = array_search($id_objet, $ids_objet);
370                                $res[$key] = $infos;
371                                pmb_cacher($objet, $id_objet, $infos, true);
372                        }
373                }
374
375        } catch (Exception $e) {
376                 echo 'Exception reçue (7) : ',  $e->getMessage(), "\n";
377        }
378
379        return $res;
380}
381
382
383
384
385/**
386 * Petite fonction d'aide pour recuperer d'une liste de tableaux
387 * les valeurs compilees d'une cle de ces tableaux
388 *
389 * entree :
390 *              tab[0][cle] = [n] (tableau...)
391 *              tab[1][cle] = [n]
392 *              tab[i][cle] = [n]
393 *
394 * sortie :
395 *              tab[n] (merge de tous les tableaux [n])
396 *
397**/
398function pmb_get_enfants($tableau, $cle) {
399        $enfants = array();
400        foreach ($tableau as $t) {
401                if (isset($t[$cle]) and is_array($t[$cle])) {
402                        $enfants = array_merge($enfants, $t[$cle]);
403                }
404        }
405        return $enfants;
406}
407
408
409
410/**
411 * Recupere les informations d'auteurs
412 * dont les identifiants sont fournis par
413 * le tableau $ids_auteurs.
414 *
415 * Chaque identifiant calcule est mis en cache
416 * pour eviter des requetes intempestives
417 * sur un hit de page et permettre d'utiliser plusieurs
418 * fois une boucle telle que (PMB:AUTEURS){id}
419 * sans avoir besoin de tout recalculer.
420 *
421 * Notons que l'on ne peut recuperer que les champs "exportables"
422 * dans PMB.
423 *
424 * @param array $ids_auteurs
425 *              Tableau d'id d'auteurs a recupereer
426 * @return array
427 *              Tableau contenant pour chaque auteur la liste des champs
428 *              que l'on a pu recuperer.
429**/
430function pmb_extraire_auteurs_ids($ids_auteur) {
431        return pmb_extraire_abstract_ids('auteurs', $ids_auteur, 'pmbesAuthors_get_author_information_and_notices');
432}
433
434/**
435 * Partie d'extraction d'un auteur
436 * dans un resultat de requete a PMB
437**/ 
438function pmb_extraire_resultat_auteurs_id($ws_result) {
439        $r = $ws_result;
440        $a = array();
441        $a['id_auteur']       = $r->information->author_id;
442        $a['id_type_auteur']  = $r->information->author_type;
443        $a['nom']             = $r->information->author_name;
444        $a['prenom']          = $r->information->author_rejete;
445        if ($r->information->author_rejete) {
446                $a['nomcomplet'] =  $a['prenom'].' '.$a['nom'];
447        } else {
448                $a['nomcomplet'] = $a['nom'];
449        }
450        // what's 'see' ?
451        $a['id_voir']     = $r->information->author_see;
452        $a['date']        = $r->information->author_date;
453        $a['web']         = $r->information->author_web;
454        $a['commentaire'] = $r->information->author_comment;
455        $a['lieu']        = $r->information->author_lieu;
456        $a['ville']       = $r->information->author_ville;
457        $a['pays']        = $r->information->author_pays;
458        $a['subdivision'] = $r->information->author_subdivision;
459        $a['numero']      = $r->information->author_numero;
460        $a['ids_notice']  = $r->notice_ids;
461        return $a;
462}
463
464
465
466
467
468/**
469 * Retourne la liste des notices
470 * ayant etes empruntees par les autres lecteurs
471 * ayant empruntes la ou les notices en parametres
472 *
473 * @param array identifiant(s) de notice
474 * @return array identifiant(s) de notices en relation
475**/
476function pmb_ids_notices_autres_lecteurs($ids_notice) {
477        if (!is_array($ids_notice)) {
478                $ids_notice = array($ids_notice);
479        }
480
481        $listenotices = Array();
482
483        try {
484                $ws = pmb_webservice();
485                if ($ws->pmbesOPACGeneric_is_also_borrowed_enabled()) {
486                        foreach ($ids_notice as $id_notice) {
487                                $r = $ws->pmbesOPACGeneric_also_borrowed($id_notice, 0);
488                                if (is_array($r)) {
489                                        foreach ($r as $notice) {
490                                                $listenotices[] = $notice['notice_id'];
491                                        }
492                                }
493                        }
494                        $listenotices = array_unique($listenotices);
495                }
496        }catch (Exception $e) {
497                echo 'Exception reçue (10) : ',  $e->getMessage(), "\n";
498        }
499       
500        return $listenotices;
501}
502
503
504
505/**
506 * Retourne la liste des documents d'une notice
507 *
508 * @param string $ids_notice
509 *              Liste des identifiants de notices dont les documents sont a recuperer
510 *
511 * @return array
512 *              Liste des documents
513**/
514function pmb_extraire_documents_ids($ids_notice) {
515
516        // retrouver les infos en cache
517        list($res, $wanted) = pmb_cacher('documents', $ids_notice);
518
519        // si on a tout trouve, on s'en va...
520        if (!count($wanted)) {
521                return pmb_get_enfants($res, 'documents');
522        }
523       
524        try {
525                $ws = pmb_webservice();
526                foreach ($ids_notice as $id_notice) {
527                        // 2e. parametre $id_session non ulitise
528                        $r=$ws->pmbesNotices_listNoticeExplNums($id_notice);
529                        $documents = array();
530                        if (is_array($r)) {
531                                foreach ($r as $document) {
532                                        $d = array();
533                                        $d['titre']         = pmb_nettoyer_caracteres($document->name);
534                                        $d['id_document'] = $document->id;
535                                        $d['id_notice']   = $id_notice;
536                                        $d['mimetype']    = $document->mimetype;
537                                        $d['image']       = (strpos($d['mimetype'],'image')!==false)?'oui':'non';
538                                        $d['source']                = $document->url;
539                                        $d['source_telechargement'] = $document->downloadUrl;
540                                        $documents[] = $d;
541                                }
542                        }
543                        // remettre dans les demandes et sauver en cache
544                        $key = array_search($id_notice, $ids_notice);
545                        $res[$key] = array('documents'=>$documents);
546                        pmb_cacher('documents', $id_notice, $res[$key], true);
547                }
548
549        } catch (Exception $e) {
550                 echo 'Exception reçue (11) : ',  $e->getMessage(), "\n";
551        } 
552
553        // si on a tout trouve, on s'en va...
554        return pmb_get_enfants($res, 'documents');
555       
556}
557
558
559/**
560 * Retourne la liste des exemplaires (item)
561 * d'une notice (identifiant d'un ouvrage/document)
562 *
563 * @param string $ids_notice
564 *              Liste des identifiants de notices dont les exemplaires sont a recuperer
565 *
566 * @return array
567 *              Liste des exemplaires
568**/
569function pmb_extraire_exemplaires_ids($ids_notice) {
570        # meme fonctionnement que pmb_extraire_documents_ids()
571        if (!$ids_notice) {
572                return array();
573        }
574        $res = Array();
575
576        try {
577                $ws = pmb_webservice();
578                foreach ($ids_notice as $id_notice) {
579                        // second parametre $id_session non utilise
580                        $exemplaires = $ws->pmbesItems_fetch_notice_items($id_notice);
581                        if (is_array($exemplaires)) {
582                                foreach ($exemplaires as $exemplaire) {
583                                        $e = Array();
584                                        $e['id']               = $exemplaire->id;
585                                        $e['id_notice']        = $id_notice;
586                                        $e['code_barre']       = $exemplaire->cb;
587                                        $e['cote']             = $exemplaire->cote;
588                                        $e['id_location']      = $exemplaire->location_id;
589                                        $e['titre_location']   = $exemplaire->location_caption;
590                                        $e['id_section']       = $exemplaire->section_id;
591                                        $e['titre_section']    = $exemplaire->section_caption;
592                                        $e['statut']           = $exemplaire->statut;
593                                        $e['support']          = $exemplaire->support;
594                                        $e['situation']        = $exemplaire->situation;
595                                        $res[] = $e;
596                                }
597                        }
598                }
599        } catch (Exception $e) {
600                 echo 'Exception reçue (12) : ',  $e->getMessage(), "\n";
601        }
602       
603        return $res;
604}
605
606
607/**
608 * Retourne la liste des prets
609 * d'un auteur pmb authentifie
610 *
611 * @param string $ids_pmb_session
612 *              Sessions pmb de/des auteurs
613 *
614 * @param int $type_pret
615 *              Type de reponse :
616 *              1 : les prets en cours
617 *              0 : les prets en retard
618 *
619 * @return array
620 *              Liste des prets
621**/
622function pmb_extraire_prets_ids($ids_pmb_session, $type_pret=0) {
623        $ids_pmb_session = array_filter($ids_pmb_session);
624        if (!$ids_pmb_session) {
625                return array();
626        }
627        $prets = array();
628        $notices = Array();
629        $ws = pmb_webservice();
630       
631        foreach ($ids_pmb_session as $id_pmb_session) {
632                $les_prets = $ws->pmbesOPACEmpr_list_loans($id_pmb_session, $type_pret);
633                if (is_array($les_prets)) {
634                        foreach ($les_prets as $pret) {
635                                $p = array();
636                                $p['id_emprunteur']             = $pret->empr_id;
637                                $p['id_notice']                 = $pret->notice_id;
638                                $p['id_bulletin']               = $pret->bulletin_id;
639                                $p['exemplaire_id']             = $pret->expl_id;
640                                $p['exemplaire_code_barre']     = $pret->expl_cb;
641                                $p['exemplaire_support']        = $pret->expl_support;
642                                $p['exemplaire_id_location']    = $pret->expl_location_id;
643                                $p['exemplaire_titre_location'] = $pret->expl_location_caption;
644                                $p['exemplaire_id_section']     = $pret->expl_section_id;
645                                $p['exemplaire_titre_section']  = $pret->expl_section_caption;
646                                $p['exemplaire_libelle']        = $pret->expl_libelle;
647                                $p['date_debut']                = $pret->loan_startdate;
648                                $p['date_retour']               = $pret->loan_returndate;
649                                $notices[] = $pret->notice_id;
650                                $prets[] = $p;
651                        }
652                }
653        }
654        if ($prets) {
655                // on integre les informations des notices
656                $notices = pmb_extraire_notices_ids($notices);
657                // (pas tres optimise... mais y en a pas beaucoup)
658                foreach ($prets as $c=>$p) {
659                        foreach ($notices as $n) {
660                                if ($p['id_notice'] == $n['id_notice']) {
661                                        $prets[$c]['notice'] = $n;
662                                        break;
663                                }
664                        }
665                }
666        }
667        return $prets;
668}
669
670/**
671 * Retourne les reservations demandes...
672 *
673 * @param array $ids_pmb_session
674 *              Les demandes, des 'pmb_session' (table spip_auteurs_pmb)
675 *
676 * @return array
677 *              Tableau contenant les reservations
678 *              Et dans 'notice' de chaque reservation
679 *              les informations de la notice correspondante.
680**/
681function pmb_extraire_reservations_ids($ids_pmb_session) {
682        $ids_pmb_session = array_filter($ids_pmb_session);
683        if (!$ids_pmb_session) {
684                return array();
685        }
686       
687        $resas = array();
688        $notices = Array();
689        $ws = pmb_webservice();
690       
691        foreach ($ids_pmb_session as $id_pmb_session) {
692                $reservations = $ws->pmbesOPACEmpr_list_resas($id_pmb_session);
693                if (is_array($reservations)) {
694                        foreach ($reservations as $reservation) {
695                                $r = array();
696                                $r['id_reservation']      = $reservation->resa_id;
697                                $r['id_emprunteur']       = $reservation->empr_id;
698                                $r['id_notice']           = $reservation->notice_id;
699                                $r['id_bulletin']         = $reservation->bulletin_id;
700                                $r['rank']                = $reservation->resa_rank;
701                                $r['date_fin']            = $reservation->resa_dateend;
702                                $r['retrait_id_location'] = $reservation->resa_retrait_location_id ;
703                                $r['retrait_location']    = $reservation->resa_retrait_location;
704                                $notices[] = $reservation->notice_id;
705                                $resas[] = $r;
706                        }
707                }
708        }
709        if ($resas) {
710                // on integre les informations des notices
711                $notices = pmb_extraire_notices_ids($notices);
712                // (pas tres optimise... mais y en a pas beaucoup)
713                foreach ($resas as $c=>$r) {
714                        foreach ($notices as $n) {
715                                if ($r['id_notice'] == $n['id_notice']) {
716                                        $resas[$c]['notice'] = $n;
717                                        break;
718                                }
719                        }
720                }
721        }
722        return $resas;
723}
724
725
726
727
728/**
729 * Retourne la liste des identifiants de notices trouvees
730 *
731 * @param Array $demande
732 *              Description des différentes criteres de recherche (cle/valeur)
733 *              - recherche
734 *
735 * @param int $nbTotal
736 *              Sera renseigne par le nombre total de resultats trouves
737 *
738 * @param int $debut
739 *              Position du premier resultat renvoye
740 *
741 * @param int $nombre
742 *              Nombre de resultats renvoyes
743 *
744 * @return array
745 *              Ids des notices trouvees
746**/
747function pmb_ids_notices_recherches($demande, &$nbTotal, $debut=0, $nombre=5, $pagination=false) {
748       
749        $recherche          = $demande['recherche'];
750        $id_section         = $demande['id_section'];
751        $id_section_parent  = $demande['id_section_parent'];
752        $id_location        = $demande['id_location'];
753        $typdoc             = $demande['type_document'];
754        $look               = $demande['look'];
755       
756        if ($id_section_parent) {
757                $id_location = $id_section_parent; // a n'y rien comprendre...
758        }
759
760        $recherche = str_replace("+"," ",$recherche);
761
762        if (!$look) $look = array();
763        $look = array_flip($look);
764        $tous = true;
765
766
767        // si tout coche
768        if (isset($look['ALL'])) {
769                $tous = true;
770        // ou tout pas coche mais autre chose de coche...
771        } elseif (count($look)) {
772                $tous = false;
773        }
774       
775        if ($recherche=='*') {
776                $recherche='';
777        }
778       
779        $searchType = 0;
780        $sort = '';
781        $ids = array();
782        $debut;   // indice du premier resultat
783        $nombre;  // nombre de resultats
784
785        // types de recherches
786        $types = array(
787                'TITLE' => 1,
788                'AUTHOR' => 2,
789                'PUBLISHER' => 3,
790                'COLLECTION' => 4,
791                'CATEGORY' => 6,
792        );
793        // je reproduis a peu pres tel que le code d'avant
794        // mais c'est assez etrange que si plusieurs choses
795        // sont cochees, c'est le dernier type qui est pris
796        // (le plus eleve)
797        foreach ($types as $nom=>$index) {
798                if (isset($look[$nom]) and $look[$nom]) {
799                        $searchType = $index;
800                }
801        }
802
803        // ajout des criteres de recherche.
804        if ($recherche) {
805                $search[] = array("inter"=>"or", "field"=>42, "operator"=>"BOOLEAN", "value"=>$recherche);
806
807                $look_correspondances = array(
808                        'TITLE' => 1,
809                        'AUTHOR' => 2,
810                        'PUBLISHER' => 3,
811                        'COLLECTION' => 4,
812                        'ABSTRACT' => 10,
813                        'CATEGORY' => 11,
814                        'INDEXINT' => 12,
815                        'KEYWORDS' => 13,
816                );
817                foreach ($look_correspondances as $nom=>$id) {
818                        if (isset($look[$nom]) and $look[$nom]) {
819                                $search[] = array("inter"=>"or", "field"=>$id, "operator"=>"BOOLEAN", "value"=>$recherche);
820                        }
821                }
822        }
823
824        if ($typdoc)            $search[] = array("inter"=>"and", "field"=>15, "operator"=>"EQ", "value"=>$typdoc);
825        if ($id_section)        $search[] = array("inter"=>"and", "field"=>17, "operator"=>"EQ", "value"=>$id_section);
826        if ($id_location)       $search[] = array("inter"=>"and", "field"=>16, "operator"=>"EQ", "value"=>$id_location);
827
828        try {
829                $ws = pmb_webservice();
830
831                // demande de recherche...
832                if ($tous and !$id_section and !$id_location) {
833                        $r = $ws->pmbesOPACAnonymous_simpleSearch($searchType,$recherche);
834/*
835                } else if (($tous AND $id_section AND !$typdoc)){
836                        $r=$ws->pmbesSearch_simpleSearchLocalise($searchType,$recherche,$id_location,$id_section);
837*/
838                } else {
839                        $r=$ws->pmbesOPACAnonymous_advancedSearch($search);
840                }
841
842                // on obtient une cle specifique a PMB avec le nombre de resultats... c'est tout.
843                $searchId=$r->searchId;
844                $nbTotal = $r->nbResults;
845
846                // pas de nombre... pas la peine de continuer !
847                if ($nbTotal) {
848                        // le critere de tri semble dependre de ce qui a ete defini dans PMB dans une table 'tris'
849                        // l'inconvenient ici, c'est que PMB retourne tous les champs
850                        // et pas uniquement l'identifiant, ce qui est inutile et charge la connexion
851                        // et le travail de PMB, mais il n'y a pas de moyen a cette heure ci pour ne demmander que les ids.
852                        $r=$ws->pmbesOPACAnonymous_fetchSearchRecordsArraySorted($searchId,$debut,$nombre,"utf-8",false,false,$sort);
853                        if (is_array($r)) {
854                                foreach ($r as $n) {
855                                        $ids[] = $n->id;
856                                }
857                        }
858                        // la, on fait un truc rigolo pour SPIP...
859                        // on remplit de 0 avant le debut, et apres la fin de la pagination
860                        // jusqu'au nombre de resultats, pour faire croire que tous les elements
861                        // sont la.
862                        // 15 resultats, debut = 5, nb = 5
863                        // 0 0 0 0 0 2 4 5 12 18 0 0 0 0
864                        if ($pagination) {
865                                $vide = array_fill(0, $nbTotal, 0); // que des 0
866                                array_splice($vide, $debut, $nombre, $ids);
867                                $ids = $vide;
868                        }
869                }
870        } catch (Exception $e) {
871                echo 'Exception reçue (8) : ',  $e->getMessage(), "\n";
872        }
873
874        return $ids;
875}
876
877
878
879/**
880 * Retourne la liste de toutes les options de recherche
881 * (il semblerait !)
882**/
883function pmb_recuperer_champs_recherche($langue=0) {
884        $tresultat = Array();
885       
886        try {
887                $ws = pmb_webservice();
888                $result = $ws->pmbesSearch_getAdvancedSearchFields('opac|search_fields',$langue,true);
889                $cpt=0;
890                if (is_array($result)) {
891                        foreach ($result as &$res) {
892                                $tresultat[$cpt] = Array();
893                                $tresultat[$cpt]['id'] = $res->id;
894                                $tresultat[$cpt]['label'] = $res->label;
895                                $tresultat[$cpt]['type'] = $res->type;
896                                $tresultat[$cpt]['operators'] = $res->operators;
897                                $tresultat[$cpt]['values'] = Array();
898                                $cpt2=0;
899                                if (is_array($res->values)) {
900                                        foreach ($res->values as &$value) {
901                                                $tresultat[$cpt]['values'][$cpt2]['value_id'] = $value->value_id;
902                                                $tresultat[$cpt]['values'][$cpt2]['value_caption'] = $value->value_caption;
903                                                $cpt2++;
904                                        }
905                                }
906                                $cpt++;
907                        }
908                }
909        } catch (Exception $e) {
910                 echo 'Exception reçue (9) : ',  $e->getMessage(), "\n";
911        } 
912        return $tresultat;
913}
914
915
916/**
917 * Analyse un tableau de proprietes UNIMARC
918 * Contrairement aux apparences, ces numeros
919 * et cles signifient quelque chose !
920 *
921 * http://www.bnf.fr/fr/professionnels/anx_formats/a.unimarc_manuel_format_bibliographique.html
922 * http://www.bnf.fr/documents/UNIMARC%28B%29_conversion.pdf
923 *
924 * @param array $value Tableau UNIMARC a traduire
925 * @return array Tableau traduit
926**/
927function pmb_ws_parser_notice($value) {
928       
929        // mise en cache des resultats en fonction de $value
930        static $resultats = array();
931        // on utilise le cache s'il est la.
932        $hash = md5(serialize($value));
933        if (isset($resultats[$hash])) {
934                return $resultats[$hash];
935        }
936       
937
938        include_spip('inc/unimarc');
939
940        $tresultat = Array();
941        $id_notice = $value->id;
942
943        if (isset($value->f) && is_array($value->f)) {
944                foreach($value->f as $informations) {
945                        #echo "\n<pre>"; print_r($informations); echo "</pre>";
946                        if ($res = pmb_parse_unimarc($informations)) {
947                                foreach ($res as $r) {
948                                        $cle = $r['cle'];
949                                       
950                                        // pour chaque variable retournee, on la stocke
951                                        // dans le tableau de resultat.
952                                        // il se peut qu'il y ait des traitements a effectuer
953                                        // tel que merger des champs s'ils existaient deja.
954                                       
955                                        if (isset($r['params']) AND isset($r['params']['@post_traitements'])) {
956                                                $tr = $r['params']['@post_traitements'];
957                                               
958                                                // il n'existait aucune valeur avant ?
959                                                if (!isset($tresultat[$cle]) or !$tresultat[$cle]) {
960                                                        $tresultat[$cle] = $r['valeur'];
961                                                } else {
962                                                        // inter : equivalent de {', '} en spip
963                                                        // placer_avant : place le resultat avant ou apres l'ancien.
964                                                        $before = isset($tr['placer_avant']) and $tr['placer_avant'];
965                                                        $inter = isset($tr['inter']) ? $tr['inter'] : '';
966                                                       
967                                                        if ($inter) {
968                                                                if ($before) {
969                                                                        $tresultat[$cle] = $r['valeur'] . $inter . $tresultat[$cle] ;
970                                                                } else {
971                                                                        $tresultat[$cle] .= $inter . $r['valeur'];
972                                                                }
973                                                        }
974                                                }
975                                        } else {
976                                                $tresultat[$cle] = $r['valeur'];
977                                        }
978                                }
979                        } else {
980                                #echo "\n<pre>"; print_r($informations); echo "</pre>";
981                        }
982                }
983        }
984
985        // si pas d'auteur, on prend le responsable
986        if (!$tresultat['lesauteurs']) {
987                $tresultat['lesauteurs'] = $tresultat['auteur'];
988        }
989       
990        // tous les auteurs et tous les liens d'auteurs
991        // pour se simplifier un peu...
992        foreach (array('lesauteurs', 'liensauteurs') as $quoi) {
993                $tous = array();
994                foreach (
995                        array(
996                                $quoi.'_personne'    , $quoi.'_personne2'    , $quoi.'_personne3', 
997                                $quoi.'_collectivite', $quoi.'_collectivite2', $quoi.'_collectivite3', 
998                ) as $a) {
999                        if (isset($tresultat[$a]) and $tresultat[$a]) {
1000                                $tous[] = $tresultat[$a];
1001                        }
1002                }
1003                $tresultat['tous'.$quoi] = implode(', ', $tous);
1004        }
1005
1006
1007        // si pas de logo, mais isbn, on tente une demande a amazon
1008        if (!isset($tresultat['source_logo']) OR !$tresultat['source_logo']) {
1009                if (isset($tresultat['isbn']) and $tresultat['isbn']) {
1010                        // je me demande si un copie local de l'url d'amazon irait pas plus vite directement...
1011                        $tresultat['source_logo'] =
1012                                rtrim(lire_config("spip_pmb/url","http://tence.bibli.fr/opac"),'/')
1013                                 . "/getimage.php?url_image=http%3A%2F%2Fimages-eu.amazon.com%2Fimages%2FP%2F!!isbn!!.08.MZZZZZZZ.jpg&noticecode="
1014                                 . str_replace("-","",$tresultat['isbn']);
1015                }
1016        }
1017
1018        $tresultat['id'] = $tresultat['id_notice'] = $id_notice;
1019
1020        // on stocke en cache
1021        $resultats[$hash] = $tresultat;
1022        return $tresultat;
1023}
1024
1025
1026
1027/**
1028 * Sauve ou restaure un cache d'information
1029 * sur la base [$type_cache][$id] = valeur
1030 *
1031 * @param string $type
1032 *              Le type de cache (notices, auteurs, ...)
1033 * @param int|array $id
1034 *              L'identifiant desire ou une liste d'identifiants desires
1035 * @param mixed $valeur
1036 *              La valeur a stocker si stockage demande
1037 * @param bool $set
1038 *              Est-ce un stockage demande ?
1039 * @return mixed
1040 *              Si stockage : true
1041 *              Sinon,
1042 *              si $id simple, sa $valeur enregistree
1043 *              si $id tableau, retourne array($res, $wanted),
1044 *              2 tableaux contenants les resultats trouves et ceux non trouves
1045 *              en conservant les cles du tableau $id en entree.
1046**/
1047function pmb_cacher($type, $id, $valeur=null, $set=false) {
1048        static $cache = array();
1049        if (!isset($cache[$type])) {
1050                // Par ailleurs, l'id 0, s'il se produit est incongru est
1051                // provient du hack pour la pagination de ce plugin.
1052                $cache[$type] = array(0 => array());
1053        }
1054       
1055        // mise en cache
1056        if ($set) {
1057                $cache[$type][$id] = $valeur;
1058                return true;
1059        }
1060       
1061        // lecture du cache
1062        // 1 seul element demande
1063        if (!is_array($id)) {
1064                return $cache[$type][$id];
1065        }
1066       
1067        // n elements demandes...
1068        // id est un tableau d'id
1069        // on retourne un tableau $res et $wanted
1070        // contenant ce qu'on a et ce qu'on n'a pas.
1071        $wanted = $id;
1072        // ce qu'on a trouve...
1073        $res = array();
1074       
1075        foreach ($id as $c=>$l) {
1076                if (isset($cache[$type][$l])) {
1077                        $res[$c] = $cache[$type][$l];
1078                        unset($wanted[$c]);
1079                }
1080        }
1081        return array($res, $wanted);
1082}
1083
1084
1085
1086
1087/**
1088 * Charge le web service
1089 * qui permet de requeter sur notre PMB
1090 *
1091 * @return object WebService pour PMB
1092**/
1093function pmb_webservice() {
1094        static $ws = null;
1095        if ($ws) {
1096                return $ws;
1097        }
1098
1099        try {
1100                $rpc_type = lire_config("spip_pmb/rpc_type","soap");
1101                if ($rpc_type == "soap") {
1102                        ini_set("soap.wsdl_cache_enabled", "0");
1103                        $ws = new SoapClient(lire_config("spip_pmb/wsdl", "http://tence.bibli.fr/pmbws/PMBWsSOAP_1?wsdl"), array("features" => SOAP_SINGLE_ELEMENT_ARRAYS, 'encoding' => 'iso8859-1'));
1104                }
1105                else {
1106                        include_spip('inc/jsonRPCClient');
1107                        $ws = new jsonRPCClient(lire_config("spip_pmb/jsonrpc", ""), false);
1108                }
1109        }
1110        catch (Exception $e) {
1111                echo 'Exception reçue (15) : ',  $e->getMessage(), "\n";
1112        } 
1113
1114        return $ws;
1115}
1116
1117
1118/**
1119 * Retourne un tableau contenant la liste des tris possibles
1120 * (non utilisee)
1121**/
1122function pmb_ws_liste_tri_recherche() {
1123        //
1124        /* Exemple de retour:
1125          Array
1126          (
1127          [0] => Array
1128          (
1129          [sort_name] => text_1
1130          [sort_caption] => Titre
1131          )
1132         
1133          [1] => Array
1134          (
1135          [sort_name] => num_2
1136          [sort_caption] => Indexation décimale
1137          )
1138        ...
1139      )*/
1140        $tresultat = Array();
1141       
1142        try {
1143                $ws = pmb_webservice();
1144                $tresultat=$ws->pmbesSearch_get_sort_types();
1145        } catch (Exception $e) {
1146                echo 'Exception reçue (16) : ',  $e->getMessage(), "\n";
1147        }
1148        return $tresultat;
1149}
1150
1151
1152
1153/**
1154 *  tester si la session pmb est toujours active
1155**/
1156function pmb_tester_session($pmb_session, $id_auteur) {
1157        try {
1158                $ws = pmb_webservice();
1159                if ($ws->pmbesOPACEmpr_get_account_info($pmb_session)) {
1160                        return 1;
1161                } else {
1162                        $m = sql_updateq('spip_auteurs_pmb', array('pmb_session' => ''), "id_auteur=".$id_auteur);
1163                        return 0;
1164                }
1165        } catch (Exception $e) {
1166                $m = sql_updateq('spip_auteurs_pmb', array('pmb_session' => ''), "id_auteur=".$id_auteur);
1167                return 0;
1168        }
1169}
1170
1171
1172/**
1173 * Reserve pour un auteur identifie a pmb une notice
1174 *
1175**/
1176function pmb_reserver_ouvrage($session_id, $notice_id, $bulletin_id, $location) {
1177
1178        $result= Array();
1179
1180        $ws = pmb_webservice();
1181        $result = $ws->pmbesOPACEmpr_add_resa($session_id, $notice_id, $bulletin_id, $location);
1182        if (!$result->status) {
1183                if ($result->error == "no_session_id") return "La réservation n'a pas pu être réalisée pour la raison suivante : pas de session";
1184                else if ($result->error == "no_empr_id") return "La réservation n'a pas pu être réalisée pour la raison suivante : pas d'id emprunteur";
1185                else if ($result->error == "check_empr_exists") return "La réservation n'a pas pu être réalisée pour la raison suivante : id emprunteur inconnu";
1186                else if ($result->error == "check_notice_exists") return "La réservation n'a pas pu être réalisée pour la raison suivante : Notice inconnue";
1187                else if ($result->error == "check_quota") return "La réservation n'a pas pu être réalisée pour la raison suivante : violation de quotas: Voir message complémentaire";
1188                else if ($result->error == "check_resa_exists") return "La réservation n'a pas pu être réalisée pour la raison suivante : Document déjà réservé par ce lecteur";
1189                else if ($result->error == "check_allready_loaned") return "La réservation n'a pas pu être réalisée pour la raison suivante : Document déjà emprunté par ce lecteur";
1190                else if ($result->error == "check_statut") return "La réservation n'a pas pu être réalisée pour la raison suivante : Pas de document prêtable";
1191                else if ($result->error == "check_doc_dispo") return "La réservation n'a pas pu être réalisée pour la raison suivante : Document disponible, mais non réservable";
1192                else if ($result->error == "check_localisation_expl") return "La réservation n'a pas pu être réalisée pour la raison suivante : Document non réservable dans les localisations autorisées";
1193                else if ($result->error == "resa_no_create") return "La réservation n'a pas pu être réalisée pour la raison suivante : échec de l'enregistrement de la résevation";
1194                else return "La réservation n'a pas pu être réalisée pour la raison suivante : ".$result->error;
1195        } else {
1196                return "Votre réservation a été enregistrée";
1197        }
1198/* Description des entrées:
1199
1200        session_id type string        Le numéro de session
1201        notice_id type integer        l'id de la notice
1202        bulletin_id type integer        l'id du bulletin
1203        location type integer        la localisation de retrait ni applicable
1204        Description des retours:
1205
1206        success type boolean        Un boolean indiquant le succès éventuel de l'opération
1207        error type string        Code d'erreur si la réservation n'est pas effectuée:
1208        no_session_id (pas de session)
1209        no_empr_id (pas d'id emprunteur)
1210        check_empr_exists (id emprunteur inconnu)
1211        check_notice_exists (Notice inconnue)
1212        check_quota (violation de quotas: Voir message complémentaire)
1213        check_resa_exists (Document déjà réservé par ce lecteur)
1214        check_allready_loaned (Document déjà emprunté par ce lecteur)
1215        check_statut (Pas de document prêtable)
1216        check_doc_dispo (Document disponible, mais non réservable)
1217        check_localisation_expl (Document non réservable dans les localisations autorisées)
1218        resa_no_create (échec de l'enregistrement de la résevation)
1219        message type string        Message d'information complémentaire
1220*/
1221}
1222
1223
1224/**
1225 * Nettoyer des caracteres etranges
1226 * qui proviennent des requetes de PMB...
1227 *
1228 * @param string $valeur
1229 *              Chaine a nettoyer
1230 * @return string
1231 *              Chaine nettoyee
1232**/
1233function pmb_nettoyer_caracteres($valeur) {
1234        $valeur = stripslashes($valeur);
1235        $valeur = str_replace(
1236                array("’", "œ", "“", "”",  "€"),
1237                array("'", "&oelig;", "\"", "\"", "&euro;"), $valeur);
1238        return $valeur;
1239}
1240?>
Note: See TracBrowser for help on using the repository browser.