source: spip-zone/_plugins_/xmlrpc/trunk/action/xmlrpc_serveur.php @ 81508

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

Indentation

File size: 33.7 KB
Line 
1<?php
2/**
3 * Plugin xmlrpc
4 *
5 * Auteurs : kent1 (http://www.kent1.info)
6 * © 2011-2012 - GNU/GPL v3
7 *
8 * Action serveur xml-rpc
9 */
10
11if (!defined("_ECRIRE_INC_VERSION")) return;
12
13function action_xmlrpc_serveur_dist(){
14        if(_request('rsd')){
15                $rsd = recuperer_fond('inclure/inc-rsd');
16                echo $rsd;
17                exit;
18        }
19       
20        global $HTTP_RAW_POST_DATA;
21        if (!isset($HTTP_RAW_POST_DATA)){
22                $HTTP_RAW_POST_DATA = file_get_contents( 'php://input' );
23        }
24       
25        if ( isset($HTTP_RAW_POST_DATA) )
26                $HTTP_RAW_POST_DATA = trim($HTTP_RAW_POST_DATA);
27
28        include_spip('lib/ixr/ixr_library');
29        include_spip('inc/utils');
30        include_spip('inc/filtres');
31        include_spip('inc/lien');
32        include_spip('inc/autoriser');
33        include_spip('public/quete');
34       
35        class spip_xmlrpc_server extends IXR_Server {
36                /**
37                 * Chargement des méthodes disponibles
38                 */
39                function __construct() {
40                        $this->methodes = array(
41                                /**
42                                 * SPIP API
43                                */
44                                'spip.auth' => 'this:auth',
45                                'spip.logout' => 'this:logout',
46                                'spip.creer_objet' => 'this:spip_creer_objet',
47                                'spip.lire_objet' => 'this:spip_lire_objet',
48                                'spip.supprimer_objet' => 'this:spip_supprimer_objet',
49                                'spip.modifier_objet' => 'this:spip_modifier_objet',
50                                'spip.lire_article' => 'this:spip_lire_article',
51                                'spip.lire_auteur' => 'this:spip_lire_auteur',
52                                'spip.lire_document' => 'this:spip_lire_document',
53                                'spip.lire_forum' => 'this:spip_lire_forum',
54                                'spip.lire_rubrique' => 'this:spip_lire_rubrique',
55                                'spip.lire_mot' => 'this:spip_lire_mot',
56                                'spip.liste_articles' => 'this:spip_liste_articles',
57                                'spip.liste_auteurs' => 'this:spip_liste_auteurs',
58                                'spip.liste_documents' => 'this:spip_liste_documents',
59                                'spip.liste_mots' => 'this:spip_liste_mots',
60                                'spip.liste_rubriques' => 'this:spip_liste_rubriques',
61                                'spip.liste_forums' => 'this:spip_liste_forums'
62                        );
63                        $this->methodes = pipeline('xmlrpc_methodes',$this->methodes);
64                }
65               
66                /**
67                 * Fonction de démarage du serveur
68                 */
69                function serve_request() {
70                        $this->IXR_Server($this->methodes);
71                }
72               
73                /**
74                 * Fonction qui regarde si le serveur est fermé ...
75                 *
76                 * @return bool : true si pas fermé, false s'il l'est
77                 */
78                function verifier_access(){
79                        $options = @unserialize($GLOBALS['meta']['xmlrpc']);
80                        if(!is_array($options))
81                                $options = array();
82                       
83                        if($options['ferme'] == 'on'){
84                                $this->error = new IXR_Error( 405, texte_backend(_T('xmlrpc:erreur_xmlrpc_desactive')));
85                                return false;
86                        }
87                        return true;
88                }
89               
90                /**
91                 * Fonction d'identification
92                 *
93                 * NB : si on a un cookie d'itenfication et une session valide, celle ci est utilisée
94                 *
95                 * Arguments :
96                 * -* 0 string : le login de l'utilisateur
97                 * -* 1 string : le mot de passe
98                 * ex : array('mon login','mon_pass');
99                 * return : l'array de la session de l'utilisateur
100                 * ou un bool false (0) en cas d'échec
101                 */
102                function auth($args=array()){
103                        $auth_methode = 'spip';
104                        if(is_array($GLOBALS['visiteur_session']) && $GLOBALS['visiteur_session'] > 1){
105                                return $GLOBALS['visiteur_session'];
106                        }
107                        $login = $args[0];
108                        include_spip('inc/auth');
109                        $res = auth_identifier_login(trim($login), trim($args[1]));
110                        /**
111                         * Si on n'a pas un array => mauvaise identification
112                         */
113                        if(!is_array($res)){
114                                $erreur = attribut_html(_T('xmlrpc:erreur_mauvaise_identification'));
115                                $this->error = new IXR_Error(403,$erreur);
116                                return false;
117                        }
118                        // sinon on loge l'auteur identifie, et on finit en envoyant les infos de l'auteur
119                        auth_loger($res);
120                        return $this->spip_lire_auteur(array('id_auteur'=>$res['id_auteur']));
121                }
122               
123                /**
124                 * Fonction de logout
125                 */
126                function logout(){
127                        global $visiteur_session;
128                        if (is_numeric($visiteur_session['id_auteur'])) {
129                                include_spip('inc/auth');
130                                auth_trace($visiteur_session, '0000-00-00 00:00:00');
131                                // le logout explicite vaut destruction de toutes les sessions
132                                if (isset($_COOKIE['spip_session'])) {
133                                        $session = charger_fonction('session', 'inc');
134                                        $session($visiteur_session['id_auteur']);
135                                        spip_setcookie('spip_session', $_COOKIE['spip_session'], time()-3600);
136                                }
137                        }
138                        return true;
139                }
140               
141                function read($args){
142                        $crud = charger_fonction('crud','action');
143                        $res = $crud('read',$args['objet'],$args['id_objet']);
144                        if($res['success'] != 1 OR !$res['success']){
145                                $erreur = strlen($res['message'])?$res['message']:_T('xmlrpc:erreur_lecture',array('objet'=>$args['objet'],'id_objet' => $args['id_objet']));
146                                $this->error = new IXR_Error(-32601, texte_backend($erreur));
147                                return false;
148                        }
149                        /**
150                         * Si on a un argument "champs_demandes", on enlève du résultat ce qui n'y parait pas
151                         */
152                        if(is_array($args['champs_demandes']) && (count($args['champs_demandes']) > 0)){
153                                foreach ($res['result'][0] as $champ => $valeur){
154                                        if(!in_array($champ,array(id_table_objet($args['objet']))) && !in_array($champ,$args['champs_demandes']))
155                                                unset($res['result'][0][$champ]);
156                                }
157                        }
158                        return $res;
159                }
160               
161                function create($args){
162                        if(!is_array($args['set'])){
163                                $this->error = new IXR_Error(-32601, texte_backend(_T('xmlrpc:erreur_argument_set')));
164                                return false;
165                        }
166                        $crud = charger_fonction('crud','action');
167                        $res = $crud('create',$args['objet'],$args['id_objet'],$args['set']);
168                        if($res['success'] != 1 OR !$res['success']){
169                                $this->error = new IXR_Error(-32601, texte_backend($res['message']));
170                                return false;
171                        }
172
173                        return $res;
174                }
175               
176                function update($args){
177                        if(!is_array($args['set'])){
178                                $this->error = new IXR_Error(-32601, texte_backend(_T('xmlrpc:erreur_argument_set')));
179                                return false;
180                        }
181                        $crud = charger_fonction('crud','action');
182                        $res = $crud('update',$args['objet'],$args['id_objet'],$args['set']);
183                        if($res['success'] != 1 OR (!$res['success'])){
184                                $this->error = new IXR_Error(-32601, texte_backend($res['message']));
185                                return false;
186                        }
187                        return $res;
188                }
189               
190                function delete($args){
191                        $crud = charger_fonction('crud','action');
192                        $res = $crud('delete',$args['objet'],$args['id_objet']);
193                        if($res['success'] != 1){
194                                $this->error = new IXR_Error(-32601, texte_backend($res['message']));
195                                return false;
196                        }
197                        if($res['result']['row'] == false){
198                                $message = _T('crud:erreur_edition_objet',array('objet'=>$args['objet'],'id'=>$args['id_objet']));
199                                return new IXR_Error(-32601, attribut_html($message));
200                        }
201                        return $res;
202                }
203               
204                /**
205                 * Crée un objet
206                 * On vérifie si une fonction spécifique à un objet est disponible
207                 * sinon on tente un create() sur le type d'objet
208                 *
209                 * Paramètres :
210                 * -* login string
211                 * -* pass string
212                 * -* objet string : obligatoire
213                 * -* set array : obligatoire - le contenu des champs à mettre en base
214                 */
215                function spip_creer_objet($args){
216                        if(!$args['objet'] OR !is_array($args['set']))
217                                return new IXR_Error(-32601, _T('xmlrpc:erreur_arguments_obligatoires',array('arguments'=>'objet, set')));
218                       
219                        $methode = 'spip.creer_'.$args['objet'];
220                       
221                        foreach($args['set'] as $key => $value){
222                                if(is_numeric($key)){
223                                        if(preg_match('/=/',$value)){
224                                                $values = explode('=',$value,2);
225                                                $set[$values[0]] = $values[1];
226                                        }else
227                                                return new IXR_Error(-32601, _T('xmlrpc:erreur_array'));
228                                }else{
229                                        $set[$key] = $value;
230                                }
231                        }
232                        $args['set'] = $set;
233                        /**
234                         * On regarde si la méthode spip.creer_$args['objet'] existe ...
235                         * On l'utilise si possible
236                         */
237                        if ($this->hasMethod($methode)) {
238                                $struct = $this->call($methode, $args);
239                        }
240                        else {
241                                $struct = $this->create($args);
242                                if(!$struct)
243                                        return $this->error ? $this->error : new IXR_Error(-32601, _T('xmlrpc:erreur_impossible_creer_objet',$args));
244                        }
245                        if(isset($struct['result']))
246                                $struct = $struct['result']['row'];
247                        return $struct;
248                }
249
250                /**
251                 * Met à jour un objet
252                 * On vérifie si une fonction spécifique à un objet est disponible
253                 * sinon on tente un update() sur l'objet spécifié
254                 *
255                 * Paramètres :
256                 * -* login string
257                 * -* pass string
258                 * -* objet string : obligatoire
259                 * -* id_objet int : obligatoire
260                 * -* set array : obligatoire - les champs à mettre à jour
261                 */
262                function spip_modifier_objet($args){
263                        if(!$args['objet'] OR !intval($args['id_objet']) OR !is_array($args['set']))
264                                return new IXR_Error(-32601, _T('xmlrpc:erreur_arguments_obligatoires',array('arguments'=>'objet,id_objet,set')));
265                       
266                        $methode = 'spip.modifier_'.$args['objet'];
267                       
268                        foreach($args['set'] as $key => $value){
269                                if(is_numeric($key)){
270                                        if(preg_match('/=/',$value)){
271                                                $values = explode('=',$value,2);
272                                                $set[$values[0]] = $values[1];
273                                        }else
274                                                return new IXR_Error(-32601, _T('xmlrpc:erreur_array'));
275                                }else{
276                                        $set[$key] = $value;
277                                }
278                        }
279                        $args['set'] = $set;
280
281                        /**
282                         * On regarde si la méthode spip.modifier_$args['objet'] existe ...
283                         * On l'utilise si possible
284                         */
285                        if ($this->hasMethod($methode)) {
286                                $struct = $this->call($methode, $args);
287                        }
288                        else {
289                                $struct = $this->update($args);
290                                if(!$struct)
291                                        return $this->error ? $this->error : new IXR_Error(-32601, _T('xmlrpc:erreur_impossible_modifier_objet',$args));
292                        }
293                        if(isset($struct['result']))
294                                $struct = $struct['result']['row'];
295                        return $struct;
296                }
297               
298                /**
299                 * Supprime un objet
300                 * On vérifie si une fonction spécifique à un objet est disponible
301                 * sinon on tente un delete() sur l'objet en question
302                 *
303                 * Paramètres :
304                 * -* login string
305                 * -* pass string
306                 * -* objet string : obligatoire
307                 * -* id_objet int : obligatoire
308                 */
309                function spip_supprimer_objet($args){
310                        if(!$args['objet'] OR !intval($args['id_objet']))
311                                return new IXR_Error(-32601, _T('xmlrpc:erreur_arguments_obligatoires',array('arguments'=>'objet,id_objet')));
312                       
313                        $methode = 'spip.supprimer_'.$args['objet'];
314                       
315                        /**
316                         * On regarde si la méthode spip.creer_$args['objet'] existe ...
317                         * On l'utilise si possible
318                         */
319                        if ($this->hasMethod($methode)) {
320                                $struct = $this->call($methode, $args);
321                        }
322                        else {
323                                $struct = $this->create($args);
324                                if(!$struct)
325                                        return new IXR_Error(-32601, _T('xmlrpc:erreur_impossible_supprimer_objet',$args));
326                        }
327                        if(isset($struct['result']))
328                                $struct = $struct['result'][0];
329                        return $struct;
330                }
331
332                /**
333                 * Récupère le contenu d'un objet
334                 * On vérifie si une fonction spécifique à un objet est disponible
335                 * sinon on tente un read() sur l'objet en paramètre
336                 *
337                 * Paramètres :
338                 * -* login string
339                 * -* pass string
340                 * -* objet string : obligatoire
341                 * -* id_objet int : obligatoire
342                 */
343                function spip_lire_objet($args){
344                        if(!$args['objet'] OR !$args['id_objet'])
345                                return new IXR_Error(-32601, _T('xmlrpc:erreur_arguments_obligatoires',array('arguments'=>'objet, id_objet')));
346                       
347                        $args[id_table_objet($args['objet'])] = $args['id_objet'];
348                        $methode = 'spip.lire_'.$args['objet'];
349                       
350                        /**
351                         * On regarde si la méthode spip.lire_$args['objet'] existe ...
352                         * On l'utilise si possible
353                         */
354                        if ($this->hasMethod($methode)) {
355                                $struct = $this->call($methode, $args);
356                        }
357                        else {
358                                $struct = $this->read($args);
359                                if(!$struct)
360                                        return new IXR_Error(-32601, _T('xmlrpc:erreur_impossible_lire_objet',$args));
361                        }
362                        if(isset($struct['result']))
363                                $struct = $struct['result'][0];
364                        return $struct;
365                }
366               
367                /**
368                 * Récupère le contenu d'un article
369                 *
370                 * Arguments possibles :
371                 * -* login string
372                 * -* pass string
373                 * -* id_article int : obligatoire
374                 */
375                function spip_lire_article($args){
376                        if(!intval($args['id_article']) > 0){
377                                $erreur = _T('xmlrpc:erreur_identifiant',array('objet'=>'article'));
378                                return new IXR_Error(-32601, attribut_html($erreur));
379                        }
380                       
381                        $from[] = 'spip_articles';
382                        $where[] = 'id_article='.intval($args['id_article']);
383                       
384                        $statut = sql_getfetsel('statut',$from,$where);
385                        $args_article = array_merge($args,array('id_objet'=>$args['id_article'],'objet'=>'article'));
386                       
387                        /**
388                         * Si on est identifié
389                         * Si on a un id_article non publié dans la requète on regarde si on a le droit de le modifier
390                         */
391                        if(($statut != 'publie') && is_array($GLOBALS['visiteur_session']) && autoriser('modifier','article',$args['id_article'],$GLOBALS['visiteur_session'])){
392                                $res = $this->read($args_article);
393                                if(!$res)
394                                        return $this->error;
395                                $logo = quete_logo('id_article','on', $res['result'][0]['id_article'], '', false);
396                                if(is_array($logo))
397                                        $res['result'][0]['logo'] = url_absolue($logo[0]);
398                                $res['result'][0]['modifiable'] = 1;
399                                $article_struct = $res['result'][0];
400                        }
401                        /**
402                         * Cas où l'on n'a pas de user/pass
403                         * On liste l'article uniquement si publié
404                         */
405                        else if($statut == 'publie'){
406                                $res = $this->read($args_article);
407                                if(!$res)
408                                        return $this->error;
409                                $res['result'][0]['url'] = url_absolue(generer_url_entite($args['id_article'],'article'));
410                                $logo = quete_logo('id_article','on', $res['result'][0]['id_article'], '', false);
411                                if(is_array($logo))
412                                        $res['result'][0]['logo'] = url_absolue($logo[0]);
413                                if(autoriser('modifier','article',$args['id_article'],$GLOBALS['visiteur_session']))
414                                        $res['result'][0]['modifiable'] = 1;
415                                else
416                                        $res['result'][0]['modifiable'] = 0;
417                                $article_struct = $res['result'][0];
418                        }
419                        /**
420                         * Sinon on envoit une erreur
421                         */
422                        else{
423                                $erreur = _T('xmlrpc:erreur_objet_inexistant',array('objet'=>'article','id_objet'=>$args['id_article']));
424                                return new IXR_Error(-32601, attribut_html($erreur));
425                        }
426                        return $article_struct;
427                }
428
429                /**
430                 * Récupère le contenu d'un auteur
431                 *
432                 * Arguments possibles :
433                 * -* login string
434                 * -* pass string
435                 * -* id_auteur int : obligatoire
436                 */
437                function spip_lire_auteur($args){
438                        if(!intval($args['id_auteur']) > 0){
439                                $erreur = _T('xmlrpc:erreur_identifiant',array('objet'=>'auteur'));
440                                return new IXR_Error(-32601, attribut_html($erreur));
441                        }
442
443                        $from = 'spip_auteurs';
444                        $where = 'id_auteur='.intval($args['id_auteur']);
445                       
446                        $statut = sql_getfetsel('statut',$from,$where);
447                        $args_auteur = array_merge($args,array('id_objet'=>$args['id_auteur'],'objet'=>'auteur'));
448
449                        /**
450                         * Si on est identifié
451                         * Si on a un id_auteur dans la requète on liste les articles publiés de l'id_auteur en question
452                         * Sinon on liste l'ensemble des articles de l'auteur logué qu'il soit publiés ou non
453                         */
454                        if(autoriser('modifier','auteur',$args['id_auteur'],$GLOBALS['visiteur_session'])){
455                                $res = $this->read($args_auteur);
456                                if(!$res)
457                                        return $this->error;
458                                $a_enlever = array(
459                                                        'en_ligne',
460                                                        'pass',
461                                                        'low_sec',
462                                                        'htpass',
463                                                        'alea_actuel',
464                                                        'alea_futur',
465                                                        'prefs',
466                                                        'cookie_oubli',
467                                                        'source',
468                                                        'extra',
469                                                        'composition',
470                                                        'composition_lock',
471                                                        'auth');
472                       
473                                foreach($a_enlever as $enleve){
474                                        unset($res['result'][0][$enleve]);
475                                }
476                                if(in_array($statut,array("6forum","0minirezo","1comite")))
477                                        $res['result'][0]['url'] = url_absolue(generer_url_entite($args['id_auteur'],'auteur'));
478                                $logo = quete_logo('id_auteur','on', $res['result'][0]['id_auteur'], '', false);
479                                if(is_array($logo))
480                                        $res['result'][0]['logo'] = url_absolue($logo[0]);
481                                $res['result'][0]['modifiable'] = 1;
482                                $auteur_struct = $res['result'][0];
483                        }
484                        /**
485                         * Cas où l'on n'a pas de user/pass
486                         * On liste l'auteur uniquement s'il existe (pas dans la poubelle)
487                         */
488                        else if(in_array($statut,array("6forum","0minirezo","1comite"))){
489                                $res = $this->read($args_auteur);
490                                if(!$res)
491                                        return $this->error;
492                                $a_enlever = array(
493                                                        'en_ligne',
494                                                        'email',
495                                                        'login',
496                                                        'pass',
497                                                        'low_sec',
498                                                        'htpass',
499                                                        'alea_actuel',
500                                                        'alea_futur',
501                                                        'prefs',
502                                                        'cookie_oubli',
503                                                        'source',
504                                                        'extra',
505                                                        'composition',
506                                                        'composition_lock',
507                                                        'auth');
508                       
509                                foreach($a_enlever as $enleve){
510                                        unset($res['result'][0][$enleve]);
511                                }
512                                $res['result'][0]['url'] = url_absolue(generer_url_entite($args['id_auteur'],'auteur'));
513                                $logo = quete_logo('id_auteur','on', $res['result'][0]['id_auteur'], '', false);
514                                if(is_array($logo))
515                                        $res['result'][0]['logo'] = url_absolue($logo[0]);
516                                $res['result'][0]['modifiable'] = 0;
517                                $auteur_struct = $res['result'][0];
518                        }
519                        /**
520                         * Sinon on envoit une erreur
521                         */
522                        else{
523                                $erreur = _T('xmlrpc:erreur_objet_inexistant',array('objet'=>'auteur','id_objet'=>$args['id_auteur']));
524                                return new IXR_Error(-32601, attribut_html($erreur));
525                        }
526
527                        return $auteur_struct;
528                }
529
530                /**
531                 * Récupère le contenu d'un document
532                 *
533                 * Arguments possibles :
534                 * -* login string
535                 * -* pass string
536                 * -* id_document : obligatoire
537                 */
538                function spip_lire_document($args){
539                        if(!intval($args['id_document']) > 0){
540                                $erreur = _T('xmlrpc:erreur_identifiant',array('objet'=>'document'));
541                                return new IXR_Error(-32601, attribut_html($erreur));
542                        }
543                       
544                        $from = 'spip_documents';
545                        $where = 'id_document='.intval($args['id_document']);
546                       
547                        $args_document = array_merge($args,array('id_objet'=>$args['id_document'],'objet'=>'document'));
548                        $res = $this->read($args_document);
549                        if(!$res){
550                                return $this->error;
551                        }
552
553                        include_spip('inc/documents');
554                        $res['result'][0]['fichier'] = url_absolue(get_spip_doc($res['result'][0]['fichier']));
555                        if(intval($res['result'][0]['id_vignette']) > 0)
556                                $res['result'][0]['vignette'] = url_absolue(get_spip_doc(sql_getfetsel('fichier','spip_documents','id_document='.intval($res['result'][0]['id_vignette']))));
557                        else
558                        if(autoriser('modifier','document',$args['id_document'],$GLOBALS['visiteur_session']))
559                                $res['result'][0]['modifiable'] = 1;
560                        else
561                                $res['result'][0]['modifiable'] = 0;
562
563                        $document_struct = $res['result'][0];
564                       
565                        return $document_struct;
566                }
567
568                /**
569                 * Récupère le contenu d'une rubrique
570                 *
571                 * Arguments possibles :
572                 * -* login string
573                 * -* pass string
574                 * -* id_rubrique int : obligatoire
575                 */
576                function spip_lire_rubrique($args){
577                        if(!intval($args['id_rubrique']) > 0){
578                                $erreur = _T('xmlrpc:erreur_identifiant',array('objet'=>'rubrique'));
579                                return new IXR_Error(-32601, attribut_html($erreur));
580                        }
581                       
582                        $from = 'spip_rubriques';
583                        $where = 'id_rubrique='.intval($args['id_rubrique']);
584                       
585                        $statut = sql_getfetsel('statut',$from,$where);
586                        $args_rubrique = array_merge($args,array('id_objet'=>$args['id_rubrique'],'objet'=>'rubrique'));
587                       
588                        /**
589                         * Si on est identifié
590                         * Si on a un id_rubrique non publié dans la requète on regarde si on a le droit de créer un article dedans
591                         */
592                        if(($statut != 'publie') && is_array($GLOBALS['visiteur_session']) && autoriser('creerarticledans','rubrique',$args['id_rubrique'],$GLOBALS['visiteur_session'])){
593                                $res = $this->read($args_rubrique);
594                                if(!$res)
595                                        return $this->error;
596                                if(autoriser('modifier','rubrique',$args['id_rubrique'],$GLOBALS['visiteur_session']))
597                                        $res['result'][0]['modifiable'] = 1;
598                                else
599                                        $res['result'][0]['modifiable'] = 0;
600                                $logo = quete_logo('id_rubrique','on', $res['result'][0]['id_rubrique'], '', false);
601                                if(is_array($logo))
602                                        $res['result'][0]['logo'] = url_absolue($logo[0]);
603                                $rubrique_struct = $res['result'][0];
604                        }
605                        /**
606                         * Cas où l'on n'a pas de user/pass
607                         * On liste la rubrique uniquement si publié
608                         */
609                        else if($statut == 'publie'){
610                                $res = $this->read($args_rubrique);
611                                if(!$res)
612                                        return $this->error;
613                                $res['result'][0]['url'] = url_absolue(generer_url_entite($args['id_rubrique'],'rubrique'));
614                                if(autoriser('modifier','rubrique',$args['id_rubrique'],$GLOBALS['visiteur_session']))
615                                        $res['result'][0]['modifiable'] = 1;
616                                else
617                                        $res['result'][0]['modifiable'] = 0;
618                                $logo = quete_logo('id_rubrique','on', $res['result'][0]['id_rubrique'], '', false);
619                                if(is_array($logo))
620                                        $res['result'][0]['logo'] = url_absolue($logo[0]);
621                                $rubrique_struct = $res['result'][0];
622                        }
623                        /**
624                         * Sinon on envoit une erreur
625                         */
626                        else{
627                                $erreur = _T('xmlrpc:erreur_objet_inexistant',array('objet'=>'rubrique','id_objet'=>$args['id_rubrique']));
628                                return new IXR_Error(-32601, attribut_html($erreur));
629                        }
630
631                        return $rubrique_struct;
632                }
633
634                /**
635                 * Récupère le contenu d'un mot
636                 *
637                 * Arguments possibles :
638                 * -* login string
639                 * -* pass string
640                 * -* id_mot int : obligatoire
641                 */
642                function spip_lire_mot($args){
643                        if(!intval($args['id_mot']) > 0){
644                                $erreur = _T('xmlrpc:erreur_identifiant',array('objet'=>'mot'));
645                                return new IXR_Error(-32601, attribut_html($erreur));
646                        }
647                       
648                        $args_mot = array_merge($args,array('objet'=>'mot','id_objet'=>$args['id_mot']));
649                        $res = $this->read($args_mot);
650                       
651                        if(!$res)
652                                return $this->error;
653                        if(autoriser('modifier','mot',$args['id_mot'],$GLOBALS['visiteur_session']))
654                                $res['result'][0]['modifiable'] = 1;
655                        else
656                                $res['result'][0]['modifiable'] = 0;
657                        $logo = quete_logo('id_mot','on', $res['result'][0]['id_mot'], '', false);
658                        if(is_array($logo))
659                                $res['result'][0]['logo'] = url_absolue($logo[0]);
660                        $mot_struct = $res['result'][0];
661
662                        return $mot_struct;
663                }
664                /**
665                 * Récupère le contenu d'un forum
666                 *
667                 * Arguments possibles :
668                 * -* login string
669                 * -* pass string
670                 * -* id_forum int : obligatoire
671                 */
672                function spip_lire_forum($args){
673                        if(!intval($args['id_forum']) > 0){
674                                $erreur = _T('xmlrpc:erreur_identifiant',array('objet'=>'forum'));
675                                return new IXR_Error(-32601, attribut_html($erreur));
676                        }
677                       
678                        $args_forum = array_merge($args,array('objet'=>'forum','id_objet'=>$args['id_forum']));
679                        $res = $this->read($args_forum);
680                       
681                        if(!$res)
682                                return $this->error;
683                        if(autoriser('modifier','forum',$args['id_forum'],$GLOBALS['visiteur_session']))
684                                $res['result'][0]['modifiable'] = 1;
685                        else
686                                $res['result'][0]['modifiable'] = 0;
687
688                        $forum_struct = $res['result'][0];
689
690                        return $forum_struct;
691                }
692                /**
693                 * Récupère la liste des objet
694                 * On vérifie si une fonction spécifique à un objet est disponible
695                 * sinon on tente un read() sur l'objet en paramètre
696                 */
697                function spip_liste_objets($args){
698                        if(!$args['objet'] OR !$args['id_objet'])
699                                return new IXR_Error(-32601, _T('xmlrpc:erreur_arguments_obligatoires',array('arguments'=>'objet, id_objet')));
700                       
701                        $args[id_table_objet($args['objet'])] = $args['id_objet'];
702                        $methode = 'spip.lire_'.$args['objet'];
703                       
704                        /**
705                         * On regarde si la méthode spip.lire_$args['objet'] existe ...
706                         * On l'utilise si possible
707                         */
708                        if ($this->hasMethod($methode)) {
709                                $struct = $this->call($methode, $args);
710                        }
711                        else {
712                                $struct = $this->read($args);
713                                if(!$struct)
714                                        return new IXR_Error(-32601, _T('xmlrpc:erreur_impossible_lire_objet',$args));
715                        }
716                        return $struct;
717                }
718                /**
719                 * Récupère la liste des articles
720                 *
721                 * Arguments possibles :
722                 * -* login string
723                 * -* pass string
724                 * -* id_rubrique int
725                 * -* id_secteur int
726                 * -* id_auteur int
727                 * -* where array : conditions à ajouter dans la clause where du select
728                 * -* tri array (un array de champs pour trier)
729                 * -* limite int
730                 */
731                function spip_liste_articles($args){
732                        $objet = 'article';
733                       
734                        $what[] = 'articles.id_article';
735                       
736                        if (version_compare($GLOBALS['spip_version_branche'], '2.3', '>=')){
737                                $from = 'spip_articles as articles LEFT JOIN spip_auteurs_liens AS auteurs ON articles.id_article=auteurs.id_objet AND auteurs.objet="article"';
738                        }else{
739                                $from = 'spip_articles as articles LEFT JOIN spip_auteurs_articles AS auteurs ON articles.id_article=auteurs.id_article';
740                        }
741                        $where = is_array($args['where']) ? $args['where'] : array();
742                        $order = is_array($args['tri']) ? $args['tri'] : array('!date');
743                       
744                        if(intval($args['id_rubrique'])){
745                                $where[] = 'articles.id_rubrique='.intval($args['id_rubrique']);
746                        }
747                        if(intval($args['id_secteur'])){
748                                $where[] = 'articles.id_secteur='.intval($args['id_secteur']);
749                        }
750                        if(intval($args['id_auteur'])){
751                                $where[] = 'auteurs.id_auteur='.intval($args['id_auteur']);
752                        }
753                       
754                        if(is_string($args['recherche']) AND strlen($args['recherche']) > 3){
755                                $prepare_recherche = charger_fonction('prepare_recherche', 'inc');
756                                list($rech_select, $rech_where) = $prepare_recherche($args['recherche'], $objet, $where);
757                                $what[] = $rech_select;
758                                $from .= ' INNER JOIN spip_resultats AS resultats ON ( resultats.id = articles.id_article ) ';
759                                $where[] = 'resultats.'.$rech_where;
760                        }
761                       
762                        $articles_struct = array();
763                       
764                        /**
765                         * Si on est identifié
766                         * Si on a un id_auteur dans la requète on liste les articles publiés de l'id_auteur en question
767                         * Sinon on liste l'ensemble des articles de l'auteur logué qu'il soit publiés ou non
768                         */
769                        if(is_array($GLOBALS['visiteur_session'])){
770                                $articles_struct = array();
771                                if(!$args['id_auteur']){
772                                        $where[] = 'auteurs.id_auteur='.intval($GLOBALS['visiteur_session']['id_auteur']);
773                                }else{
774                                        $where[] = 'articles.statut="publie"';
775                                }
776                        }
777                        /**
778                         * Cas où l'on n'a pas de user/pass
779                         * On liste les articles publiés uniquement
780                         */
781                        else{
782                                $where[] = 'articles.statut="publie"';
783                        }
784
785                        if($arts = sql_select($what,$from,$where,array(),$order,$args['limite'])){
786                                while($art = sql_fetch($arts)){
787                                        $struct=array();
788                                        $args['id_article'] = $art['id_article'];
789                                        /**
790                                         * On utilise la fonction lire_article pour éviter de dupliquer trop de code
791                                         */
792                                        $struct = $this->spip_lire_article($args);
793                                        $articles_struct[] = $struct;
794                                }
795                        }
796
797                        return $articles_struct;
798                }
799               
800                /**
801                 * Récupère la liste des auteurs
802                 *
803                 * Arguments possibles :
804                 * -* statut
805                 * -* recherche
806                 * -* where array : conditions à ajouter dans la clause where du select
807                 * -* tri array (un array de champs pour trier)
808                 * -* limite int : le nombre de résultats à retourner
809                 */
810                function spip_liste_auteurs($args){
811                        $objet = 'auteur';
812                       
813                        $what[] = 'auteurs.id_auteur';
814                        $from = 'spip_auteurs AS auteurs';
815                        $where = is_array($args['where']) ? $args['where'] : array();
816                        $order = is_array($args['tri']) ? $args['tri'] : array('!id_auteur');
817                       
818                        if(is_string($args['recherche']) AND strlen($args['recherche']) > 3){
819                                $prepare_recherche = charger_fonction('prepare_recherche', 'inc');
820                                list($rech_select, $rech_where) = $prepare_recherche($args['recherche'], $objet, $where);
821                                $what[] = $rech_select;
822                                $from .= ' INNER JOIN spip_resultats AS resultats ON ( resultats.id = auteurs.id_auteur ) ';
823                                $where[] = 'resultats.'.$rech_where;
824                        }
825                        $auteurs_struct = array();
826                       
827                        /**
828                         * Si on est identifié
829                         * Si on a le droit de modifier l'auteur en question, on affiche son mail et son login
830                         */
831                        if(is_array($GLOBALS['visiteur_session'])){
832                                $where[] = 'auteurs.statut IN ("6forum","0minirezo","1comite")';
833                        }else{
834                                $where[] = 'auteurs.statut IN ("6forum","0minirezo","1comite")'; 
835                        }
836                        if($auts = sql_select($what,$from,$where,array(),$order,$args['limite'])){
837                                while($aut = sql_fetch($auts)){
838                                        $struct=array();
839                                        $args['id_auteur'] = $aut['id_auteur'];
840                                        /**
841                                         * On utilise la fonction lire_auteur pour éviter de dupliquer trop de code
842                                         */
843                                        $struct = $this->spip_lire_auteur($args);
844                                        $auteurs_struct[] = $struct;
845                                }
846                        }
847                        return $auteurs_struct;
848                }
849
850                /**
851                 * Récupère la liste des documents
852                 *
853                 * Arguments possibles :
854                 * -* login string
855                 * -* pass string
856                 * -* id_objet
857                 * -* objet
858                 * -* where array : conditions à ajouter dans la clause where du select
859                 * -* recherche
860                 * -* tri array (un array de champs pour trier)
861                 * -* limite int : le nombre de résultats à retourner
862                 */
863                function spip_liste_documents($args){
864                        $objet = 'document';
865                       
866                        $what[] = 'documents.id_document';
867                        $from = 'spip_documents as documents LEFT JOIN spip_documents_liens as lien ON documents.id_document=lien.id_document';
868                        $where = is_array($args['where']) ? $args['where'] : array();
869                        $order = is_array($args['tri']) ? $args['tri'] : array('!id_document');
870                       
871                        if(intval($args['id_objet']) && $args['objet']){
872                                $where[] = 'lien.id_objet='.intval($args['id_objet']).' AND lien.objet='.sql_quote($args['objet']);
873                        }
874                       
875                        if(is_string($args['recherche']) AND strlen($args['recherche']) > 3){
876                                $prepare_recherche = charger_fonction('prepare_recherche', 'inc');
877                                list($rech_select, $rech_where) = $prepare_recherche($args['recherche'], $objet, $where);
878                                $what[] = $rech_select;
879                                $from .= ' INNER JOIN spip_resultats AS resultats ON ( resultats.id = documents.id_document ) ';
880                                $where[] = 'resultats.'.$rech_where;
881                        }
882                       
883                        $documents_struct = array();
884       
885                        if($documents = sql_select($what,$from,$where,array(),$order,$args['limite'])){
886                                while($document = sql_fetch($documents)){
887                                        $struct=array();
888                                        $args['id_document'] = $document['id_document'];
889                                        /**
890                                         * On utilise la fonction lire_document pour éviter de dupliquer trop de code
891                                         */
892                                        $struct = $this->spip_lire_document($args);
893                                        $documents_struct[] = $struct;
894                                }
895                        }
896
897                        return $documents_struct;
898                }
899
900                /**
901                 * Récupère la liste des mots clés
902                 *
903                 * Arguments possibles :
904                 * -* login string
905                 * -* pass string
906                 * -* id_groupe
907                 * -* where array : conditions à ajouter dans la clause where du select
908                 * -* recherche
909                 * -* tri array (un array de champs pour trier)
910                 * -* limite int : le nombre de résultats à retourner
911                 */
912                function spip_liste_mots($args){
913                        $objet = 'mot';
914                       
915                        $what[] = 'mots.id_mot';
916                        $from = 'spip_mots as mots';
917                        $where = is_array($args['where']) ? $args['where'] : array();
918                        $order = is_array($args['tri']) ? $args['tri'] : array('!id_mot');
919                       
920                        if(intval($args['id_groupe'])){
921                                $where[] = 'mots.id_groupe='.intval($args['id_groupe']);
922                        }
923                       
924                        if(is_string($args['recherche']) AND strlen($args['recherche']) > 3){
925                                $prepare_recherche = charger_fonction('prepare_recherche', 'inc');
926                                list($rech_select, $rech_where) = $prepare_recherche($args['recherche'], $objet, $where);
927                                $what[] = $rech_select;
928                                $from .= ' INNER JOIN spip_resultats AS resultats ON ( resultats.id = rubriques.id_rubrique ) ';
929                                $where[] .= 'resultats.'.$rech_where;
930                        }
931
932                        $mots_struct = array();
933       
934                        if($mots = sql_select($what,$from,$where,array(),$order,$args['limite'])){
935                                while($mot = sql_fetch($mots)){
936                                        $struct=array();
937                                        $args['id_mot'] = $mot['id_mot'];
938                                        /**
939                                         * On utilise la fonction lire_mot pour éviter de dupliquer trop de code
940                                         */
941                                        $struct = $this->spip_lire_mot($args);
942                                        $mots_struct[] = $struct;
943                                }
944                        }
945
946                        return $mots_struct;
947                }
948
949                /**
950                 * Récupère la liste des rubriques
951                 *
952                 * Arguments possibles :
953                 * -* id_parent
954                 * -* id_secteur
955                 * -* login string
956                 * -* pass string
957                 * -* where array : conditions à ajouter dans la clause where du select
958                 * -* recherche
959                 * -* tri array (un array de champs pour trier)
960                 * -* limite int : le nombre de résultats à retourner
961                 */
962                function spip_liste_rubriques($args){
963                        $objet = 'rubrique';
964                       
965                        $where = is_array($args['where']) ? $args['where'] : array();
966                        $where[] = 'rubriques.id_rubrique > 0';
967                        $what[] = 'rubriques.id_rubrique';
968                        $from = 'spip_rubriques AS rubriques';
969                        $order = is_array($args['tri']) ? $args['tri'] : array('!id_rubrique');
970                       
971                        if(intval($args['id_parent'])){
972                                $where[] = 'rubriques.id_parent='.intval($args['id_parent']);
973                        }
974                        if(intval($args['id_secteur'])){
975                                $where[] = 'rubriques.id_secteur='.intval($id_secteur);
976                        }
977                       
978                        if(is_string($args['recherche']) AND strlen($args['recherche']) > 3){
979                                $prepare_recherche = charger_fonction('prepare_recherche', 'inc');
980                                list($rech_select, $rech_where) = $prepare_recherche($args['recherche'], $objet, $where);
981                                $what = $rech_select;
982                                $from .= ' INNER JOIN spip_resultats AS resultats ON ( resultats.id = rubriques.id_rubrique ) ';
983                                $where[] = 'resultats.'.$rech_where;
984                        }
985                       
986                        $categories_struct = array();
987                       
988                        if(is_array($GLOBALS['visiteur_session'])){
989                               
990                        }
991                        /**
992                         * Cas où l'on n'a pas de user/pass
993                         * On liste les rubriques publiées
994                         */
995                        else{
996                               
997                        }
998                        if($cats = sql_select($what,$from,$where,array(),$order,$args['limite'])){
999                                while($cat = sql_fetch($cats)){
1000                                        $struct=array();
1001                                        if(autoriser('creerarticledans','rubrique',$cat['id_rubrique'],$GLOBALS['visiteur_session'])){
1002                                                $args['id_rubrique'] = $cat['id_rubrique'];
1003                                                /**
1004                                                 * On utilise la fonction lire_mot pour éviter de dupliquer trop de code
1005                                                 */
1006                                                $struct = $this->spip_lire_rubrique($args);
1007                                                $categories_struct[] = $struct;
1008                                        }
1009                                }
1010                        }
1011                        return $categories_struct;
1012                }
1013
1014                /**
1015                 * Récupère la liste des forums
1016                 *
1017                 * Arguments possibles :
1018                 * -* id_thread
1019                 * -* recherche
1020                 * -* login string
1021                 * -* pass string
1022                 * -* where array : conditions à ajouter dans la clause where du select
1023                 * -* tri array (un array de champs pour trier)
1024                 * -* limite int : le nombre de résultats à retourner
1025                 */
1026                function spip_liste_forums($args){
1027                        $objet = 'forum';
1028                       
1029                        $what[] = 'forums.id_forum'; 
1030                        $from = 'spip_forum as forums';
1031                        $where = is_array($args['where']) ? $args['where'] : array();
1032                        $order = is_array($args['tri']) ? $args['tri'] : array('!id_forum');
1033                       
1034                        if(is_string($args['recherche']) AND strlen($args['recherche']) > 3){
1035                                $prepare_recherche = charger_fonction('prepare_recherche', 'inc');
1036                                list($rech_select, $rech_where) = $prepare_recherche($args['recherche'], $objet, $where,null,true);
1037                                $what[] = $rech_select;
1038                                $from .= ' INNER JOIN spip_resultats AS resultats ON ( resultats.id = forums.id_forum ) ';
1039                                $where[] = $rech_where;
1040                        }
1041                       
1042                        if($args['id_auteur']){
1043                                $where[] = 'forums.id_auteur='.intval($args['id_auteur']);
1044                        }
1045                        $forums_struct = array();
1046
1047                        $where[] = 'forums.statut="publie"';
1048                               
1049                        if($forums = sql_select($what,$from,$where,array(),$order,$args['limite'])){
1050                                while($forum = sql_fetch($forums)){
1051                                        $struct=array();
1052                                        $args['id_forum'] = $forum['id_forum'];
1053                                        /**
1054                                         * On utilise la fonction lire_forum pour éviter de dupliquer trop de code
1055                                         */
1056                                        $struct = $this->spip_lire_forum($args);
1057                                        $forums_struct[] = $struct;
1058                                }
1059                        }
1060                        return $forums_struct;
1061                }
1062        }
1063
1064        /**
1065         * On lance le serveur
1066         */
1067        pipeline('xmlrpc_server_class');
1068        $server = $GLOBALS['spip_xmlrpc_serveur'] = new spip_xmlrpc_server();
1069        $server->serve_request();
1070}
1071?>
Note: See TracBrowser for help on using the repository browser.