source: pmb4.1/trunk/fuentes/pmb/classes/external_services_converters.class.php @ 478

Last change on this file since 478 was 478, checked in by mabarracus, 4 years ago

copy trusty code 4.1

  • Property svn:executable set to *
File size: 37.0 KB
Line 
1<?php
2// +-------------------------------------------------+
3// | 2002-2007 PMB Services / www.sigb.net pmb@sigb.net et contributeurs (voir www.sigb.net)
4// +-------------------------------------------------+
5// $Id: external_services_converters.class.php,v 1.20.2.2 2014-12-01 17:24:40 mbertin Exp $
6
7//
8//Convertisseurs et cacheur de formats des résultats des services externes
9//
10
11require_once("$base_path/admin/convert/export.class.php");
12require_once("$base_path/admin/convert/convert.class.php");
13require_once("$class_path/external_services_caches.class.php");
14require_once("$class_path/mono_display.class.php");
15
16if (version_compare(PHP_VERSION,'5','>=') && extension_loaded('xsl')) {
17        if (substr(phpversion(), 0, 1) == "5") @ini_set("zend.ze1_compatibility_mode", "0");
18        require_once($include_path.'/xslt-php4-to-php5.inc.php');
19}
20
21class external_services_converter {
22        var $object_type=0; //Type d'objet
23        var $life_duration=600; //Durée de vie de l'objet converti, en secondes
24        var $results=array();
25        var $cache=NULL;
26        var $params=array();
27       
28        function external_services_converter($object_type, $life_duration) {
29                $this->object_type = $object_type+0;
30                $this->life_duration = $life_duration+0;
31                $this->cache = new external_services_cache('es_cache_blob', $life_duration);
32        }
33       
34        function set_params($new_params) {
35                $this->params = $new_params;
36        }
37       
38        function convert_batch($objects, $format, $target_charset='iso-8859-1') {
39                //Cette fonction va chercher les valeurs dans le cache si elle existent.
40               
41                global $dbh;
42                //Si aucun résultat, pas de traitement
43                if (!is_array($objects)) {
44                        $this->results = array();
45                        return;
46                }
47                array_walk($objects, create_function('&$a', '$a+=0;'));//Soyons sûr de ne stocker que des entiers dans le tableau.
48                $objects = array_unique($objects);
49               
50                if (!$objects) {
51                        $this->results = array();
52                        return;
53                }
54
55                //Initialisons tous avec des zéros
56                $this->results = array_combine($objects, array_fill(0, count($objects), 0));
57               
58                //Allons chercher dans le cache ce qui est encore bon
59                $in_cache = $this->cache->get_objectref_contents($this->object_type, '', $format, $objects);
60                $rawed = substr($format, 0, 9) == "raw_array";
61                foreach ($in_cache as $object_ref => $object_content) {
62                        if ($rawed) {
63                                $this->results[$object_ref] = unserialize($object_content);
64                        } else {
65                                $this->results[$object_ref] = $object_content;
66                        }
67                }
68               
69        }
70       
71        function encache_value($object_id, $value, $format) {
72                //Mise en cache d'une valeur
73                global $dbh;
74                $rawed = substr($format, 0, 9) == "raw_array";
75                if ($rawed)
76                        $value = serialize($value);
77                $this->cache->encache_objectref_contents($this->object_type, '', $format, array($object_id => $value));
78        }
79       
80}
81
82class external_services_converter_notices extends external_services_converter {
83       
84        function convert_batch($objects, $format, $target_charset='iso-8859-1',$xslt="") {
85                if (!$objects)
86                        return array();
87                //Va chercher dans le cache les notices encore bonnes
88                $format_ref = $format.'_C_'.$target_charset;
89                if ($this->params["include_links"])
90                        $format_ref .= "_withlinks";
91                if ($this->params["include_items"])
92                        $format_ref .= "_withitems";
93                parent::convert_batch($objects, $format_ref, $target_charset);
94                //Converti les notices qui
95                $this->convert_uncachednotices($format, $format_ref, $target_charset,$xslt);
96                return $this->results;
97        }
98
99        function convert_batch_to_pmb_xml($notices_to_convert, $target_charset='iso-8859-1') {
100                global $charset;
101                if (!$notices_to_convert) //Rien à faire? On fait rien
102                        return;
103
104                $xmlexport = new export($notices_to_convert);
105                $current_notice_id = $xmlexport->notice_list[$xmlexport->current_notice];
106                $parametres = array();
107
108                if (is_array($this->params['include_links'])) {
109                        $parametres=$this->params['include_links'];
110                } else if ($this->params["include_links"]) {
111                        $parametres["genere_lien"]=1;//Notices liées, relations entre notices
112       
113                        $parametres["mere"]=1; //Exporter les liens vers les notices mères
114                        $parametres["notice_mere"]=0;//Exporter aussi les notices mères liées
115                       
116                        $parametres["fille"]=1; //Exporter les liens vers les notices filles
117                        $parametres["notice_fille"]=0;//Exporter aussi les notices filles liées
118                       
119                        $parametres["art_link"]=1;//Exporter les liens vers les articles pour les notices de pério
120                        $parametres["notice_art"]=0;//Exporter aussi les articles pour les notices de pério
121                        $parametres["bulletinage"]=0;//Exporter le bulletinage pour les notices de pério
122               
123                        $parametres["bull_link"]=1;//Exporter les liens vers les bulletins pour les notices d'article
124                        $parametres["perio_link"]=1; //Exporter les liens vers les périodiques pour les notices d'articles
125                        $parametres["notice_perio"]=0;//Exporter aussi les périodiques pour les notices d'articles
126                }
127                if ($this->params["include_authorite_ids"]) {
128                        $parametres["include_authorite_ids"] = true;
129                }
130                $parametres["docnum"]=1;
131                $keep_expl = isset($this->params["include_items"]) && $this->params["include_items"];
132                while($xmlexport->get_next_notice("", array(), array(), $keep_expl, $parametres)) {
133                        $xmlexport->toxml();
134                        if ($current_notice_id != -1) {
135                                $this->results[$current_notice_id] = $xmlexport->notice;
136                                //La classe export exporte ses données dans la charset de la base.
137                                //Convertissons si besoin
138                                if ($charset!='utf-8' && $target_charset == 'utf-8')
139                                        $this->results[$current_notice_id] = utf8_encode($this->results[$current_notice_id]);
140                                else if ($charset=='utf-8' && $target_charset != 'utf-8')
141                                        $this->results[$current_notice_id] = utf8_decode($this->results[$current_notice_id]);
142                                $current_notice_id = $xmlexport->notice_list[$xmlexport->current_notice];
143                        }
144                }
145        }
146
147        function convert_batch_to_json($notices_to_convert, $target_charset='iso-8859-1') {
148                        global $charset;
149                if (!$notices_to_convert) //Rien à faire? On fait rien
150                        return;
151
152                $xmlexport = new export($notices_to_convert);
153                $current_notice_id = $xmlexport->notice_list[$xmlexport->current_notice];
154                $parametres = array();
155                if (is_array($this->params['include_links'])) {
156                        $parametres=$this->params['include_links'];
157                } else if ($this->params["include_links"]) {
158                        $parametres["genere_lien"]=1;//Notices liées, relations entre notices
159       
160                        $parametres["mere"]=1; //Exporter les liens vers les notices mères
161                        $parametres["notice_mere"]=0;//Exporter aussi les notices mères liées
162                       
163                        $parametres["fille"]=1; //Exporter les liens vers les notices filles
164                        $parametres["notice_fille"]=0;//Exporter aussi les notices filles liées
165                       
166                        $parametres["art_link"]=1;//Exporter les liens vers les articles pour les notices de pério
167                        $parametres["notice_art"]=0;//Exporter aussi les articles pour les notices de pério
168                        $parametres["bulletinage"]=0;//Exporter le bulletinage pour les notices de pério
169               
170                        $parametres["bull_link"]=1;//Exporter les liens vers les bulletins pour les notices d'article
171                        $parametres["perio_link"]=1; //Exporter les liens vers les périodiques pour les notices d'articles
172                        $parametres["notice_perio"]=0;//Exporter aussi les périodiques pour les notices d'articles
173                }
174                if ($this->params["include_authorite_ids"]) {
175                        $parametres["include_authorite_ids"] = true;
176                }
177                $parametres["docnum"]=1;
178                $keep_expl = isset($this->params["include_items"]) && $this->params["include_items"];
179                while($xmlexport->get_next_notice("", array(), array(), $keep_expl, $parametres)) {
180                        $xmlexport->tojson();
181                        if ($current_notice_id != -1) {
182                                $this->results[$current_notice_id] = $xmlexport->notice;
183                                //La classe export exporte ses données dans la charset de la base.
184                                //Convertissons si besoin
185                                if ($charset!='utf-8' && $target_charset == 'utf-8')
186                                        $this->results[$current_notice_id] = utf8_encode($this->results[$current_notice_id]);
187                                else if ($charset=='utf-8' && $target_charset != 'utf-8')
188                                        $this->results[$current_notice_id] = utf8_decode($this->results[$current_notice_id]);
189                                $current_notice_id = $xmlexport->notice_list[$xmlexport->current_notice];
190                        }
191                }
192        }
193
194        function convert_batch_to_json_assoc($notices_to_convert, $target_charset='iso-8859-1') {
195                $this->convert_batch_to_php_array_assoc($notices_to_convert, $target_charset);
196                foreach ($notices_to_convert as $anotice_id)
197                        $this->results[$anotice_id] = json_encode($this->results[$anotice_id]);
198        }
199       
200        function convert_batch_to_serialized($notices_to_convert, $target_charset='iso-8859-1') {
201                global $charset;
202                if (!$notices_to_convert) //Rien à faire? On fait rien
203                        return;
204
205                $xmlexport = new export($notices_to_convert);
206                $current_notice_id = $xmlexport->notice_list[$xmlexport->current_notice];
207                $parametres = array();
208                if (is_array($this->params['include_links'])) {
209                        $parametres=$this->params['include_links'];
210                } else if ($this->params["include_links"]) {
211                        $parametres["genere_lien"]=1;//Notices liées, relations entre notices
212       
213                        $parametres["mere"]=1; //Exporter les liens vers les notices mères
214                        $parametres["notice_mere"]=0;//Exporter aussi les notices mères liées
215                       
216                        $parametres["fille"]=1; //Exporter les liens vers les notices filles
217                        $parametres["notice_fille"]=0;//Exporter aussi les notices filles liées
218                       
219                        $parametres["art_link"]=1;//Exporter les liens vers les articles pour les notices de pério
220                        $parametres["notice_art"]=0;//Exporter aussi les articles pour les notices de pério
221                        $parametres["bulletinage"]=0;//Exporter le bulletinage pour les notices de pério
222               
223                        $parametres["bull_link"]=1;//Exporter les liens vers les bulletins pour les notices d'article
224                        $parametres["perio_link"]=1; //Exporter les liens vers les périodiques pour les notices d'articles
225                        $parametres["notice_perio"]=0;//Exporter aussi les périodiques pour les notices d'articles
226                }
227                if ($this->params["include_authorite_ids"]) {
228                        $parametres["include_authorite_ids"] = true;
229                }
230                $parametres["docnum"]=1;
231                $keep_expl = isset($this->params["include_items"]) && $this->params["include_items"];
232                while($xmlexport->get_next_notice("", array(), array(), $keep_expl, $parametres)) {
233                        $xmlexport->toserialized();
234                        if ($current_notice_id != -1) {
235                                $this->results[$current_notice_id] = $xmlexport->notice;
236                                //La classe export exporte ses données dans la charset de la base.
237                                //Convertissons si besoin
238                                if ($charset!='utf-8' && $target_charset == 'utf-8')
239                                        $this->results[$current_notice_id] = utf8_encode($this->results[$current_notice_id]);
240                                else if ($charset=='utf-8' && $target_charset != 'utf-8')
241                                        $this->results[$current_notice_id] = utf8_decode($this->results[$current_notice_id]);
242                                $current_notice_id = $xmlexport->notice_list[$xmlexport->current_notice];
243                        }
244                }
245        }
246       
247        function convert_batch_to_serialized_assoc($notices_to_convert, $target_charset='iso-8859-1') {
248                $this->convert_batch_to_php_array_assoc($notices_to_convert, $target_charset);
249                foreach ($notices_to_convert as $anotice_id) {
250                        $this->results[$anotice_id] = serialize($this->results[$anotice_id]);
251                }
252        }       
253       
254        function convert_batch_to_php_array($notices_to_convert, $target_charset='iso-8859-1') {
255                global $charset;
256                if (!$notices_to_convert) //Rien à faire? On fait rien
257                        return;
258
259                $xmlexport = new export($notices_to_convert);
260                $current_notice_id = $xmlexport->notice_list[$xmlexport->current_notice];
261                $parametres = array();
262                if (is_array($this->params['include_links'])) {
263                        $parametres=$this->params['include_links'];
264                } else if ($this->params["include_links"]) {
265                        $parametres["genere_lien"]=1;//Notices liées, relations entre notices
266       
267                        $parametres["mere"]=1; //Exporter les liens vers les notices mères
268                        $parametres["notice_mere"]=0;//Exporter aussi les notices mères liées
269                       
270                        $parametres["fille"]=1; //Exporter les liens vers les notices filles
271                        $parametres["notice_fille"]=0;//Exporter aussi les notices filles liées
272                       
273                        $parametres["art_link"]=1;//Exporter les liens vers les articles pour les notices de pério
274                        $parametres["notice_art"]=0;//Exporter aussi les articles pour les notices de pério
275                        $parametres["bulletinage"]=0;//Exporter le bulletinage pour les notices de pério
276               
277                        $parametres["bull_link"]=1;//Exporter les liens vers les bulletins pour les notices d'article
278                        $parametres["perio_link"]=1; //Exporter les liens vers les périodiques pour les notices d'articles
279                        $parametres["notice_perio"]=0;//Exporter aussi les périodiques pour les notices d'articles
280                }
281                if ($this->params["include_authorite_ids"]) {
282                        $parametres["include_authorite_ids"] = true;
283                }
284                $parametres["docnum"]=1;
285                $keep_expl = isset($this->params["include_items"]) && $this->params["include_items"];
286                while($xmlexport->get_next_notice("", array(), array(), $keep_expl, $parametres)) {
287                        $xmlexport->to_raw_array();
288                        if ($current_notice_id != -1) {
289                                $xmlexport_notice = $xmlexport->notice;
290                                $aresult = $xmlexport_notice;
291                                $aresult = array();
292                                $headers = array();
293                                if (isset($xmlexport_notice['rs']["value"]))
294                                        $headers[] = array("name" => "rs", "value" => $xmlexport_notice['rs']["value"]);
295                                if (isset($xmlexport_notice['dt']["value"]))
296                                        $headers[] = array("name" => "dt", "value" => $xmlexport_notice['dt']["value"]);
297                                if (isset($xmlexport_notice['bl']["value"]))
298                                        $headers[] = array("name" => "bl", "value" => $xmlexport_notice['bl']["value"]);
299                                if (isset($xmlexport_notice['hl']["value"]))
300                                        $headers[] = array("name" => "hl", "value" => $xmlexport_notice['hl']["value"]);
301                                if (isset($xmlexport_notice['el']["value"]))
302                                        $headers[] = array("name" => "el", "value" => $xmlexport_notice['el']["value"]);
303                                if (isset($xmlexport_notice['ru']["value"]))
304                                        $headers[] = array("name" => "ru", "value" => $xmlexport_notice['ru']["value"]);
305                                $aresult["id"] = $current_notice_id;
306                                $aresult["header"] = $headers;
307                                $aresult["f"] = $xmlexport_notice['f'];
308                                foreach ($aresult["f"] as &$af) {
309                                        $af["ind"] = isset($af["ind"]) ? $af["ind"] : "";
310                                        $af["id"] = isset($af["id"]) ? $af["id"] : "";
311                                        $af["s"] = isset($af["s"]) ? $af["s"] : array();
312                                        foreach ($af["s"] as &$as) {
313                                                $as["value"] = isset($as["value"]) ? $as["value"] : "";
314                                                $as["c"] = isset($as["c"]) ? $as["c"] : "";
315                                                //La classe export exporte ses données dans la charset de la base.
316                                                //Convertissons si besoin
317                                                if ($charset!='utf-8' && $target_charset == 'utf-8')
318                                                        $as["value"] = utf8_encode($as["value"]);
319                                                else if ($charset=='utf-8' && $target_charset != 'utf-8')
320                                                        $as["value"] = utf8_decode($as["value"]);
321                                        }
322
323                                }
324                                $this->results[$current_notice_id] = $aresult;
325                                $current_notice_id = $xmlexport->notice_list[$xmlexport->current_notice];
326                        }
327                }
328        }
329       
330        function convert_batch_to_php_array_assoc($notices_to_convert, $target_charset='iso-8859-1') {
331                global $charset;
332                if (!$notices_to_convert) //Rien à faire? On fait rien
333                        return;
334
335                $xmlexport = new export($notices_to_convert);
336                $current_notice_id = $xmlexport->notice_list[$xmlexport->current_notice];
337                $parametres = array();
338                if (is_array($this->params['include_links'])) {
339                        $parametres=$this->params['include_links'];
340                } else if ($this->params["include_links"]) {
341                        $parametres["genere_lien"]=1;//Notices liées, relations entre notices
342       
343                        $parametres["mere"]=1; //Exporter les liens vers les notices mères
344                        $parametres["notice_mere"]=0;//Exporter aussi les notices mères liées
345                       
346                        $parametres["fille"]=1; //Exporter les liens vers les notices filles
347                        $parametres["notice_fille"]=0;//Exporter aussi les notices filles liées
348                       
349                        $parametres["art_link"]=1;//Exporter les liens vers les articles pour les notices de pério
350                        $parametres["notice_art"]=0;//Exporter aussi les articles pour les notices de pério
351                        $parametres["bulletinage"]=0;//Exporter le bulletinage pour les notices de pério
352               
353                        $parametres["bull_link"]=1;//Exporter les liens vers les bulletins pour les notices d'article
354                        $parametres["perio_link"]=1; //Exporter les liens vers les périodiques pour les notices d'articles
355                        $parametres["notice_perio"]=0;//Exporter aussi les périodiques pour les notices d'articles
356                }
357                if ($this->params["include_authorite_ids"]) {
358                        $parametres["include_authorite_ids"] = true;
359                }
360                $parametres["docnum"]=1;
361                $keep_expl = isset($this->params["include_items"]) && $this->params["include_items"];
362                while($xmlexport->get_next_notice("", array(), array(), $keep_expl, $parametres)) {
363                        $xmlexport->to_raw_array();
364                        if ($current_notice_id != -1) {
365                                $xmlexport_notice = $xmlexport->notice;
366                                $aresult = array();
367                                $headers = array();
368                                if (isset($xmlexport_notice['rs']["value"]))
369                                        $headers["rs"] = $xmlexport_notice['rs']["value"];
370                                if (isset($xmlexport_notice['dt']["value"]))
371                                        $headers["dt"] = $xmlexport_notice['dt']["value"];
372                                if (isset($xmlexport_notice['bl']["value"]))
373                                        $headers["bl"] = $xmlexport_notice['bl']["value"];
374                                if (isset($xmlexport_notice['hl']["value"]))
375                                        $headers["hl"] = $xmlexport_notice['hl']["value"];
376                                if (isset($xmlexport_notice['el']["value"]))
377                                        $headers["el"] = $xmlexport_notice['el']["value"];
378                                if (isset($xmlexport_notice['ru']["value"]))
379                                        $headers["ru"] = $xmlexport_notice['ru']["value"];
380                                $aresult["id"] = $current_notice_id;
381                                $aresult["header"] = $headers;
382                                $aresult["f"] = array();
383                                foreach ($xmlexport_notice['f'] as &$af) {
384                                        if (!isset($af["c"]))
385                                                continue;
386                                        if (!isset($aresult["f"][$af["c"]]))
387                                                $aresult["f"][$af["c"]] = array();
388                                        $arf = array();
389                                        $arf["ind"] = isset($af["ind"]) ? $af["ind"] : "";
390                                        $arf["id"] = isset($af["id"]) ? $af["id"] : "";
391                                        if (isset($af["s"])) {
392                                                foreach ($af["s"] as &$as) {
393                                                        //La classe export exporte ses données dans la charset de la base.
394                                                        //Convertissons si besoin
395                                                        $value = $as["value"];
396                                                        if ($charset!='utf-8' && $target_charset == 'utf-8')
397                                                                $value = utf8_encode($value);
398                                                        else if ($charset=='utf-8' && $target_charset != 'utf-8')
399                                                                $value = utf8_decode($value);
400                                                        if (isset($arf[$as["c"]]) && !is_array($arf[$as["c"]]))
401                                                                $arf[$as["c"]] = array($arf[$as["c"]]);
402                                                        if (isset($arf[$as["c"]]) && is_array($arf[$as["c"]]))
403                                                                $arf[$as["c"]][] = $value;
404                                                        else
405                                                                $arf[$as["c"]] = $value;
406                                                }
407                                        }
408                                        else if (isset($af["value"])) {
409                                                $arf["value"] = $af["value"];
410                                        }
411
412                                        $aresult["f"][$af["c"]][] = $arf;
413                                }
414                                $this->results[$current_notice_id] = $aresult;
415                                $current_notice_id = $xmlexport->notice_list[$xmlexport->current_notice];
416                        }
417                }
418        }
419       
420       
421        function apply_xsl_to_xml($xml, $xsl, $params) {
422                global $charset;
423                $xh = xslt_create();
424                xslt_set_encoding($xh, $charset);
425                $arguments = array(
426                  '/_xml' => $xml,
427                  '/_xsl' => $xsl
428                );
429                $result = xslt_process($xh, 'arg:/_xml', 'arg:/_xsl', NULL, $arguments, $params);
430                xslt_free($xh);
431                return $result;         
432        }
433
434        function convert_batch_to_dublin_core($notices_to_convert, $target_charset,$xsl_pmbxmlunimarc_to_dc = "") {
435                global $base_path, $opac_url_base;
436                if (!$notices_to_convert) //Rien à faire? On fait rien
437                        return;
438
439                //Un petit tour en xml en utf-8 et après on convertit par xsl
440                $this->convert_batch_to_pmb_xml($notices_to_convert,'utf-8');
441               
442                //Allons chercher la feuille de style
443                if(!$xsl_pmbxmlunimarc_to_dc){
444                        $xsl_pmbxmlunimarc_to_dc = file_get_contents($base_path."/admin/convert/imports/pmbxml2dc/pmbxmlunimarc2dc.xsl");
445                }
446       
447                foreach ($notices_to_convert as $anotice_id) {
448                        if (!$this->results[$anotice_id])
449                                continue;
450                        $pmbxmlunimarc_version = '<?xml version="1.0" encoding="'.$target_charset.'"?><unimarc>'.$this->results[$anotice_id]."</unimarc>";
451                        $converted_version = $this->apply_xsl_to_xml($pmbxmlunimarc_version, $xsl_pmbxmlunimarc_to_dc, array("notice_url_base" => $opac_url_base));
452                        $converted_version = preg_replace('/^<\?xml[^>]*\?>/', "", $converted_version);
453
454                       
455                        //Cette conversion sort de l'utf-8
456                        if ($target_charset != 'utf-8')
457                                $converted_version = utf8_decode($converted_version);
458
459                        $this->results[$anotice_id] = $converted_version;
460                }
461        }
462       
463        //Utilise les fonctions de admin/convert pour faire une conversion perso
464        function convert_batch_to_adminconvert_script($notices_to_convert, $the_conversion, $target_charset) {
465                global $base_path, $charset, $opac_url_base;
466                if (!$notices_to_convert) //Rien à faire? On fait rien
467                        return;
468
469                //Un petit tour en xml dans le charset de la base et après on invoque la classe de conversion
470                $this->convert_batch_to_pmb_xml($notices_to_convert, $charset);
471
472                $conv = new convert("", $the_conversion["position"], true);
473
474                foreach ($notices_to_convert as $anotice_id) {
475                        if (!$this->results[$anotice_id])
476                                continue;
477                        $conv->prepared_notice = $xml_header.$this->results[$anotice_id];
478                        $converted_version = $conv->transform(true);
479                       
480                        if ($the_conversion["output_charset"] == 'utf-8' && $target_charset != 'utf-8')
481                                $converted_version = utf8_decode($converted_version);
482                        if ($the_conversion["output_charset"] != 'utf-8' && $target_charset == 'utf-8')
483                                $converted_version = utf8_encode($converted_version);
484                        $this->results[$anotice_id] = $converted_version;
485                }
486        }
487
488        function convert_batch_to_header($notices_to_convert, $target_charset) {
489                global $charset,$include_path,$base_path,$msg;
490                if (!$notices_to_convert) //Rien à faire? On fait rien
491                        return;
492
493                foreach ($notices_to_convert as $anotice_id) {
494                        $monod = new mono_display($anotice_id, 0, '', 0, '', '', '', 0, 1, 0, 0, '', 0, true, false, 0);
495                        $this->results[$anotice_id] = $monod->header;
496                       
497                        if ($charset!='utf-8' && $target_charset == 'utf-8')
498                                $this->results[$anotice_id] = utf8_encode($this->results[$anotice_id]);
499                        else if ($charset=='utf-8' && $target_charset != 'utf-8')
500                                $this->results[$anotice_id] = utf8_decode($this->results[$anotice_id]);
501                }
502        }
503       
504        function convert_batch_to_isbd($notices_to_convert, $target_charset) {
505                global $charset,$include_path,$base_path,$msg;
506                if (!$notices_to_convert) //Rien à faire? On fait rien
507                        return;
508
509                foreach ($notices_to_convert as $anotice_id) {
510                        $monod = new mono_display($anotice_id, 1, '', 0, '', '', '', 0, 1, 0, 0, '', 0, true, false, 0);
511                        $this->results[$anotice_id] = $monod->isbd;
512                       
513                        if ($charset!='utf-8' && $target_charset == 'utf-8')
514                                $this->results[$anotice_id] = utf8_encode($this->results[$anotice_id]);
515                        else if ($charset=='utf-8' && $target_charset != 'utf-8')
516                                $this->results[$anotice_id] = utf8_decode($this->results[$anotice_id]);
517                }
518        }
519       
520        function convert_batch_to_isbd_suite($notices_to_convert, $target_charset) {
521                global $charset,$include_path,$base_path,$msg;
522                if (!$notices_to_convert) //Rien à faire? On fait rien
523                        return;
524
525                foreach ($notices_to_convert as $anotice_id) {
526                        $monod = new mono_display($anotice_id, 6, '', 0, '', '', '', 0, 1, 0, 0, '', 0, true, false, 0);
527                        $this->results[$anotice_id] = $monod->isbd;
528                       
529                        if ($charset!='utf-8' && $target_charset == 'utf-8')
530                                $this->results[$anotice_id] = utf8_encode($this->results[$anotice_id]);
531                        else if ($charset=='utf-8' && $target_charset != 'utf-8')
532                                $this->results[$anotice_id] = utf8_decode($this->results[$anotice_id]);
533                }
534        }
535       
536        function convert_batch_to_personnal_xslt($notices_to_convert, $target_charset,$xslt) {
537                global $base_path, $charset, $opac_url_base;
538                if (!$notices_to_convert || !$xslt) //Rien à faire? On fait rien
539                        return;
540                //Un petit tour en xml et après on converti par xsl
541                $this->convert_batch_to_pmb_xml($notices_to_convert);
542               
543                foreach ($notices_to_convert as $anotice_id) {
544                        if (!$this->results[$anotice_id])
545                                continue;
546                        $pmbxmlunimarc_version = '<?xml version="1.0" encoding="'.$charset.'"?><unimarc>'.$this->results[$anotice_id]."</unimarc>";
547                        $converted_version = $this->apply_xsl_to_xml($pmbxmlunimarc_version, $xslt, array("notice_url_base" => $opac_url_base));
548                        $converted_version = preg_replace('/^<\?xml[^>]*\?>/', "", $converted_version);
549
550                        //Cette conversion sort de l'utf-8
551                        if ($target_charset != 'utf-8')
552                                $converted_version = utf8_decode($converted_version);
553
554                        $this->results[$anotice_id] = $converted_version;
555                }
556        }
557       
558        function convert_uncachednotices($format, $format_ref, $target_charset='iso-8859-1',$xslt="") {
559                $notices_to_convert=array();
560
561                foreach ($this->results as $notice_id => $aresult) {
562                        if (!$aresult && $notice_id) {
563                                $notices_to_convert[] = $notice_id;
564                        }
565                }       
566
567                if (substr($format, 0, 8) == "convert:") {
568                        //C'est une conversion par script admin/convert
569                        $convert_path = substr($format, 8);
570                       
571                        //Trouvons la position de la conversion pour invoquer la classe de conversion
572                        $the_conversion = NULL;
573                        $catalog = $this->get_export_possibilities(false);
574                        foreach ($catalog as $aconvert) {
575                                if ($aconvert["path"] == $convert_path) {
576                                        $the_conversion = $aconvert;
577                                }
578                        }
579                       
580                        if (!$the_conversion) {
581                                //Oups! pas trouvé
582                                //Renvoyons des strings vides.
583                                foreach($notices_to_convert as $anotice_id) {
584                                        $this->results[$anotice_id] = "";
585                                }
586                        }
587                        else {
588                                //C'est parti!
589                                $this->convert_batch_to_adminconvert_script($notices_to_convert, $the_conversion, $target_charset);
590                        }
591                       
592                }
593                else {
594                        //Conversion builtin
595                        switch ($format) {
596                                case "pmb_xml_unimarc":
597                                        $this->convert_batch_to_pmb_xml($notices_to_convert, $target_charset);
598                                        break;
599                                case "json_unimarc":
600                                        $this->convert_batch_to_json($notices_to_convert, $target_charset);
601                                        break;
602                                case "json_unimarc_assoc":
603                                        $this->convert_batch_to_json_assoc($notices_to_convert, $target_charset);
604                                        break;
605                                case "serialized_unimarc":
606                                        $this->convert_batch_to_serialized($notices_to_convert, $target_charset);
607                                        break;
608                                case "serialized_unimarc_assoc":
609                                        $this->convert_batch_to_serialized_assoc($notices_to_convert, $target_charset);
610                                        break;
611                                case "raw_array":
612                                        $this->convert_batch_to_php_array($notices_to_convert, $target_charset);
613                                        break;
614                                case "raw_array_assoc":
615                                        $this->convert_batch_to_php_array_assoc($notices_to_convert, $target_charset);
616                                        break;
617                                case "header":
618                                        $this->convert_batch_to_header($notices_to_convert, $target_charset);
619                                        break;
620                                case "isbd":
621                                        $this->convert_batch_to_isbd($notices_to_convert, $target_charset);
622                                        break;
623                                case "isbd_suite":
624                                        $this->convert_batch_to_isbd_suite($notices_to_convert, $target_charset);
625                                        break;
626                                case "xslt_transform":
627                                        $this->convert_batch_to_personnal_xslt($notices_to_convert, $target_charset,$xslt);
628                                        break;
629                                case "dc":
630                                case "oai_dc":
631                                        $this->convert_batch_to_dublin_core($notices_to_convert, $target_charset,$xslt);
632                                        break;
633                                default:
634                                        //Par défaut on renvoi juste le notice_id
635                                        foreach($notices_to_convert as $anotice_id) {
636                                                $this->results[$anotice_id] = $anotice_id;
637                                        }
638                                        break;
639                        }
640                }
641
642                //Cachons les notices converties maintenant.
643                foreach ($notices_to_convert as $anotice_id) {
644                        if ($this->results[$anotice_id])
645                                $this->encache_value($anotice_id, $this->results[$anotice_id], $format_ref);
646                }
647        }
648       
649        //Cette fonction parse les différents catalogues de admin/convert et liste les conversions qui exportent en xml
650        static function get_export_possibilities($only_xml=true) {
651                global $base_path;
652                $result = array();
653                if (file_exists($base_path."/admin/convert/imports/catalog_subst.xml")) {
654                        $catalog_xml = file_get_contents($base_path."/admin/convert/imports/catalog_subst.xml");
655                } else {
656                        $catalog_xml = file_get_contents($base_path."/admin/convert/imports/catalog.xml");
657                }
658                $catalog = _parser_text_no_function_($catalog_xml);
659                $count = 0;
660                //Parsons le catalogue
661                if (isset($catalog["CATALOG"][0]["ITEM"]))
662                        foreach ($catalog["CATALOG"][0]["ITEM"] as $aconverttype) {
663                                if ($aconverttype["EXPORT"] == "yes") {
664                                        $path = $aconverttype["PATH"];
665                                        if ($path) {
666                                                //Regardons si cette conversion sort du xml
667                                                $export_xml = file_get_contents($base_path."/admin/convert/imports/$path/params.xml");
668                                                $params = _parser_text_no_function_($export_xml);
669                                                if (isset($params["PARAMS"][0]["OUTPUT"][0]["TYPE"])) {
670                                                        $output_type = $params["PARAMS"][0]["OUTPUT"][0]["TYPE"];
671                                                        if (!$only_xml || (strtolower($output_type) == 'xml')) {
672                                                                //Oui? on l'ajoute au resultat
673                                                                $conv_charset = isset($params["PARAMS"][0]["OUTPUT"][0]["CHARSET"]) ? $params["PARAMS"][0]["OUTPUT"][0]["CHARSET"] : 'iso-8859-1';
674                                                                $result[] = array(
675                                                                        "position" => $count,
676                                                                        "caption" => $aconverttype["EXPORTNAME"],
677                                                                        "path" => $path,
678                                                                        "output_charset" => $conv_charset
679                                                                );
680                                                        }
681                                                }
682                                        }
683                                }
684                                $count++;
685                        }
686                return $result;
687        }
688}
689
690class external_services_converter_external_notices extends external_services_converter {
691       
692        function convert_batch($objects, $format, $target_charset='iso-8859-1') {
693                if (!$objects)
694                        return array();
695                //Va chercher dans le cache les notices encore bonnes
696                $format_ref = $format.'_C_'.$target_charset;
697                parent::convert_batch($objects, $format_ref, $target_charset);
698                //Converti les notices qui
699                $this->convert_uncachednotices($format, $format_ref, $target_charset);
700                return $this->results;
701        }
702
703        function get_notice_unimarc_array($notice_id) {
704                global $dbh;
705                $requete = "SELECT source_id FROM external_count WHERE rid=".addslashes($notice_id);
706                $myQuery = mysql_query($requete, $dbh);
707                if (!mysql_num_rows($myQuery))
708                        return FALSE;
709                $source_id = mysql_result($myQuery, 0, 0);
710                if (!$source_id)
711                        return FALSE;
712
713                $requete="select * from entrepot_source_".$source_id." where recid='".addslashes($notice_id)."' order by ufield,field_order,usubfield,subfield_order,value";
714                $myQuery = mysql_query($requete, $dbh);
715                $unimarc = array('f' => array());
716                if(mysql_num_rows($myQuery)) {
717                        $field_order = $subfield_order = 0;
718                        while ($l=mysql_fetch_object($myQuery)) {
719                                if (in_array($l->ufield, array('bl', 'rs', 'dt', 'el', 'hl', 'ru'))) {
720                                        $unimarc[$l->ufield]['value'] = $l->value;
721                                        continue;
722                                }
723                                $unimarc['f'][$l->field_order]['c'] = $l->ufield;
724                                $unimarc['f'][$l->field_order]['ind'] = '';
725                                $unimarc['f'][$l->field_order]['id'] = '';
726                                $unimarc['f'][$l->field_order]['s'][$l->subfield_order] = array('c' => $l->usubfield, 'value' => $l->value);
727                                if($l->field_order > $field_order)
728                                $field_order = $l->field_order;
729                                if($l->ufield == "801"){
730                                        if($l->subfield_order > $subfield_order)
731                                                $subfield_order= $l->subfield_order;
732                                }
733                        }
734                        //on ajoute le nom de source en 801$9
735                        $rqt = "select name from connectors_sources where source_id ='".$source_id."'";
736                        $res = mysql_query($rqt);
737                        if(mysql_num_rows($res)){
738                                $unimarc['f'][$field_order+1]['c'] = "801";
739                                $unimarc['f'][$field_order+1]['ind'] = '';
740                                $unimarc['f'][$field_order+1]['id'] = '';
741                                $unimarc['f'][$field_order+1]['s'][$subfield_order+1] = array('c' => "9", 'value' => mysql_result($res,0,0));                           
742                        }
743                }
744                $unimarc['f'] = array_values($unimarc['f']);
745                foreach($unimarc['f'] as &$afield) {
746                        $afield['s'] = array_values($afield['s']);
747                        unset($afield);
748                }
749               
750                return $unimarc;
751        }
752               
753        function convert_batch_to_php_array($notices_to_convert, $target_charset='iso-8859-1') {
754                global $charset;
755                if (!$notices_to_convert) //Rien à faire? On fait rien
756                        return;
757
758                foreach($notices_to_convert as $anotice_id)  {
759                        $xmlexport_notice = $this->get_notice_unimarc_array($anotice_id);
760                        if (!$xmlexport_notice)
761                                continue;
762                        $aresult = $xmlexport_notice;
763                        $aresult = array();
764                        $headers = array();
765                        if (isset($xmlexport_notice['rs']["value"]))
766                                $headers[] = array("name" => "rs", "value" => $xmlexport_notice['rs']["value"]);
767                        if (isset($xmlexport_notice['dt']["value"]))
768                                $headers[] = array("name" => "dt", "value" => $xmlexport_notice['dt']["value"]);
769                        if (isset($xmlexport_notice['bl']["value"]))
770                                $headers[] = array("name" => "bl", "value" => $xmlexport_notice['bl']["value"]);
771                        if (isset($xmlexport_notice['hl']["value"]))
772                                $headers[] = array("name" => "hl", "value" => $xmlexport_notice['hl']["value"]);
773                        if (isset($xmlexport_notice['el']["value"]))
774                                $headers[] = array("name" => "el", "value" => $xmlexport_notice['el']["value"]);
775                        if (isset($xmlexport_notice['ru']["value"]))
776                                $headers[] = array("name" => "ru", "value" => $xmlexport_notice['ru']["value"]);
777                        $aresult["id"] = $anotice_id;
778                        $aresult["header"] = $headers;
779                        $aresult["f"] = $xmlexport_notice['f'];
780                        foreach ($aresult["f"] as &$af) {
781                                $af["ind"] = isset($af["ind"]) ? $af["ind"] : "";
782                                $af["id"] = isset($af["id"]) ? $af["id"] : "";
783                                $af["s"] = isset($af["s"]) ? $af["s"] : array();
784                                foreach ($af["s"] as &$as) {
785                                        $as["value"] = isset($as["value"]) ? $as["value"] : "";
786                                        $as["c"] = isset($as["c"]) ? $as["c"] : "";
787                                        //La classe export exporte ses données dans la charset de la base.
788                                        //Convertissons si besoin
789                                        if ($charset!='utf-8' && $target_charset == 'utf-8')
790                                                $as["value"] = utf8_encode($as["value"]);
791                                        else if ($charset=='utf-8' && $target_charset != 'utf-8')
792                                                $as["value"] = utf8_decode($as["value"]);
793                                }
794
795                        }
796                        $this->results[$anotice_id] = $aresult;
797                }
798        }
799       
800        function convert_batch_to_php_array_assoc($notices_to_convert, $target_charset='iso-8859-1') {
801                global $charset;
802                if (!$notices_to_convert) //Rien à faire? On fait rien
803                        return;
804
805                foreach($notices_to_convert as $anotice_id)  {
806                        $xmlexport_notice = $this->get_notice_unimarc_array($anotice_id);
807                        if (!$xmlexport_notice)
808                                continue;
809                        $aresult = array();
810                        $headers = array();
811                        if (isset($xmlexport_notice['rs']["value"]))
812                                $headers["rs"] = $xmlexport_notice['rs']["value"];
813                        if (isset($xmlexport_notice['dt']["value"]))
814                                $headers["dt"] = $xmlexport_notice['dt']["value"];
815                        if (isset($xmlexport_notice['bl']["value"]))
816                                $headers["bl"] = $xmlexport_notice['bl']["value"];
817                        if (isset($xmlexport_notice['hl']["value"]))
818                                $headers["hl"] = $xmlexport_notice['hl']["value"];
819                        if (isset($xmlexport_notice['el']["value"]))
820                                $headers["el"] = $xmlexport_notice['el']["value"];
821                        if (isset($xmlexport_notice['ru']["value"]))
822                                $headers["ru"] = $xmlexport_notice['ru']["value"];
823                        $aresult["id"] = $anotice_id;
824                        $aresult["header"] = $headers;
825                        $aresult["f"] = array();
826                        foreach ($xmlexport_notice['f'] as &$af) {
827                                if (!isset($af["c"]))
828                                        continue;
829                                if (!isset($aresult["f"][$af["c"]]))
830                                        $aresult["f"][$af["c"]] = array();
831                                $arf = array();
832                                $arf["ind"] = isset($af["ind"]) ? $af["ind"] : "";
833                                $arf["id"] = isset($af["id"]) ? $af["id"] : "";
834                                if (isset($af["s"])) {
835                                        foreach ($af["s"] as &$as) {
836                                                //La classe export exporte ses données dans la charset de la base.
837                                                //Convertissons si besoin
838                                                $value = $as["value"];
839                                                if ($charset!='utf-8' && $target_charset == 'utf-8')
840                                                        $value = utf8_encode($value);
841                                                else if ($charset=='utf-8' && $target_charset != 'utf-8')
842                                                        $value = utf8_decode($value);
843                                                if (isset($arf[$as["c"]]) && !is_array($arf[$as["c"]]))
844                                                        $arf[$as["c"]] = array($arf[$as["c"]]);
845                                                if (isset($arf[$as["c"]]) && is_array($arf[$as["c"]]))
846                                                        $arf[$as["c"]][] = $value;
847                                                else
848                                                        $arf[$as["c"]] = $value;
849                                        }
850                                }
851                                else if (isset($af["value"])) {
852                                        $arf["value"] = $af["value"];
853                                }
854
855                                $aresult["f"][$af["c"]][] = $arf;
856                        }
857                        $this->results[$anotice_id] = $aresult;
858                }
859        }
860       
861        function convert_batch_to_serialized($notices_to_convert, $target_charset='iso-8859-1') {
862                        $this->convert_batch_to_php_array($notices_to_convert, $target_charset);
863                foreach ($notices_to_convert as $anotice_id) {
864                        $this->results[$anotice_id] = serialize($this->results[$anotice_id]);
865                }
866        }
867       
868        function convert_batch_to_serialized_assoc($notices_to_convert, $target_charset='iso-8859-1') {
869                $this->convert_batch_to_php_array_assoc($notices_to_convert, $target_charset);
870                foreach ($notices_to_convert as $anotice_id) {
871                        $this->results[$anotice_id] = serialize($this->results[$anotice_id]);
872                }
873        }       
874       
875        function convert_batch_to_json($notices_to_convert, $target_charset='iso-8859-1') {
876                $this->convert_batch_to_php_array($notices_to_convert, $target_charset);
877                foreach ($notices_to_convert as $anotice_id)
878                        $this->results[$anotice_id] = json_encode($this->results[$anotice_id]);
879        }
880
881        function convert_batch_to_json_assoc($notices_to_convert, $target_charset='iso-8859-1') {
882                $this->convert_batch_to_php_array_assoc($notices_to_convert, $target_charset);
883                foreach ($notices_to_convert as $anotice_id)
884                        $this->results[$anotice_id] = json_encode($this->results[$anotice_id]);
885        }
886       
887        function convert_uncachednotices($format, $format_ref, $target_charset='iso-8859-1') {
888                $notices_to_convert=array();
889                foreach ($this->results as $notice_id => $aresult) {
890                        if (!$aresult && $notice_id) {
891                                $notices_to_convert[] = $notice_id;
892                        }
893                }
894               
895                //Conversion builtin
896                switch ($format) {
897                        case "json_unimarc":
898                                $this->convert_batch_to_json($notices_to_convert, $target_charset);
899                                break;
900                        case "json_unimarc_assoc":
901                                $this->convert_batch_to_json_assoc($notices_to_convert, $target_charset);
902                                break;
903                        case "serialized_unimarc":
904                                $this->convert_batch_to_serialized($notices_to_convert, $target_charset);
905                                break;
906                        case "serialized_unimarc_assoc":
907                                $this->convert_batch_to_serialized_assoc($notices_to_convert, $target_charset);
908                                break;
909                        case "raw_array":
910                                $this->convert_batch_to_php_array($notices_to_convert, $target_charset);
911                                break;
912                        case "raw_array_assoc":
913                                $this->convert_batch_to_php_array_assoc($notices_to_convert, $target_charset);
914                                break;
915                        default:
916                                //Par défaut on renvoie juste le notice_id
917                                foreach($notices_to_convert as $anotice_id) {
918                                        $this->results[$anotice_id] = $anotice_id;
919                                }
920                                break;
921                }
922
923                //Cachons les notices converties maintenant.
924                foreach ($notices_to_convert as $anotice_id) {
925                        if ($this->results[$anotice_id])
926                                $this->encache_value($anotice_id, $this->results[$anotice_id], $format_ref);
927                }
928        }
929       
930}
931
932
933?>
Note: See TracBrowser for help on using the repository browser.