source: spip-zone/_plugins_/spip-listes/spip-listes_1_9_3/inc/spiplistes_api.php @ 30253

Last change on this file since 30253 was 30253, checked in by gilles.vincent@…, 12 years ago

[30252] suite : split est deprecie en 5.3.0

  • Property svn:keywords set to LastChangedBy LastChangedDate LastChangedRevision
File size: 37.5 KB
Line 
1<?php
2
3// inc/spiplistes_api.php
4
5/******************************************************************************************/
6/* SPIP-Listes est un systeme de gestion de listes d'abonnes et d'envoi d'information     */
7/* par email pour SPIP. http://bloog.net/spip-listes                                      */
8/* Copyright (C) 2004 Vincent CARON  v.caron<at>laposte.net                               */
9/*                                                                                        */
10/* Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes */
11/* de la Licence Publique Generale GNU publiee par la Free Software Foundation            */
12/* (version 2).                                                                           */
13/*                                                                                        */
14/* Ce programme est distribue car potentiellement utile, mais SANS AUCUNE GARANTIE,       */
15/* ni explicite ni implicite, y compris les garanties de commercialisation ou             */
16/* d'adaptation dans un but specifique. Reportez-vous a la Licence Publique Generale GNU  */
17/* pour plus de details.                                                                  */
18/*                                                                                        */
19/* Vous devez avoir recu une copie de la Licence Publique Generale GNU                    */
20/* en meme temps que ce programme ; si ce n'est pas le cas, ecrivez a la                  */
21/* Free Software Foundation,                                                              */
22/* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, Etats-Unis.                   */
23/******************************************************************************************/
24
25// $LastChangedRevision: 30253 $
26// $LastChangedBy: gilles.vincent@gmail.com $
27// $LastChangedDate: 2009-07-27 03:26:42 +0000 (Mon, 27 Jul 2009) $
28
29if (!defined("_ECRIRE_INC_VERSION")) return;
30
31include_spip ("inc/utils");
32include_spip ("inc/filtres");    /* email_valide() */
33include_spip ("inc/acces");      /* creer_uniqid() */
34include_spip('inc/charsets');
35
36include_spip('base/abstract_sql');
37
38include_spip('inc/spiplistes_api_abstract_sql');
39include_spip('inc/spiplistes_api_globales');
40
41/**
42 * Fonction de compatibilite de php4 / php5 pour http_build_query
43 *
44 * @return un query string a passer a une url
45 * @param object $data un array de contexte
46 * @param object $prefix[optional]
47 * @param object $sep[optional]
48 * @param object $key[optional]
49 */
50function spiplistes_http_build_query($data,$prefix=null,$sep='',$key=''){
51        if(!function_exists('http_build_query')) {
52            function http_build_query($data,$prefix=null,$sep='',$key='') {
53                $ret = array();
54                    foreach((array)$data as $k => $v) {
55                        $k    = urlencode($k);
56                        if(is_int($k) && $prefix != null) {
57                            $k    = $prefix.$k;
58                        };
59                        if(!empty($key)) {
60                            $k    = $key."[".$k."]";
61                        };
62       
63                        if(is_array($v) || is_object($v)) {
64                            array_push($ret,http_build_query($v,"",$sep,$k));
65                        }
66                        else {
67                            array_push($ret,$k."=".urlencode($v));
68                        };
69                    };
70       
71                if(empty($sep)) {
72                    $sep = ini_get("arg_separator.output");
73                };
74                return implode($sep, $ret);
75            };
76        };
77        return http_build_query($data);
78}
79
80/* function privee
81 * multi_queries mysql n'est pas en mesure de le faire en natif :-(
82 * A tranformer le jour ou mysql gerera correctement le multi_query
83 * Et a transformer en transanction quand spip utilisera innodb ou autre table transactionnelle
84 * @param $queries : requetes separees par des ';'
85 */
86function __exec_multi_queries($queries) {
87        $queries = trim($queries);
88        if (substr($queries, -1, 1) == ';') {
89                $queries = substr($queries, 0, strlen($queries)-1);
90        }
91        $_queries = explode(';', $queries);
92        while( list(,$val) = each($_queries)) {
93                $res = spip_query($val);
94        }
95        return $res;
96}
97
98//CP-20080508: renvoie OK ou ERR entre crochet
99// sert principalement pour les log
100function spiplistes_str_ok_error ($statut) {
101        return("[".(($statut != false) ? "OK" : "ERR")."]");
102}
103
104//
105function spiplistes_singulier_pluriel_str_get ($var, $str_sing, $str_plur, $returnvar = true) {
106        $result = "";
107        if($var) {
108                $result = (($returnvar) ? $var : "") . " " . (($var > 1) ? $str_plur : $str_sing);
109        }
110        return($result);
111}
112
113//CP-20080508
114function spiplistes_sql_compter ($table, $sql_whereq) {
115        $sql_result = intval(sql_countsel($table, $sql_whereq));
116        return($sql_result);
117}
118
119// CP-20080511
120function spiplistes_courriers_statut_compter ($statut='tous') {
121        $sql_where = spiplistes_listes_sql_where_or(
122                ($statut == 'tous')
123                ? _SPIPLISTES_COURRIERS_STATUTS
124                : $statut
125                );
126        return(spiplistes_sql_compter('spip_courriers', $sql_where));
127}
128
129// CP-20080510
130function spiplistes_courriers_casier_premier ($sql_select, $sql_whereq) {
131        return(sql_select(
132                        $sql_select, "spip_courriers", $sql_whereq." LIMIT 1"
133                )
134        );
135}
136
137//CP-20080520
138// Les fonctions spiplistes_abonnements_*() concernent les abonnements
139// Table cible : spip_auteurs_listes
140
141// CP-20080324 : abonner un id_auteur a une id_liste
142// CP-20080508 : ou une liste de listes ($id_liste est un tableau de (id)listes)
143// CP-20090111: ajouter la date d'inscription
144/*
145 * @return array id_listes ajoutees
146 */
147function spiplistes_abonnements_ajouter ($id_auteur, $id_liste) {
148       
149        $r_id_listes = false;
150       
151        if(($id_auteur = intval($id_auteur)) > 0) {
152                $sql_table = "spip_auteurs_listes";
153                $sql_noms = "(id_auteur,id_liste,date_inscription)";
154               
155                $curr_abos_auteur = spiplistes_abonnements_listes_auteur($id_auteur);
156                $r_id_listes = array();
157               
158                if(is_array($id_liste)) {
159                        $sql_valeurs = array();
160                        $msg = array();
161                        foreach($id_liste as $id) {
162                                if(
163                                   (($id = intval($id)) > 0)
164                                        && !in_array($id, $curr_abos_auteur)
165                                  )
166                                {
167                                        $sql_valeurs[] = "($id_auteur,$id,NOW())";
168                                        $msg[] = $id;
169                                }
170                        }
171                        if(count($sql_valeurs)) {
172                                $sql_valeurs = implode(",", $sql_valeurs);
173                        }
174                }
175                else if(
176                        (($id_liste = intval($id_liste)) > 0)
177                        && (!$curr_abos || !in_array($id_liste, $curr_abos))
178                        )
179                {
180                        $sql_valeurs = " ($id_auteur,$id_liste,NOW())";
181                        $msg = array($id_liste);
182                        $r_id_listes[] = $id_liste;
183                }
184                if($sql_valeurs) {
185                        $msg = "#" . implode(",#", $msg);
186                        if(sql_insert($sql_table, $sql_noms, $sql_valeurs) === false) {
187                                spiplistes_sqlerror_log ("spiplistes_abonnements_ajouter()");
188                        }
189                        else {
190                                spiplistes_log_api("subscribe id_auteur #$id_auteur to id_liste $msg");
191                        }
192                }
193        }
194        return($r_id_listes);
195}
196
197// desabonner des listes (CP-20071016)
198// $listes_statuts : array (statuts des listes,..)
199function spiplistes_abonnements_desabonner_statut ($id_auteur, $listes_statuts) {
200        if(($id_auteur = intval($id_auteur)) && count($listes_statuts)) {
201                $sql_where = "statut=".implode(" OR statut=", array_map("sql_quote", $listes_statuts));
202                $sql_result = sql_select("id_liste", "spip_listes", $sql_where);
203                $listes = array();
204                while($row = sql_fetch($sql_result)) {
205                        $listes[] = intval($row['id_liste']);
206                }
207                if(count($listes)) {
208                        $sql_where = " id_auteur=".sql_quote($id_auteur)." AND id_liste IN (" . implode(",", $listes) . ")";
209                        sql_delete("spip_auteurs_listes", $sql_where);
210                }
211                return(spiplistes_format_abo_modifier($id_auteur));
212        }
213        return(false);
214}
215
216
217//CP-20080512 : supprimer des abonnes de la table des abonnements
218function spiplistes_abonnements_auteurs_supprimer ($auteur_statut) {
219        $auteur_statut = "statut=".sql_quote($auteur_statut);
220        if(spiplistes_spip_est_inferieur_193()) { 
221                $result = sql_delete("spip_auteurs_listes", 
222                                        "id_auteur IN (SELECT id_auteur FROM spip_auteurs WHERE $auteur_statut)");
223        } else {
224                // Sur les precieux conseils de MM :
225                // passer la requete en 2 etapes pour assurer portabilite sql
226                $selection =
227                        sql_select("id_auteur", "spip_auteurs", $auteur_statut,'','','','','',false);
228                $sql_result = sql_delete("spip_auteurs_listes", "id_auteur IN ($selection)");
229                if ($sql_result === false) {
230                        spiplistes_sqlerror_log("abonnements_auteurs_supprimer");
231                }
232        }
233        return($result);
234}
235
236/*
237 * CP-20080330 : renvoie la liste des abonnements pour id_auteur
238 * @return tableau d'id_listes. La valeur est titre si $avec_titre true, sinon id_liste
239 * @param $id_auteur int
240 * @param $avec_titre bool
241 */
242function spiplistes_abonnements_listes_auteur ($id_auteur, $avec_titre = false) {
243        $result = array();
244        $sql_select = array("abo.id_liste");
245        $sql_from = array("spip_auteurs_listes AS abo");
246        $sql_where = array();
247        if($avec_titre) {
248                $sql_select[] = "list.titre";
249                $sql_from[] = "spip_listes AS list";
250                $sql_where[] = "abo.id_liste=list.id_liste";
251        }
252        $sql_where[] = "abo.id_auteur=".sql_quote($id_auteur);
253        $sql_result = sql_select (
254                $sql_select
255                , $sql_from
256                , $sql_where
257                );
258        if ($sql_result === false) {
259                spiplistes_sqlerror_log("spiplistes_abonnements_listes_auteur");
260        }
261        else {
262                while ($row = sql_fetch($sql_result)) {
263                        $result[$row['id_liste']] = ($avec_titre ? $row['titre'] : $row['id_liste']);
264                }
265        }
266        return($result);
267}
268
269// CP-20080324 : desabonner un id_auteur d'une id_liste
270// CP-20080508 : ou de toutes les listes si $id_liste = 'toutes'
271// CP-20090111: ou tous les abonnes si id_auteur == 'tous'
272// CP-20090410: ou une serie si array
273function spiplistes_abonnements_auteur_desabonner ($id_auteur, $id_liste = false) {
274        $result = false;
275        $msg1 = $msg2 = "";
276        $sql_where = array();
277        if($id_auteur == 'tous') {
278                $sql_where[] = "id_auteur>0";
279                $msg1 = $id_auteur;
280        }
281        else if(is_array($id_auteur)) {
282                $ii = implode(",", $id_auteur);
283                $sql_where[] = "id_auteur IN ($ii)";
284                $msg1 = "id_auteur #$ii";
285        }
286        else if(($id_auteur = intval($id_auteur)) > 0) {
287                $sql_where[] = "id_auteur=$id_auteur";
288                $msg1 = "id_auteur #$id_auteur";
289        }
290        if(count($sql_where)) {
291                $sql_table = "spip_auteurs_listes";
292                if($id_liste == "toutes") {
293                        $msg2 = " des listes";
294                } else if(($id_liste = intval($id_liste)) > 0) {
295                        $sql_where[] = "id_liste=$id_liste";
296                        $msg2 = " de la liste #$id_liste";
297                }
298                if(($result = sql_delete($sql_table, $sql_where)) === false) {
299                        spiplistes_sqlerror_log("abonnements_auteur_desabonner()");
300                }
301                else {
302                        spiplistes_log_api("desabonne $msg1 $msg2");
303                }
304        }
305        return($result);
306}
307
308//CP-20080512 : supprimer des abonnements
309function spiplistes_abonnements_supprimer ($sql_whereq) {
310        return(sql_delete('spip_auteurs_listes', $sql_whereq));
311}
312
313
314//CP-20080508 : dans la table des abonnements
315function spiplistes_abonnements_compter ($sql_whereq = "") {
316        return(spiplistes_sql_compter("spip_auteurs_listes", $sql_whereq));
317}
318
319/*
320 * Compter les abonnements qui n'ont plus d'abonnes
321 * @return array id_auteur
322 */
323function spiplistes_abonnements_zombies () {
324        // SELECT id_auteur FROM spip_auteurs_listes WHERE id_auteur
325        //      IN (SELECT id_auteur FROM spip_auteurs WHERE statut='5poubelle')
326        $sql_select = "id_auteur";
327        $sql_from = "spip_auteurs";
328        $sql_where = "statut=".sql_quote('5poubelle');
329        $selection = 
330                (spiplistes_spip_est_inferieur_193())
331                ? "SELECT $sql_select FROM $sql_from WHERE $sql_where"
332                : sql_select($sql_select, $sql_from, $sql_where,'','','','','',false)
333                ;
334        $sql_from = "spip_auteurs_listes";
335        $sql_result = sql_select(
336                $sql_select
337                , $sql_from
338                , "$sql_select IN (".$selection.")"
339                );
340        if($sql_result === false) {
341                spiplistes_sqlerror_log("spiplistes_abonnements_zombies");
342        }
343        $result = array();
344        while($row = sql_fetch($sql_result)) {
345                $result[] = $row[$sql_select];
346        }
347        return($result);
348
349}
350
351//CP-20080520
352// Les fonctions spiplistes_listes_*() concernent les listes
353// Table cible : spip_listes
354
355//CP-20080508 : dans la table des listes
356function spiplistes_listes_compter ($sql_whereq = "") {
357        return(spiplistes_sql_compter("spip_listes", $sql_whereq));
358}
359
360//CP-20081228
361//Donner le nombre d'abonnés (pour une liste)
362//qui ont un vrai format de réception (html ou texte)
363// et une adresse mail valide
364function spiplistes_listes_vrais_abos_compter ($id_liste) {
365        if($id_liste = intval($id_liste)) {
366                // SELECT COUNT(l.id_auteur) AS nb
367                // FROM spip_auteurs_listes AS l, spip_auteurs_elargis AS f, spip_auteurs AS a
368                // WHERE l.id_liste=$id_liste
369                //      AND l.id_auteur=f.id_auteur
370                //      AND (l.id_auteur=a.id_auteur AND LENGTH(a.email) > 3)
371                //      AND (f.`spip_listes_format`='html' OR f.`spip_listes_format`='texte')
372                $sql_select = array('COUNT(l.id_auteur) AS nb');
373                $sql_from = array('spip_auteurs_listes AS l', 'spip_auteurs_elargis AS f', 'spip_auteurs AS a');
374                $sql_where = array(
375                        "l.id_liste=$id_liste"
376                        , "l.id_auteur=f.id_auteur"
377                        , "(l.id_auteur=a.id_auteur AND LENGTH(a.email) > 3)"
378                        , "(f.`spip_listes_format`='html' OR f.`spip_listes_format`='texte')"
379                        );
380                $sql_result = sql_select($sql_select, $sql_from, $sql_where);
381                if($sql_result === false) {
382                        spiplistes_sqlerror_log("spiplistes_listes_vrais_abos_compter()");
383                }
384                if($row = sql_fetch($sql_result)) {
385                        $result = $row['nb'];
386                }
387        }
388        return($result);
389}
390
391// CP-20080501
392function spiplistes_listes_liste_modifier ($id_liste, $array_set) {
393        return(
394                sql_update(
395                        'spip_listes'
396                        , $array_set
397                        , "id_liste=".sql_quote($id_liste)." LIMIT 1"
398                )
399        );
400}
401
402// CP-20080501
403function spiplistes_listes_liste_supprimer ($id_liste) {
404        $sql_where = "id_liste=".sql_quote(intval($id_liste));
405        return(
406                sql_delete('spip_listes', $sql_where." LIMIT 1")
407                && spiplistes_mod_listes_supprimer("tous", $id_liste)
408                && sql_delete('spip_auteurs_listes', $sql_where)
409        );
410}
411
412//CP-20080512
413function spiplistes_listes_liste_creer ($statut, $lang, $titre, $texte, $pied_page) {
414        global $connect_id_auteur;
415
416        if($id_liste = sql_insertq('spip_listes', array(
417                          'statut' => $statut
418                        , 'lang' => $lang
419                        , 'titre' => $titre
420                        , 'texte' => $texte
421                        , 'pied_page' => $pied_page
422                        )
423                )
424        ) { 
425                $id_liste = intval($id_liste);
426                $id_auteur = intval($connect_id_auteur);
427                spiplistes_mod_listes_supprimer("tous", $id_liste);
428                spiplistes_mod_listes_ajouter($id_auteur, $id_liste);
429                spiplistes_abonnements_auteur_desabonner("tous", $id_liste);
430                spiplistes_abonnements_ajouter($id_auteur, $id_liste);
431                return($id_liste);
432        }
433        return(false);
434}
435
436//CP-20080602
437// renvoie tableau de id_auteurs abonnes a une liste
438function spiplistes_listes_liste_abo_ids ($id_liste) {
439        $sql_result = sql_select('id_auteur', 'spip_auteurs_listes', "id_liste=".sql_quote($id_liste), '', array('id_auteur'));
440        $ids_abos = array();
441        while($row = sql_fetch($sql_result)) {
442                $ids_abos[] = intval($row['id_auteur']);
443        }
444        return($ids_abos);
445}
446
447// retourne nombre d'abonnes a une liste
448// si $preciser, renvoie tableau total et formats
449function spiplistes_listes_nb_abonnes_compter ($id_liste = 0, $preciser = false) {
450        $id_liste = intval($id_liste);
451        $sql_whereq = (($id_liste > 0) ? "id_liste=".sql_quote($id_liste) : "");
452        $total = spiplistes_sql_compter ("spip_auteurs_listes", $sql_whereq);
453        if($preciser) {
454                $selection = 
455                        (spiplistes_spip_est_inferieur_193())
456                        ? "SELECT id_auteur FROM spip_auteurs_listes " . (!empty($sql_whereq) ? "WHERE  $sql_whereq" : "")
457                        : sql_select("id_auteur", "spip_auteurs_listes", $sql_whereq,'','','','','',false)
458                        ;
459                $sql_result = sql_select(
460                        "`spip_listes_format` AS f, COUNT(*) AS n"
461                        , "spip_auteurs_elargis"
462                        , "id_auteur IN (".$selection.")"
463                        , "`spip_listes_format`");
464                if( $sql_result === false) {
465                        spiplistes_sqlerror_log("listes_nb_abonnes_compter");
466                }
467                $formats = array('html' => 0, 'texte' => 0);
468                $keys = array_keys($formats);
469                while($row = sql_fetch($sql_result)) {
470                        if(in_array($row['f'], $keys)) {
471                                $formats[$row['f']] += $row['n'];
472                        }
473                }
474                return(array($total, $formats['html'], $formats['texte']));
475        }
476        return($total);
477}
478
479function spiplistes_desabonner_auteur ($id_auteur) {
480       
481}
482
483//CP-20080509: renvoie email emetteur d'une liste
484function spiplistes_listes_email_emetteur ($id_liste = 0) {
485        $id_liste = intval($id_liste);
486        if($id_liste > 0) {
487                $result = 
488                        sql_getfetsel(
489                                "email_envoi"
490                                , "spip_listes"
491                                , "id_liste=".sql_quote($id_liste)." LIMIT 1"
492                        );
493                if($result === false) {
494                        spiplistes_sqlerror_log("listes_email_emetteur");
495                }
496        }
497        // si pas d'adresse moderateur, va chercher adresse par defaut
498        if(!$result || empty($result)) {
499                $result = spiplistes_email_from_default();
500        }
501        return($result);
502}
503
504//CP-20080511
505function spiplistes_listes_liste_fetsel ($id_liste, $keys = "*") {
506        $id_liste = intval($id_liste);
507        return(sql_fetsel($keys, "spip_listes", "id_liste=".sql_quote($id_liste)." LIMIT 1"));
508}
509
510//CP-20081116
511function spiplistes_listes_liste_statut ($id_liste) {
512        return(spiplistes_listes_liste_fetsel($id_liste, 'statut'));
513}
514
515// CP-20080505 : renvoie array sql_where des listes publiees
516function spiplistes_listes_sql_where_or ($listes) {
517        return("statut=".implode(" OR statut=", array_map("sql_quote", explode(";", $listes))));
518}
519
520//taille d'une chaine sans saut de lignes ni espaces ni punct
521function spiplistes_strlen($out){
522        $out = preg_replace("/([[:space:]]|[[:punct:]])+/", "", $out);
523        return (strlen($out));
524}
525
526//CP-20080508 : dans la queue d'envoi des courriers
527function spiplistes_courriers_en_queue_compter ($sql_whereq = "") {
528        // demande le nombre de courriers dans la queue
529        // avec etat vide (si etat non vide,
530        // c'est que la meleuse est en train de l'envoyer)
531        return(spiplistes_sql_compter("spip_auteurs_courriers", $sql_whereq));
532}
533
534// CP-20080510
535function spiplistes_courriers_en_queue_modifier ($array_set, $sql_whereq) {
536        return(
537                sql_update(
538                        'spip_auteurs_courriers'
539                        , $array_set
540                        , $sql_whereq
541                )
542        );
543}
544
545// CP-20080510
546function spiplistes_courriers_en_queue_supprimer ($sql_whereq) {
547        if(($result = sql_delete('spip_auteurs_courriers', $sql_whereq)) === false) {
548                spiplistes_sqlerror_log("courriers_en_queue_supprimer");
549        }
550        return($result);
551}
552
553// CP-20080621
554// la premiere etiquette sur le tas
555function spiplistes_courriers_en_queue_premier ($select, $where) {
556        return(
557                sql_getfetsel(
558                                  $select
559                                , 'spip_auteurs_courriers'
560                                , $where
561                                , '', '', 1
562                        )
563        );
564}
565
566//CP-20080512
567// Les fonctions spiplistes_format_abo_*() concernent les formats de reception des abos
568// Table cible : spip_auteurs_elargis
569
570
571// suspend les abonnements d'un compte
572function spiplistes_format_abo_suspendre ($id_auteur) {
573        return(spiplistes_format_abo_modifier($id_auteur));
574}
575
576//CP2008111 supprimer le format d'un id_auteur
577// CP-20090111: si $id_auteur == 'tous', supprimer tous les formats
578function spiplistes_format_abo_supprimer ($id_auteur) {
579        $sql_table = "spip_auteurs_elargis";
580        if(($id_auteur = intval($id_auteur)) > 0) {
581                $sql_where = "id_auteur=$id_auteur";
582                $msg = "id_auteur #$id_auteur";
583        }
584        else if ($id_auteur == 'tous') {
585                $sql_where = "id_auteur>0";
586                $msg = "ALL";
587        }
588        if($sql_where) {
589                if(($result = sql_delete("spip_auteurs_elargis", $sql_where)) === false) {
590                        spiplistes_sqlerror_log("format_abo_supprimer()");
591                }
592                else {
593                        spiplistes_log_api("delete format for $msg");
594                }
595        }
596        return($result);
597}
598
599
600// modifier le format abonne
601// si id_auteur, celui-ci uniquement
602// sinon, 'tous' pour modifier globalement (uniquement ceux ayant deja un format)
603function spiplistes_format_abo_modifier ($id_auteur, $format = 'non') {
604
605        if($format = spiplistes_format_valide($format)) {
606                $sql_table = "spip_auteurs_elargis";
607                $sql_champs = array('`spip_listes_format`' => sql_quote($format));
608                if($id_auteur == 'tous') {
609                        // appliquer le meme format a tous les abos
610                        $sql_result = sql_update($sql_table, $sql_champs, 1);
611                        $action = "update";
612                }
613                else if(($id_auteur = intval($id_auteur)) > 0) {
614                        if(($cur_format = spiplistes_format_abo_demande($id_auteur)) !== false) {
615                                // si pas d'erreur sql
616                                if(!$cur_format) {
617                                        // si inexistant faire un insert
618                                        $sql_champs = array(
619                                                'id_auteur' => $id_auteur
620                                                , '`spip_listes_format`' => $format
621                                        );
622                                        $sql_result = sql_insertq($sql_table, $sql_champs);
623                                        $action = "insert";
624                                } else {
625                                        // sinon update
626                                        $sql_where = "id_auteur=".sql_quote($id_auteur)." LIMIT 1"; 
627                                        $sql_result = sql_update($sql_table, $sql_champs, $sql_where);
628                                        $action = "update";
629                                }
630                        }
631                }
632                if($sql_result === false) {
633                        spiplistes_sqlerror_log("spiplistes_format_abo_modifier() $action $id_auteur");
634                }
635                else {
636                        $id_auteur = ($id_auteur == 'tous') ? "ALL" :  "id_auteur #$id_auteur";
637                        spiplistes_log_api("$action format $format to $id_auteur");
638                }
639        }
640        return($sql_result);
641}
642
643// renvoie le format d'abonnement d'un auteur
644function spiplistes_format_abo_demande ($id_auteur) {
645        $id_auteur = intval($id_auteur);
646        $result = false;
647        $sql_where = "id_auteur=".sql_quote($id_auteur);
648        if($id_auteur > 0) {
649                if(!spiplistes_spip_est_inferieur_193()) {
650                        $result = sql_getfetsel("`spip_listes_format`", "spip_auteurs_elargis", $sql_where, '', '', 1);
651                } else {
652                        /*
653                        $result = sql_fetsel("`spip_listes_format` AS format", "spip_auteurs_elargis", $sql_where);
654                        $result = $result['format'];
655                        */
656                        if(($sql_result = sql_select("`spip_listes_format` AS format", "spip_auteurs_elargis", $sql_where, '', '', 1)) !== false) {
657                                $row = sql_fetch($sql_result);
658                                $result = $row['format'];
659                                spiplistes_log_api("current format for id_auteur #$id_auteur = $result ($sql_where)");
660                        }
661                        else {
662                                spiplistes_sqlerror_log("spiplistes_format_abo_demande()");
663                        }
664                }
665                /* Code a valider. Si ok, supprimer ci-dessus.
666                $GLOBALS['mysql_rappel_nom_base'] = false;
667                $result = sql_getfetsel("spip_listes_format", "spip_auteurs_elargis", "id_auteur=".sql_quote($id_auteur));
668                $result = spiplistes_format_valide($result);
669                /**/
670        }
671        return($result);
672}
673
674/*
675 * CP-20090111
676 * liste des formats autorises
677 * @return
678 *      ($idx == 'array') array (index et sa valeur identique)
679 *      ($idx == 'quoted') la valeur est sql_quote'
680 *      ($idx == 'sql_where') string ligne sql_where formatee avec OR
681 * @param $idx string[optional]
682 */
683function spiplistes_formats_autorises ($idx = 'array') {
684        static $formats;
685        if(!$formats) {
686                $ii = explode(";", _SPIPLISTES_FORMATS_ALLOWED);
687                $formats = array('array' => array_combine($ii, $ii));
688                $formats['quoted'] = array_map("sql_quote", $formats['array']);
689                $formats['sql_where'] = "(`spip_listes_format`=" . implode(" OR `spip_listes_format`=", $formats['quoted']).")";
690        }
691        return($formats[$idx]);
692}
693
694//CP-20080512
695// Les fonctions spiplistes_mod_listes_*() concernent les abonnements
696// Table cible : spip_auteurs_mod_listes
697
698// renvoie ID du moderateur de la liste
699// CP-20080608 : ou de toutes les listes si $id_liste = 'toutes'
700// -> result du style: array[id_liste] => array(id_auteur, ...)
701function spiplistes_mod_listes_get_id_auteur ($id_liste) {
702        $sql_from = 'spip_auteurs_mod_listes';
703        $sql_where = 
704                ($id_liste == "toutes")
705                ? ""
706                : "id_liste=".sql_quote(intval($id_liste))
707                ;
708        if($sql_result = sql_select("*", $sql_from, $sql_where)) {
709                $result = array();
710                while($row = sql_fetch($sql_result)) {
711                        $ii = $row['id_liste'];
712                        if(!isset($result[$ii])) {
713                                $result[$ii] = array();
714                        }
715                        $result[$ii][] = $row['id_auteur'];
716                }
717                return($result);
718        }
719        return(false);
720}
721
722// CP-20080503: supprime un ou + moderateurs d'une liste
723// CP-20090111: ou tous les moderateurs si $id_auteur == 'tous'
724function spiplistes_mod_listes_supprimer ($id_auteur, $id_liste) {
725        if(($id_auteur = intval($id_auteur)) > 0) {
726                $sql_where = array("id_auteur=$id_auteur");
727                $msg = "id_auteur #$id_auteur";
728        } else if($id_auteur == "tous") {
729                $sql_where = array("id_auteur>0");
730                $msg = "ALL";
731        }
732        if($sql_where && (($id_liste = intval($id_liste)) > 0)) {
733                $sql_where[] = "id_liste=$id_liste";
734                if(($result = sql_delete('spip_auteurs_mod_listes', $sql_where)) !== false) {
735                        spiplistes_log_api("delete moderator #$id_auteur from id_liste #$id_liste");
736                }
737                else {
738                        spiplistes_sqlerror_log("mod_listes_supprimer()");
739                }
740        }
741        return($result);
742}
743
744//CP-20080512
745function spiplistes_mod_listes_ajouter ($id_auteur, $id_liste) {
746        if(($id_liste = intval($id_liste)) > 0) {
747                $result =
748                        sql_insertq('spip_auteurs_mod_listes'
749                                , array(
750                                          'id_auteur' => $id_auteur
751                                        , 'id_liste' => $id_liste
752                                        )
753                        );
754                if($result !== false) {
755                        spiplistes_log_api("insert moderator id_auteur #$id_auteur to id_liste #$id_liste");
756                }
757                else {
758                        spiplistes_sqlerror_log("mod_listes_ajouter");
759                }
760        }
761        return($result);
762}
763
764//CP-2080610
765function spiplistes_mod_listes_compter ($id_liste) {
766        $n = sql_fetch(sql_select("COUNT(*) AS n", "spip_auteurs_mod_listes", "id_liste=".sql_quote($id_liste)));
767        return(($n && $n['n']) ? $n['n'] : false);
768}
769
770//CP-20080620
771// renvoie tableau id_liste des listes moderees par l'auteur
772function spiplistes_mod_listes_id_auteur ($id_auteur) {
773        $result = false;
774        if($sql_result = sql_select('id_liste', 'spip_auteurs_mod_listes', 'id_auteur='.sql_quote($id_auteur))) {
775                $result = array();
776                while($row = sql_fetch($sql_result)) {
777                        $result[] = $row['id_liste'];
778                }
779        }
780        else if($sql_result === false) {
781                spiplistes_sqlerror_log("mod_listes_id_auteur");
782        }
783        return($result);
784}
785
786//function spiplistes_texte_propre($texte)
787// passe propre() sur un texte puis nettoie les trucs rajoutes par spip sur du html
788//      Remplace spiplistes_courrier_propre() qui est a supprimer apres verif.
789function spiplistes_texte_propre($texte){
790        $temp_style = ereg("<style[^>]*>[^<]*</style>", $texte, $style_reg);
791        if (isset($style_reg[0])) 
792                $style_str = $style_reg[0]; 
793        else 
794                $style_str = "";
795        $texte = ereg_replace("<style[^>]*>[^<]*</style>", "__STYLE__", $texte);
796        //passer propre si y'a pas de html (balises fermantes)
797        if( !preg_match(',</?('._BALISES_BLOCS.')[>[:space:]],iS', $texte) ) 
798        $texte = propre($texte); // pb: enleve aussi <style>... 
799       
800        // Corrections complementaires
801        $patterns = array();
802        $replacements = array();
803        // html
804        $patterns[] = "#<br>#i";
805        $replacements[] = "<br />";
806        $patterns[] = "#<b>([^<]*)</b>#i";
807        $replacements[] = '<strong>\\1</strong>';
808        $patterns[] = "#<i>([^<]*)</i>#i";
809        $replacements[] = '<em>\\1</em>';
810        // spip class
811        $patterns[] = "# class=\"spip\"#";
812        $replacements[] = "";   
813       
814        $texte = preg_replace($patterns, $replacements, $texte);
815
816        $texte = ereg_replace("__STYLE__", $style_str, $texte);
817       
818        //les liens avec double debut #URL_SITE_SPIP/#URL_ARTICLE
819        $texte = ereg_replace($GLOBALS['meta']['adresse_site']."/".$GLOBALS['meta']['adresse_site'], $GLOBALS['meta']['adresse_site'], $texte);
820        $texte = liens_absolus($texte);
821       
822        return ($texte);
823}
824
825function spiplistes_titre_propre($titre){
826        $titre = spiplistes_texte_propre($titre);
827        $titre = substr($titre, 0, 128); // Au cas ou copie/colle
828        return($titre);
829}
830
831/*
832 * CP-20081128
833 * Recherche les différentes versions de patron possibles
834 * <patron>._texte.en patron texte anglais
835 * <patron>._texte patron texte generique
836 * <patron>.en patron anglais
837 * <patron> patron generique
838 * @return string le chemin du patron si patron trouve' ou FALSE si non trouve'
839 * @param $path_patron string
840 * @param $lang string
841 * @param $chercher_texte bool si TRUE, chercher la version texte du patron
842 * @todo verifier presence de lang dans les appels a cette fonction
843 */
844function spiplistes_patron_find_in_path ($path_patron, $lang, $chercher_texte = false) {
845        static $t = "_texte", $h = ".html";
846       
847        if(!$lang) {
848                $lang = $GLOBALS['spip_lang'];
849        }
850       
851        if(
852                $chercher_texte 
853                && (find_in_path($path_patron . $t . "." . $lang . $h) || find_in_path($path_patron . $t . $h))
854        ) {
855                return($path_patron . $t);
856        }
857        else if(find_in_path($path_patron . "." . $lang . $h) || find_in_path($path_patron . $h)) {
858                return($path_patron);
859       
860        }
861        return(false);
862}
863
864
865/*
866 * CP-20090427
867 * Assembler/calculer un patron
868 * @return array le resultat html et texte seul dans un tableau
869 * @param $patron string nom du patron
870 * @param $contexte array
871 */
872function spiplistes_assembler_patron ($path_patron, $contexte) {
873
874        include_spip('inc/distant');
875       
876        $patron_html = spiplistes_patron_find_in_path($path_patron, $contexte['lang'], false);
877        $contexte['patron_html'] = $patron_html;
878        // le resultat assemble' au format html
879        $result_html = 
880                $patron_html
881                // ? recuperer_fond($patron_html, $contexte)
882                ? recuperer_page(generer_url_public('patron_switch')."&".spiplistes_http_build_query($contexte,"","&"),true)
883                : ""
884                ;
885               
886        // chercher si un patron version texte existe
887        $patron_texte = spiplistes_patron_find_in_path($path_patron, $contexte['lang'], true);
888        unset($contexte['patron_html']);
889        $contexte['patron_texte'] = $patron_texte;
890        $result_texte = 
891                ($patron_texte && ($patron_html != $patron_texte))
892                // ? recuperer_fond($patron_texte, $contexte) . "\n"
893                ? recuperer_page(generer_url_public('patron_switch')."&".spiplistes_http_build_query($contexte,"","&"),true)
894                : spiplistes_courrier_version_texte($message_html) . "\n"
895                ;
896               
897        $result = array($result_html, $result_texte);
898       
899        return($result);
900}
901
902/* donne contenu tampon au format html (CP-20071013) et texte
903 * @return array (string $html, string $texte)
904 */
905function spiplistes_tampon_assembler_patron () {
906        spiplistes_log_api("calculer tampon");
907        $contexte = array();
908        $path_patron = spiplistes_pref_lire('tampon_patron');
909        spiplistes_log_api($path_patron);
910        if(!empty($path_patron))
911        {
912                foreach(explode(",", _SPIPLISTES_TAMPON_CLES) as $key) {
913                        $contexte[$key] = spiplistes_pref_lire($key);
914                }
915                $result = spiplistes_assembler_patron(_SPIPLISTES_PATRONS_TAMPON_DIR . $path_patron, $contexte);
916        }
917        else {
918                $result = array("", "");
919        }
920        return($result);
921}
922
923function spiplistes_pied_page_assembler_patron ($id_liste, $lang = false) {
924       
925        $result = array("", "");
926       
927        if(($id_liste = intval($id_liste)) > 0)
928        {
929                $result = sql_getfetsel('pied_page', 'spip_listes', "id_liste=".sql_quote($id_liste), '','',1);
930               
931                $pied_patron =
932                        (!$result)
933                        // si patron vide (ancienne version de SPIP-Listes ?), appliquer le patron par defaut
934                        ? _SPIPLISTES_PATRONS_PIED_DEFAUT
935                        : $result
936                        ;
937                if(strlen($pied_patron) > _SPIPLISTES_PATRON_FILENAMEMAX)
938                {
939                        // probablement le contenu du pied (SPIP-Listes <= 1.9.2 ?)
940                        // rester compatible avec les anciennes version de SPIP-Listes
941                        // qui stoquaient le patron assemble' en base
942                        $pied_texte = spiplistes_courrier_version_texte($pied_html = $pied_patron);
943                        $result = array($pied_html, $pied_texte);
944                }
945                else if(strlen($pied_patron) && ($pied_patron != _SPIPLISTES_PATRON_PIED_IGNORE)) {
946                       
947                        if(!$lang) {
948                                $lang = spiplistes_listes_langue($id_liste) || $GLOBALS['spip_lang'];
949                        }
950                        $contexte = array('lang' => $lang);
951                        $result = spiplistes_assembler_patron (
952                                _SPIPLISTES_PATRONS_PIED_DIR . $pied_patron
953                                , $contexte
954                        );
955                }
956        }
957        return ($result);
958}
959
960function spiplistes_format_valide ($format) {
961        return(in_array($format, array("non", "texte", "html")) ? $format : false);
962}
963
964//CP-20080519
965// Les fonctions spiplistes_auteurs_*() concernent les auteurs
966// Table cible : spip_auteurs
967
968// CP-20080503
969// soit update cookie du cookie transmis
970// soit update cookie de l'email transmis
971function spiplistes_auteurs_cookie_oubli_updateq ($cookie_oubli, $where, $where_is_cookie = false) {
972        if(is_string($where)) {
973                $where = (($where_is_cookie) ? "cookie_oubli" : "email")
974                        . "=" . sql_quote($where) . " LIMIT 1";
975        }
976        return(sql_update('spip_auteurs', array('cookie_oubli' => sql_quote($cookie_oubli)), $where));
977}
978
979// CP-20080629
980function spiplistes_date_heure_valide ($date_heure) {
981        $date_array = recup_date($date_heure);
982        if($date_array) {
983                list($annee, $mois, $jour) = $date_array;
984                list($heures, $minutes, $secondes) = recup_heure($date_heure);
985                return(array($annee, $mois, $jour, $heures, $minutes, $secondes));
986        }
987        return(false);
988}
989
990//CP-20080511
991function spiplistes_auteurs_auteur_select ($sql_select, $sql_where) {
992        return(sql_select($sql_select, 'spip_auteurs', $sql_where." LIMIT 1"));
993}
994
995//CP-20080511
996function spiplistes_auteurs_auteur_delete ($sql_where) {
997        // détruire ou mettre à la poubelle ?
998        // SPIP ne détruit pas lui !
999        // dans le doute...
1000        // if(($result = sql_delete('spip_auteurs', $sql_where." LIMIT 1")) === false) {
1001        if(($result = sql_update(
1002                                        "spip_auteurs"
1003                                        , array('statut' => sql_quote('5poubelle'))
1004                                        , $sql_where . " LIMIT 1"
1005                                )) === false) {
1006                spiplistes_sqlerror_log("auteurs_auteur_delete");
1007        }
1008        return($result);
1009}
1010
1011//CP-20080511
1012function spiplistes_auteurs_auteur_insertq ($champs_array) {
1013        return(sql_insertq('spip_auteurs', $champs_array));
1014}
1015
1016//CP-20090409
1017function spiplistes_auteurs_auteur_valider ($id_auteur, $as_redact = false) {
1018        if($id_auteur = intval($id_auteur)) {
1019                if(($result = sql_update(
1020                                                "spip_auteurs_listes"
1021                                                , array('statut' => sql_quote('valide'))
1022                                                , "id_auteur=$id_auteur LIMIT 1"
1023                                        )) === false) {
1024                        spiplistes_sqlerror_log("auteurs_auteur_valider");
1025                }
1026                else {
1027                       
1028                }
1029        }
1030        return($result);
1031}
1032
1033
1034//CP-20080511
1035// CP-20090111: utiliser l'api pour pouvoir envoyer par smtp si besoin
1036function spiplistes_envoyer_mail ($to, $subject, $message, $from = false, $headers = "", $format = 'texte') {
1037       
1038        static $opt_simuler_envoi;
1039
1040        // si desabo, plus de format ! donc forcer a texte
1041        $format = ($format == 'html') ? $format : 'texte';
1042       
1043        $charset = $GLOBALS['meta']['spiplistes_charset_envoi'];
1044        if(!$opt_simuler_envoi) {
1045                $opt_simuler_envoi = spiplistes_pref_lire('opt_simuler_envoi');
1046        }
1047        if(!$from) {
1048                $from = spiplistes_email_from_default();
1049        }
1050        if(strpos($from, "<") === false) {
1051                $fromname = extraire_multi($GLOBALS['meta']['nom_site']);
1052                if ($charset!=$GLOBALS['meta']['charset']){
1053                        include_spip('inc/charsets');
1054                        $fromname = unicode2charset(charset2unicode($fromname),$charset);
1055                }
1056        }
1057        $reply_to = "no-reply".preg_replace("|.*(@[a-z.]+)|i", "$1", email_valide($from));
1058       
1059        if($opt_simuler_envoi == 'oui') {
1060                spiplistes_log("!!! MAIL SIMULATION MODE !!!");
1061                $result = true;
1062        }
1063        else {
1064                include_once(_DIR_PLUGIN_SPIPLISTES.'inc/spiplistes_mail.inc.php');
1065               
1066                $email_a_envoyer = array();
1067               
1068                $return_path = spiplistes_return_path($from);
1069               
1070                if(is_array($message))
1071                {
1072                        if($format=='html' && isset($message[$format])) {
1073                                $email_a_envoyer['html'] = new phpMail($to, $subject, $message['html'], $message['texte'], $charset);
1074                                $email_a_envoyer['html']->From = $from ; 
1075                                if($fromname) $email_a_envoyer['html']->FromName = $fromname ; 
1076                                $email_a_envoyer['html']->AddCustomHeader("Errors-To: ".$return_path); 
1077                                $email_a_envoyer['html']->AddCustomHeader("Reply-To: ".$from); 
1078                                $email_a_envoyer['html']->AddCustomHeader("Return-Path: ".$return_path);       
1079                                $email_a_envoyer['html']->SMTPKeepAlive = true;
1080                                $email_a_envoyer['html']->Body = $message['html']->Body;
1081                                $email_a_envoyer['html']->AltBody = $message['html']->AltBody;
1082                        }
1083                        $message = $message['texte']->Body;
1084                }
1085                $email_a_envoyer['texte'] = new phpMail($to, $subject, '', html_entity_decode($message), $charset);
1086                $email_a_envoyer['texte']->From = $from ;
1087                if($fromname) $email_a_envoyer['html']->FromName = $fromname ; 
1088                $email_a_envoyer['texte']->AddCustomHeader("Errors-To: ".$return_path); 
1089                $email_a_envoyer['texte']->AddCustomHeader("Reply-To: ".$reply_to); 
1090                $email_a_envoyer['texte']->AddCustomHeader("Return-Path: ".$return_path); 
1091                $email_a_envoyer['texte']->SMTPKeepAlive = true;
1092               
1093                $result = $email_a_envoyer[$format]->send();
1094               
1095                $msg = "email from $from to $to";
1096                spiplistes_log(!$result ? "error: $msg not sent" : "$msg sent");
1097        }
1098        return($result);
1099}
1100
1101function spiplistes_listes_statuts_periodiques () {
1102        static $s;
1103        if($s === null) {
1104                $s = explode(";", _SPIPLISTES_LISTES_STATUTS_PERIODIQUES);
1105        }
1106        return($s);
1107}
1108
1109/*
1110 * Creation du login a partir de l email donne'
1111 * @return string or false if error
1112 * @param $mail string
1113 */
1114function spiplistes_login_from_email ($mail) {
1115       
1116        $result = false;
1117
1118        if($mail = email_valide($mail)) {
1119               
1120                // partie gauche du mail
1121                $left = substr($mail, 0, strpos($mail, "@"));
1122               
1123                // demande la liste des logins pour assurer unicite
1124                $sql_result = sql_select('login', 'spip_auteurs');
1125                $logins_base = array();
1126                while($row = sql_fetch($sql_result)) {
1127                        $logins_base[] = $row['login'];
1128                }
1129                // creation du login
1130                for ($ii = 0; $ii < _SPIPLISTES_MAX_LOGIN_NN; $ii++) {
1131                        $login = $left . (($ii > 0) ? $ii : "");
1132                        if(!in_array($login, $logins_base))
1133                        {
1134                                $result = $login;
1135                                break;
1136                        }
1137                }       
1138        }
1139        return($result);
1140}
1141
1142/*
1143*/
1144function spiplistes_listes_langue ($id_liste) {
1145        if(($id_liste = intval($id_liste)) > 0) {
1146                return(
1147                        sql_getfetsel(
1148                                'lang'
1149                                , "spip_listes"
1150                                , "id_liste=".sql_quote($id_liste)." LIMIT 1"
1151                        )
1152                );
1153        }
1154        return(false);
1155}
1156
1157/*
1158 */
1159function spiplistes_return_path ($from) {
1160        $return_path = spiplistes_pref_lire('email_return_path_defaut');
1161        if(!$return_path) {
1162                $return_path = $from;
1163        }
1164        return($return_path);
1165}
1166
1167/******************************************************************************************/
1168/* SPIP-Listes est un systeme de gestion de listes d'abonnes et d'envoi d'information     */
1169/* par email pour SPIP. http://bloog.net/spip-listes                                      */
1170/* Copyright (C) 2004 Vincent CARON  v.caron<at>laposte.net                               */
1171/*                                                                                        */
1172/* Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes */
1173/* de la Licence Publique Generale GNU publiee par la Free Software Foundation            */
1174/* (version 2).                                                                           */
1175/*                                                                                        */
1176/* Ce programme est distribue car potentiellement utile, mais SANS AUCUNE GARANTIE,       */
1177/* ni explicite ni implicite, y compris les garanties de commercialisation ou             */
1178/* d'adaptation dans un but specifique. Reportez-vous a la Licence Publique Generale GNU  */
1179/* pour plus de details.                                                                  */
1180/*                                                                                        */
1181/* Vous devez avoir recu une copie de la Licence Publique Generale GNU                    */
1182/* en meme temps que ce programme ; si ce n'est pas le cas, ecrivez a la                  */
1183/* Free Software Foundation,                                                              */
1184/* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, Etats-Unis.                   */
1185/******************************************************************************************/
1186?>
Note: See TracBrowser for help on using the repository browser.