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

Last change on this file since 48911 was 48911, checked in by paladin@…, 10 years ago

Revision du formulaire pour FORMULAIRE_SPIP_LISTES_INSCRIPTION. Il est possible de s'abonner à l'inscription/abonnement.

  • Property svn:keywords set to LastChangedBy LastChangedDate LastChangedRevision
File size: 49.9 KB
Line 
1<?php
2/**
3 * @package spiplistes
4 */
5 // $LastChangedRevision: 48911 $
6 // $LastChangedBy: paladin@quesaco.org $
7 // $LastChangedDate: 2011-06-18 18:43:26 +0000 (Sat, 18 Jun 2011) $
8
9/******************************************************************************************/
10/* SPIP-Listes est un systeme de gestion de listes d'abonnes et d'envoi d'information     */
11/* par email pour SPIP. http://bloog.net/spip-listes                                      */
12/* Copyright (C) 2004 Vincent CARON  v.caron<at>laposte.net                               */
13/*                                                                                        */
14/* Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes */
15/* de la Licence Publique Generale GNU publiee par la Free Software Foundation            */
16/* (version 2).                                                                           */
17/*                                                                                        */
18/* Ce programme est distribue car potentiellement utile, mais SANS AUCUNE GARANTIE,       */
19/* ni explicite ni implicite, y compris les garanties de commercialisation ou             */
20/* d'adaptation dans un but specifique. Reportez-vous a la Licence Publique Generale GNU  */
21/* pour plus de details.                                                                  */
22/*                                                                                        */
23/* Vous devez avoir recu une copie de la Licence Publique Generale GNU                    */
24/* en meme temps que ce programme ; si ce n'est pas le cas, ecrivez a la                  */
25/* Free Software Foundation,                                                              */
26/* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, Etats-Unis.                   */
27/******************************************************************************************/
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{
52        if(!function_exists('http_build_query')) {
53            function http_build_query($data,$prefix=null,$sep='',$key='') {
54                $ret = array();
55                    foreach((array)$data as $k => $v) {
56                        $k    = urlencode($k);
57                        if(is_int($k) && $prefix != null) {
58                            $k    = $prefix.$k;
59                        };
60                        if(!empty($key)) {
61                            $k    = $key."[".$k."]";
62                        };
63       
64                        if(is_array($v) || is_object($v)) {
65                            array_push($ret,http_build_query($v,"",$sep,$k));
66                        }
67                        else {
68                            array_push($ret,$k."=".urlencode($v));
69                        };
70                    };
71       
72                if(empty($sep)) {
73                    $sep = ini_get("arg_separator.output");
74                };
75                return implode($sep, $ret);
76            };
77        };
78        return http_build_query($data);
79}
80
81/**
82 * function privee
83 * multi_queries mysql n'est pas en mesure de le faire en natif :-(
84 * A tranformer le jour ou mysql gerera correctement le multi_query
85 * Et a transformer en transanction quand spip utilisera innodb ou autre table transactionnelle
86 * @param $queries : requetes separees par des ';'
87 */
88function __exec_multi_queries($queries) {
89        $queries = trim($queries);
90        if (substr($queries, -1, 1) == ';') {
91                $queries = substr($queries, 0, strlen($queries)-1);
92        }
93        $_queries = explode(';', $queries);
94        while( list(,$val) = each($_queries)) {
95                $res = spip_query($val);
96        }
97        return $res;
98}
99
100/**
101 * @version CP-20080508
102 * renvoie OK ou ERR entre crochet
103 * sert principalement pour les log
104 * @return string
105 */
106function spiplistes_str_ok_error ($statut) {
107        return("[".(($statut != false) ? "OK" : "ERR")."]");
108}
109
110//
111function spiplistes_singulier_pluriel_str_get ($var, $str_sing, $str_plur, $returnvar = true) {
112        $result = "";
113        if($var) {
114                $result = (($returnvar) ? $var : "") . " " . (($var > 1) ? $str_plur : $str_sing);
115        }
116        return($result);
117}
118
119/**
120 * @version CP-20080508
121 * @return int
122 */
123function spiplistes_sql_compter ($table, $sql_whereq) {
124        $sql_result = intval(sql_countsel($table, $sql_whereq));
125        return($sql_result);
126}
127
128/**
129 * @version CP-20080511
130 */
131function spiplistes_courriers_statut_compter ($statut='tous') {
132        $sql_where = spiplistes_listes_sql_where_or(
133                ($statut == 'tous')
134                ? _SPIPLISTES_COURRIERS_STATUTS
135                : $statut
136                );
137        return(spiplistes_sql_compter('spip_courriers', $sql_where));
138}
139
140
141/**
142 * Date/time du serveur SQL
143 * CP-20091207
144 * @return string|bool
145 */
146function spiplistes_sql_now ()
147{
148        if($result = sql_fetsel('NOW() as maintenant'))
149        {
150                $result = $result['maintenant'];
151        }
152        return($result);
153}
154
155/**
156 * @version CP-20080510
157 */
158function spiplistes_courriers_casier_premier ($sql_select, $sql_whereq) {
159        return(sql_select(
160                        $sql_select, "spip_courriers", $sql_whereq." LIMIT 1"
161                )
162        );
163}
164
165/**
166 ******************************************************************************
167        Les fonctions spiplistes_abonnements_*() concernent les abonnements
168       
169        Table cible : spip_auteurs_listes
170       
171 ******************************************************************************
172 */
173
174
175/**
176 * Abonner un id_auteur a une id_liste
177 * ou une liste de listes ($id_liste est un tableau de (id)listes)
178 * avec la date d'inscription
179 * @version CP-20110619
180 * @param int $id_auteur
181 * @param int|array $id_listes
182 * @return array id_listes ajoutees
183 */
184function spiplistes_abonnements_ajouter ($id_auteur, $id_listes) {
185       
186        if(($id_auteur = intval($id_auteur)) > 0)
187        {
188                $sql_table = 'spip_auteurs_listes';
189                $sql_noms = '(id_auteur,id_liste,date_inscription)';
190                /**
191                 * Note les abos de cet auteur
192                 */
193                $curr_abos = spiplistes_abonnements_listes_auteur($id_auteur);
194                $real_id_listes = array();
195                $sql_valeurs = array();
196               
197                if (!is_array($id_listes)) $id_listes = array($id_listes);
198               
199                if (is_array($id_listes))
200                {
201                        foreach ($id_listes as $id) {
202                                if (
203                                   (($id = intval($id)) > 0)
204                                   // si pas encore abonne'
205                                        && (!$curr_abos || !in_array($id, $curr_abos)))
206                                {
207                                        $sql_valeurs[] = '('.$id_auteur.','.$id.',NOW())';
208                                        $real_id_listes[] = $id;
209                                }
210                        }
211                        if (count($sql_valeurs)) {
212                                $sql_valeurs = implode(',', $sql_valeurs);
213                                if (sql_insert($sql_table, $sql_noms, $sql_valeurs) === false)
214                                {
215                                        spiplistes_sqlerror_log ('spiplistes_abonnements_ajouter()');
216                                }
217                                else {
218                                        spiplistes_log_api ('SUBSCRIBE id_auteur #'
219                                                                           . $id_auteur
220                                                                           . ' to id_liste '
221                                                                           . "#" . implode(',#', $real_id_listes)
222                                                                           );
223                                }
224                        }
225                }
226        }
227        return($real_id_listes);
228} // spiplistes_abonnements_ajouter()
229
230/**
231 * desabonner des listes
232 * @version CP-20071016
233 */
234function spiplistes_abonnements_desabonner_statut ($id_auteur, $listes_statuts) {
235        if(($id_auteur = intval($id_auteur)) && count($listes_statuts)) {
236                $sql_where = "statut=".implode(" OR statut=", array_map("sql_quote", $listes_statuts));
237                $sql_result = sql_select("id_liste", "spip_listes", $sql_where);
238                $listes = array();
239                while($row = sql_fetch($sql_result)) {
240                        $listes[] = intval($row['id_liste']);
241                }
242                if(count($listes)) {
243                        $sql_where = " id_auteur=".sql_quote($id_auteur)." AND id_liste IN (" . implode(",", $listes) . ")";
244                        sql_delete("spip_auteurs_listes", $sql_where);
245                }
246                return(spiplistes_format_abo_modifier($id_auteur));
247        }
248        return(false);
249}
250
251
252/**
253 * supprimer des abonnes de la table des abonnements
254 * @version CP-20080512
255 */
256function spiplistes_abonnements_auteurs_supprimer ($auteur_statut) {
257        $auteur_statut = "statut=".sql_quote($auteur_statut);
258        if(spiplistes_spip_est_inferieur_193()) { 
259                $result = sql_delete("spip_auteurs_listes", 
260                                        "id_auteur IN (SELECT id_auteur FROM spip_auteurs WHERE $auteur_statut)");
261        } else {
262                // Sur les precieux conseils de MM :
263                // passer la requete en 2 etapes pour assurer portabilite sql
264                $selection =
265                        sql_select("id_auteur", "spip_auteurs", $auteur_statut,'','','','','',false);
266                $sql_result = sql_delete("spip_auteurs_listes", "id_auteur IN ($selection)");
267                if ($sql_result === false) {
268                        spiplistes_sqlerror_log("abonnements_auteurs_supprimer");
269                }
270        }
271        return($result);
272}
273
274/**
275 * renvoie la liste des abonnements pour id_auteur
276 * @version CP-20080330
277 * @param int $id_auteur
278 * @param bool $avec_titre
279 * @return tableau d'id_listes. La valeur est titre si $avec_titre true, sinon id_liste
280 */
281function spiplistes_abonnements_listes_auteur ($id_auteur, $avec_titre = false) {
282        $result = array();
283        $sql_select = array("abo.id_liste");
284        $sql_from = array("spip_auteurs_listes AS abo");
285        $sql_where = array();
286        if($avec_titre) {
287                $sql_select[] = "list.titre";
288                $sql_from[] = "spip_listes AS list";
289                $sql_where[] = "abo.id_liste=list.id_liste";
290        }
291        $sql_where[] = "abo.id_auteur=".sql_quote($id_auteur);
292        $sql_result = sql_select (
293                $sql_select
294                , $sql_from
295                , $sql_where
296                );
297        if ($sql_result === false) {
298                spiplistes_sqlerror_log("spiplistes_abonnements_listes_auteur");
299        }
300        else {
301                while ($row = sql_fetch($sql_result)) {
302                        $result[$row['id_liste']] = ($avec_titre ? $row['titre'] : $row['id_liste']);
303                }
304        }
305        return($result);
306}
307
308/**
309 * desabonner un id_auteur d'une id_liste
310 * ou de toutes les listes si $id_liste = 'toutes'
311 * ou tous les abonnes si id_auteur == 'tous'
312 * ou une serie si array
313 * @version CP-20090410
314 */
315function spiplistes_abonnements_auteur_desabonner ($id_auteur, $id_liste = false)
316{
317        //spiplistes_debug_log("spiplistes_abonnements_auteur_desabonner ($id_auteur, $id_liste)");
318       
319        $result = false;
320        $msg1 = $msg2 = '';
321        $sql_where = array();
322        if($id_auteur == 'tous') {
323                $sql_where[] = 'id_auteur>0';
324                $msg1 = $id_auteur;
325        }
326        else if(is_array($id_auteur)) {
327                $ii = implode(',', $id_auteur);
328                $sql_where[] = 'id_auteur IN ('.$ii.')';
329                $msg1 = 'id_auteur #'.$ii;
330        }
331        else if(($id_auteur = intval($id_auteur)) > 0) {
332                $sql_where[] = 'id_auteur='.sql_quote($id_auteur);
333                $msg1 = 'id_auteur #'.$id_auteur;
334        }
335        if(count($sql_where) && $id_liste)
336        {
337                $sql_table = 'spip_auteurs_listes';
338               
339                if($id_liste == 'toutes')
340                {
341                        $msg2 = ' des listes';
342                }
343                else if(($id_liste = intval($id_liste)) > 0)
344                {
345                        $sql_where[] = 'id_liste='.$id_liste;
346                        $msg2 = ' de la liste #'.$id_liste;
347                }
348                if(($result = sql_delete($sql_table, $sql_where)) === false)
349                {
350                        spiplistes_debug_log ('ERR sql_delete: abonnements_auteur_desabonner()');
351                }
352                else {
353                        spiplistes_log_api('UNSUBSCRIBE '.$msg1.' '.$msg2);
354                }
355        }
356        return ($result);
357}
358
359/**
360 * supprimer des abonnements
361 * @version CP-20080512
362 */
363function spiplistes_abonnements_supprimer ($sql_whereq) {
364        return(sql_delete('spip_auteurs_listes', $sql_whereq));
365}
366
367/**
368 * dans la table des abonnements
369 * @version CP-20080508
370 * @return int
371 */
372function spiplistes_abonnements_compter ($sql_whereq = "") {
373        return(spiplistes_sql_compter("spip_auteurs_listes", $sql_whereq));
374}
375
376/**
377 * Compter les abonnements qui n'ont plus d'abonnes
378 * @return array id_auteur
379 */
380function spiplistes_abonnements_zombies () {
381        // SELECT id_auteur FROM spip_auteurs_listes WHERE id_auteur
382        //      IN (SELECT id_auteur FROM spip_auteurs WHERE statut='5poubelle')
383        $sql_select = "id_auteur";
384        $sql_from = "spip_auteurs";
385        $sql_where = "statut=".sql_quote('5poubelle');
386        $selection = 
387                (spiplistes_spip_est_inferieur_193())
388                ? "SELECT $sql_select FROM $sql_from WHERE $sql_where"
389                : sql_select($sql_select, $sql_from, $sql_where,'','','','','',false)
390                ;
391        $sql_from = "spip_auteurs_listes";
392        $sql_result = sql_select(
393                $sql_select
394                , $sql_from
395                , "$sql_select IN (".$selection.")"
396                );
397        if($sql_result === false) {
398                spiplistes_sqlerror_log("spiplistes_abonnements_zombies");
399        }
400        $result = array();
401        while($row = sql_fetch($sql_result)) {
402                $result[] = $row[$sql_select];
403        }
404        return($result);
405
406}
407
408/**
409 * Donne le nombre d'abonnés (pour une liste)
410 * qui ont un vrai format de réception (html ou texte)
411 * et une adresse mail valide
412 * @version CP-20081228
413 * @return int
414 */
415function spiplistes_abonnements_vrais_compter ($id_liste) {
416        if($id_liste = intval($id_liste)) {
417                // SELECT COUNT(l.id_auteur) AS nb
418                // FROM spip_auteurs_listes AS l, spip_auteurs_elargis AS f, spip_auteurs AS a
419                // WHERE l.id_liste=$id_liste
420                //      AND l.id_auteur=f.id_auteur
421                //      AND (l.id_auteur=a.id_auteur AND LENGTH(a.email) > 3)
422                //      AND (f.`spip_listes_format`='html' OR f.`spip_listes_format`='texte')
423                $sql_select = array('COUNT(l.id_auteur) AS nb');
424                $sql_from = array('spip_auteurs_listes AS l', 'spip_auteurs_elargis AS f', 'spip_auteurs AS a');
425                $sql_where = array(
426                        "l.id_liste=$id_liste"
427                        , "l.id_auteur=f.id_auteur"
428                        , "(l.id_auteur=a.id_auteur AND LENGTH(a.email) > 3)"
429                        , "(f.`spip_listes_format`='html' OR f.`spip_listes_format`='texte')"
430                        );
431                $sql_result = sql_select($sql_select, $sql_from, $sql_where);
432                if($sql_result === false) {
433                        spiplistes_sqlerror_log("spiplistes_abonnements_vrais_compter()");
434                }
435                if($row = sql_fetch($sql_result)) {
436                        $result = $row['nb'];
437                }
438        }
439        return($result);
440}
441
442/**
443 * Inventaire des abonnements.
444 * Tableau dont l'index est l'ID de la liste
445 * et la valeur un tableau des ID abonnés
446 * @param string|array $sql_where
447 * @version CP-20110510
448 * @return array|bool
449 */
450function spiplistes_abonnements_lister ($sql_where = '') {
451       
452        if(($sql_result = sql_select('id_auteur,id_liste'
453                                                                , 'spip_auteurs_listes'
454                                                                , $sql_where
455                                                                )
456                ) !== FALSE)
457        {
458                $listes = array();
459               
460                while($row = sql_fetch($sql_result))
461                {
462                        $ii = $row['id_liste'];
463                       
464                        if(!isset($listes[$ii]))
465                        {
466                                $listes[$ii] = array();
467                        }
468                        $listes[$ii][] = $row['id_auteur'];
469                }
470                return ($listes);
471        }
472        else {
473                spiplistes_sqlerror_log('spiplistes_abonnements_lister ()');
474        }
475        return (FALSE);
476}
477
478/**
479 ******************************************************************************
480        Les fonctions spiplistes_listes_*() concernent les listes
481       
482        Table cible : spip_listes
483       
484 ******************************************************************************
485 */
486
487/**
488 * dans la table des listes
489 * @version CP-20080508
490 */
491function spiplistes_listes_compter ($sql_whereq = "") {
492        return(spiplistes_sql_compter("spip_listes", $sql_whereq));
493}
494
495/**
496 * @version CP-20080501
497 */
498function spiplistes_listes_liste_modifier ($id_liste, $array_set) {
499        return(
500                sql_update(
501                        'spip_listes'
502                        , $array_set
503                        , "id_liste=".sql_quote($id_liste)." LIMIT 1"
504                )
505        );
506}
507
508/**
509 * @version CP-20080501
510 */
511function spiplistes_listes_liste_supprimer ($id_liste) {
512        $sql_where = "id_liste=".sql_quote(intval($id_liste));
513        return(
514                sql_delete('spip_listes', $sql_where." LIMIT 1")
515                && spiplistes_mod_listes_supprimer("tous", $id_liste)
516                && sql_delete('spip_auteurs_listes', $sql_where)
517        );
518}
519
520/**
521 * @version CP-20080512
522 */
523function spiplistes_listes_liste_creer ($statut, $lang, $titre, $texte, $pied_page) {
524        global $connect_id_auteur;
525
526        if($id_liste = sql_insertq('spip_listes', array(
527                          'statut' => $statut
528                        , 'lang' => $lang
529                        , 'titre' => $titre
530                        , 'texte' => $texte
531                        , 'pied_page' => $pied_page
532                        )
533                )
534        ) { 
535                $id_liste = intval($id_liste);
536                $id_auteur = intval($connect_id_auteur);
537                spiplistes_mod_listes_supprimer("tous", $id_liste);
538                spiplistes_mod_listes_ajouter($id_auteur, $id_liste);
539                spiplistes_abonnements_auteur_desabonner("tous", $id_liste);
540                spiplistes_abonnements_ajouter($id_auteur, $id_liste);
541                return($id_liste);
542        }
543        return(false);
544}
545
546/**
547 * renvoie tableau de id_auteurs abonnes a une liste
548 * @version CP-20080602
549 */
550function spiplistes_listes_liste_abo_ids ($id_liste) {
551        $sql_result = sql_select('id_auteur', 'spip_auteurs_listes', "id_liste=".sql_quote($id_liste), '', array('id_auteur'));
552        $ids_abos = array();
553        while($row = sql_fetch($sql_result)) {
554                $ids_abos[] = intval($row['id_auteur']);
555        }
556        return($ids_abos);
557}
558
559/**
560 * Compter les abonnes.
561 * @param $id_liste int. Si > 0, abonnes a cette liste,
562 *      sinon, nombre total d'abonnements (nb lignes dans la table)
563 * @param $preciser. Si true, renvoie tableau total et formats
564 * @return int|array
565 */
566function spiplistes_listes_nb_abonnes_compter ($id_liste = 0, $preciser = false)
567{
568        $id_liste = intval($id_liste);
569        $sql_whereq = (
570                                   ($id_liste > 0)
571                                   ? 'id_liste='.sql_quote($id_liste)
572                                   : ''
573                                   );
574        $total = spiplistes_sql_compter('spip_auteurs_listes', $sql_whereq);
575       
576        if($preciser)
577        {
578                $selection = 
579                        (spiplistes_spip_est_inferieur_193())
580                        ? 'SELECT id_auteur FROM spip_auteurs_listes '
581                                . (!empty($sql_whereq) ? 'WHERE '.$sql_whereq : '')
582                        : sql_select('id_auteur', 'spip_auteurs_listes', $sql_whereq,'','','','','',false)
583                        ;
584                $sql_result = sql_select(
585                        "`spip_listes_format` AS f, COUNT(*) AS n"
586                        , 'spip_auteurs_elargis'
587                        , 'id_auteur IN ('.$selection.')'
588                        , "`spip_listes_format`"
589                );
590                if($sql_result === false)
591                {
592                        spiplistes_sqlerror_log('listes_nb_abonnes_compter');
593                }
594                $formats = array('html' => 0, 'texte' => 0);
595                $keys = array_keys($formats);
596                while($row = sql_fetch($sql_result))
597                {
598                        if(in_array($row['f'], $keys)) {
599                                $formats[$row['f']] += $row['n'];
600                        }
601                }
602                return(array($total, $formats['html'], $formats['texte']));
603        }
604        return($total);
605}
606
607/**
608 * renvoie email emetteur d'une liste
609 * @version CP-20080509
610 */
611function spiplistes_listes_email_emetteur ($id_liste = 0) {
612        $id_liste = intval($id_liste);
613        if($id_liste > 0) {
614                $result = 
615                        sql_getfetsel(
616                                "email_envoi"
617                                , "spip_listes"
618                                , "id_liste=".sql_quote($id_liste)." LIMIT 1"
619                        );
620                if($result === false) {
621                        spiplistes_sqlerror_log("listes_email_emetteur");
622                }
623        }
624        // si pas d'adresse moderateur, va chercher adresse par defaut
625        if(!$result || empty($result)) {
626                $result = spiplistes_email_from_default();
627        }
628        return($result);
629}
630
631/**
632 * @version CP-20080511
633 */
634function spiplistes_listes_liste_fetsel ($id_liste, $keys = "*") {
635        $id_liste = intval($id_liste);
636        return(sql_fetsel($keys, "spip_listes", "id_liste=".sql_quote($id_liste)." LIMIT 1"));
637}
638
639/**
640 * @version CP-20081116
641 */
642function spiplistes_listes_liste_statut ($id_liste) {
643        return(spiplistes_listes_liste_fetsel($id_liste, 'statut'));
644}
645
646/**
647 * renvoie array sql_where des listes publiees
648 * @version CP-20080505
649 */
650function spiplistes_listes_sql_where_or ($listes) {
651        return("statut=".implode(" OR statut=", array_map("sql_quote", explode(";", $listes))));
652}
653
654/**
655 * taille d'une chaine sans saut de lignes ni espaces ni punct
656 */
657function spiplistes_strlen($out){
658        $out = preg_replace("/([[:space:]]|[[:punct:]])+/", "", $out);
659        return (strlen($out));
660}
661
662/**
663 * dans la queue d'envoi des courriers
664 * @version CP-20080508
665 */
666function spiplistes_courriers_en_queue_compter ($sql_whereq = "") {
667        // demande le nombre de courriers dans la queue
668        // avec etat vide (si etat non vide,
669        // c'est que la meleuse est en train de l'envoyer)
670        return(spiplistes_sql_compter("spip_auteurs_courriers", $sql_whereq));
671}
672
673/**
674 * @version CP-20080510
675 */
676function spiplistes_courriers_en_queue_modifier ($array_set, $sql_whereq) {
677        return(
678                sql_update(
679                        'spip_auteurs_courriers'
680                        , $array_set
681                        , $sql_whereq
682                )
683        );
684}
685
686
687/**
688 * @version CP-20080510
689 */
690function spiplistes_courriers_en_queue_supprimer ($sql_whereq) {
691        if(($result = sql_delete('spip_auteurs_courriers', $sql_whereq)) === false) {
692                spiplistes_sqlerror_log("courriers_en_queue_supprimer");
693        }
694        return($result);
695}
696
697/**
698 *l a premiere etiquette sur le tas
699 * @version CP-20080621
700 */
701function spiplistes_courriers_en_queue_premier ($select, $where) {
702        return(
703                sql_getfetsel(
704                                  $select
705                                , 'spip_auteurs_courriers'
706                                , $where
707                                , '', '', 1
708                        )
709        );
710}
711
712
713/**
714 ******************************************************************************
715        Les fonctions spiplistes_format_abo_*() concernent les
716        formats de reception des abos
717       
718        Table cible : spip_auteurs_elargis
719       
720        Table historique utilisee par d'autres plugins.
721       
722        Cette table contient le format par defaut de l'abonne'.
723        Le format final, reel, est dans le champ 'format' de
724        la table des abonnements (spip_auteurs_listes).
725       
726        Ce format est attache' a l'abonnement. Ainsi, un abonne'
727        peut s'inscrire au format HTML a' la liste 1
728        et au format TEXTE a la liste 2.
729       
730 ******************************************************************************
731 */
732
733
734/**
735 * suspend les abonnements d'un compte
736 */
737function spiplistes_format_abo_suspendre ($id_auteur) {
738        return(spiplistes_format_abo_modifier($id_auteur));
739}
740
741/**
742 * compter les formats (les abonnes ayant de'fini un format)
743 * @version CP-20110529
744 * @return int
745 */
746function spiplistes_formats_compter ($sql_where) {
747       
748        $result = sql_fetsel('COUNT(id_auteur) as n', 'spip_auteurs_elargis', $sql_where);
749        if ($result) {
750                $result = $result['n'];
751        }
752        return ($result);
753}
754
755/**
756 * supprimer le format d'un id_auteur
757 * si $id_auteur == 'tous', supprimer tous les formats
758 * @version CP-20090111
759 */
760function spiplistes_format_abo_supprimer ($id_auteur) {
761        $sql_table = "spip_auteurs_elargis";
762        if(($id_auteur = intval($id_auteur)) > 0) {
763                $sql_where = "id_auteur=$id_auteur";
764                $msg = "id_auteur #$id_auteur";
765        }
766        else if ($id_auteur == 'tous') {
767                $sql_where = "id_auteur>0";
768                $msg = "ALL";
769        }
770        if($sql_where) {
771                if(($result = sql_delete("spip_auteurs_elargis", $sql_where)) === false) {
772                        spiplistes_sqlerror_log("format_abo_supprimer()");
773                }
774                else {
775                        spiplistes_log_api("delete format for $msg");
776                }
777        }
778        return($result);
779}
780
781/**
782 * modifier le format abonne
783 * si id_auteur, celui-ci uniquement
784 * sinon, 'tous' pour modifier globalement (uniquement ceux ayant deja un format)
785 */
786function spiplistes_format_abo_modifier ($id_auteur, $format = 'non') {
787
788        if($format = spiplistes_format_valide($format)) {
789                $sql_table = "spip_auteurs_elargis";
790                $sql_champs = array('`spip_listes_format`' => sql_quote($format));
791                if($id_auteur == 'tous') {
792                        // appliquer le meme format a tous les abos
793                        $sql_result = sql_update($sql_table, $sql_champs, 1);
794                        $action = "update";
795                }
796                else if(($id_auteur = intval($id_auteur)) > 0) {
797                        if(($cur_format = spiplistes_format_abo_demande($id_auteur)) !== false) {
798                                // si pas d'erreur sql
799                                if(!$cur_format) {
800                                        // si inexistant faire un insert
801                                        $sql_champs = array(
802                                                'id_auteur' => $id_auteur
803                                                , '`spip_listes_format`' => $format
804                                        );
805                                        $sql_result = sql_insertq($sql_table, $sql_champs);
806                                        $action = "insert";
807                                } else {
808                                        // sinon update
809                                        $sql_where = "id_auteur=".sql_quote($id_auteur)." LIMIT 1"; 
810                                        $sql_result = sql_update($sql_table, $sql_champs, $sql_where);
811                                        $action = "update";
812                                }
813                        }
814                }
815                if($sql_result === false) {
816                        spiplistes_sqlerror_log("spiplistes_format_abo_modifier() $action $id_auteur");
817                }
818                else {
819                        $id_auteur = ($id_auteur == 'tous') ? "ALL" :  "id_auteur #$id_auteur";
820                        spiplistes_log_api("$action format to '$format' for $id_auteur");
821                }
822        }
823        return($sql_result);
824}
825
826/**
827 * renvoie le format d'abonnement d'un auteur
828 * @param int $id_auteur
829 * @return string
830 */
831function spiplistes_format_abo_demande ($id_auteur) {
832        $id_auteur = intval($id_auteur);
833        $result = false;
834        $sql_where = "id_auteur=".sql_quote($id_auteur);
835        if($id_auteur > 0) {
836                if(!spiplistes_spip_est_inferieur_193()) {
837                        $result = sql_getfetsel("`spip_listes_format`", "spip_auteurs_elargis", $sql_where, '', '', 1);
838                } else {
839                        /*
840                        $result = sql_fetsel("`spip_listes_format` AS format", "spip_auteurs_elargis", $sql_where);
841                        $result = $result['format'];
842                        */
843                        if(($sql_result = sql_select("`spip_listes_format` AS format", "spip_auteurs_elargis", $sql_where, '', '', 1)) !== false) {
844                                $row = sql_fetch($sql_result);
845                                $result = $row['format'];
846                                spiplistes_log_api("current format for id_auteur #$id_auteur = $result ($sql_where)");
847                        }
848                        else {
849                                spiplistes_sqlerror_log("spiplistes_format_abo_demande()");
850                        }
851                }
852                /* Code a valider. Si ok, supprimer ci-dessus.
853                $GLOBALS['mysql_rappel_nom_base'] = false;
854                $result = sql_getfetsel("spip_listes_format", "spip_auteurs_elargis", "id_auteur=".sql_quote($id_auteur));
855                $result = spiplistes_format_valide($result);
856                /**/
857        }
858        return($result);
859}
860
861/**
862 * liste des formats autorises
863 *      ($idx == 'array') array (index et sa valeur identique)
864 *      ($idx == 'quoted') la valeur est sql_quote'
865 *      ($idx == 'sql_where') string ligne sql_where formatee avec OR
866 * @version CP-20090111
867 * @param $idx string[optional]
868 * @return string|array
869 */
870function spiplistes_formats_autorises ($idx = 'array') {
871        static $formats;
872        if(!$formats) {
873                $ii = explode(";", _SPIPLISTES_FORMATS_ALLOWED);
874                $formats = array('array' => array_combine($ii, $ii));
875                $formats['quoted'] = array_map("sql_quote", $formats['array']);
876                $formats['sql_where'] = "(`spip_listes_format`=" . implode(" OR `spip_listes_format`=", $formats['quoted']).")";
877        }
878        return($formats[$idx]);
879}
880
881/**
882 * Donne le format de reception par defaut
883 *
884 * Le format de réception de courrier est définissable
885 * par la page de configuration du plugin.
886 * @version CP-20110508
887 * @return string
888 */
889function spiplistes_format_abo_default () {
890        $defaut = spiplistes_pref_lire('opt_format_courrier_defaut');
891        if (
892                ($defaut != 'html')
893                && ($defaut != 'texte')
894        ) {
895                $defaut = _SPIPLISTES_FORMAT_DEFAULT;
896        }
897        return ($defaut);
898}
899
900/**
901 * Inventaire des formats de réception par défaut.
902 *
903 * Tableau dont l'index est l'ID de l'auteur
904 * et la valeur le format de réception par défaut.
905 *
906 * @param string|array $sql_where
907 * @version CP-20110510
908 * @return array|bool
909 */
910function spiplistes_formats_defaut_lister ($sql_where = '') {
911       
912        if(
913                ($sql_result = sql_select('id_auteur,`spip_listes_format` AS format'
914                                                                        , 'spip_auteurs_elargis'
915                                                        , $sql_where
916                                                                        )
917        ) !== FALSE )
918        {
919                $auteurs = array();
920       
921                while($row = sql_fetch($sql_result)) {
922                        $auteurs[$row['id_auteur']] = $row['format'];
923                }
924                return ($auteurs);
925        }
926        else {
927                spiplistes_sqlerror_log('spiplistes_formats_defaut_lister ()');
928        }
929        return (FALSE);
930}
931
932/**
933 ******************************************************************************
934        Les fonctions spiplistes_mod_listes_*() concernent les moderateurs
935       
936        Table cible : spip_auteurs_mod_listes
937       
938 ******************************************************************************
939 */
940
941/**
942 * renvoie ID du moderateur de la liste
943 * ou de toutes les listes si $id_liste = 'toutes'
944 * -> result du style: array[id_liste] => array(id_auteur, ...)
945 * @version CP-20080608
946 */
947function spiplistes_mod_listes_get_id_auteur ($id_liste) {
948        $sql_from = 'spip_auteurs_mod_listes';
949        $sql_where = 
950                ($id_liste == "toutes")
951                ? ""
952                : "id_liste=".sql_quote(intval($id_liste))
953                ;
954        if($sql_result = sql_select("*", $sql_from, $sql_where)) {
955                $result = array();
956                while($row = sql_fetch($sql_result)) {
957                        $ii = $row['id_liste'];
958                        if(!isset($result[$ii])) {
959                                $result[$ii] = array();
960                        }
961                        $result[$ii][] = $row['id_auteur'];
962                }
963                return($result);
964        }
965        return(false);
966}
967
968/**
969 * supprime un ou + moderateurs d'une liste
970 * ou tous les moderateurs si $id_auteur == 'tous'
971 * @version CP-20090111
972 */
973function spiplistes_mod_listes_supprimer ($id_auteur, $id_liste) {
974        if(($id_auteur = intval($id_auteur)) > 0) {
975                $sql_where = array("id_auteur=$id_auteur");
976                $msg = "id_auteur #$id_auteur";
977        } else if($id_auteur == "tous") {
978                $sql_where = array("id_auteur>0");
979                $msg = "ALL";
980        }
981        if($sql_where && (($id_liste = intval($id_liste)) > 0)) {
982                $sql_where[] = "id_liste=$id_liste";
983                if(($result = sql_delete('spip_auteurs_mod_listes', $sql_where)) !== false) {
984                        spiplistes_log_api("delete moderator #$id_auteur from id_liste #$id_liste");
985                }
986                else {
987                        spiplistes_sqlerror_log("mod_listes_supprimer()");
988                }
989        }
990        return($result);
991}
992
993/**
994 * @version CP-20080512
995 */
996function spiplistes_mod_listes_ajouter ($id_auteur, $id_liste) {
997        if(($id_liste = intval($id_liste)) > 0) {
998                $result =
999                        sql_insertq('spip_auteurs_mod_listes'
1000                                , array(
1001                                          'id_auteur' => $id_auteur
1002                                        , 'id_liste' => $id_liste
1003                                        )
1004                        );
1005                if($result !== false) {
1006                        spiplistes_log_api("insert moderator id_auteur #$id_auteur to id_liste #$id_liste");
1007                }
1008                else {
1009                        spiplistes_sqlerror_log("mod_listes_ajouter");
1010                }
1011        }
1012        return($result);
1013}
1014
1015/**
1016 * @version CP-20080610
1017 */
1018function spiplistes_mod_listes_compter ($id_liste) {
1019        $n = sql_fetch(sql_select("COUNT(*) AS n", "spip_auteurs_mod_listes", "id_liste=".sql_quote($id_liste)));
1020        return(($n && $n['n']) ? $n['n'] : false);
1021}
1022
1023/**
1024 * renvoie tableau id_liste des listes moderees par l'auteur
1025 * @version CP-20080620
1026 * @return bool|array
1027 */
1028function spiplistes_mod_listes_id_auteur ($id_auteur) {
1029        $result = false;
1030        if($sql_result = sql_select('id_liste', 'spip_auteurs_mod_listes', 'id_auteur='.sql_quote($id_auteur))) {
1031                $result = array();
1032                while($row = sql_fetch($sql_result)) {
1033                        $result[] = $row['id_liste'];
1034                }
1035        }
1036        else if($sql_result === false) {
1037                spiplistes_sqlerror_log("mod_listes_id_auteur");
1038        }
1039        return($result);
1040}
1041
1042/**
1043 * passe propre() sur un texte puis nettoie les trucs rajoutes par spip sur du html
1044 * @return string
1045 * Remplace spiplistes_courrier_propre() qui est a supprimer apres verif.
1046 */
1047function spiplistes_texte_propre ($texte) {
1048        spiplistes_debug_log ('spiplistes_texte_propre()');
1049        static $adresse_site;
1050        if (!$adresse_site) { $adresse_site = $GLOBALS['meta']['adresse_site']; }
1051        static $style_rev = '__STYLE__';
1052       
1053        if (preg_match ('@<style[^>]*>[^<]*</style>@'
1054                                                          , $texte
1055                                                          , $style_reg
1056                                                          )
1057                > 0
1058        ) {
1059                $style_str = $style_reg[0];
1060        }
1061        else {
1062                $style_str = '';
1063        }
1064        $texte = preg_replace ('@<style[^>]*>[^<]*</style>@', $style_rev, $texte);
1065       
1066        //passer propre si y'a pas de html (balises fermantes)
1067        if( !preg_match(',</?('._BALISES_BLOCS.')[>[:space:]],iS', $texte) ) 
1068        $texte = propre($texte); // pb: enleve aussi <style>... 
1069       
1070        // Corrections complementaires
1071        $patterns = array();
1072        $replacements = array();
1073        // html
1074        $patterns[] = '#<br>#i';
1075        $replacements[] = '<br />';
1076        $patterns[] = '#<b>([^<]*)</b>#i';
1077        $replacements[] = '<strong>\\1</strong>';
1078        $patterns[] = '#<i>([^<]*)</i>#i';
1079        $replacements[] = '<em>\\1</em>';
1080        // spip class
1081        $patterns[] = '# class="spip"#';
1082        $replacements[] = '';   
1083       
1084        $texte = preg_replace($patterns, $replacements, $texte);
1085
1086        // remettre en place les styles
1087        $texte = str_replace ($style_rev, $style_str, $texte);
1088       
1089        //les liens avec double debut #URL_SITE_SPIP/#URL_ARTICLE
1090        $texte = preg_replace (
1091                                '@'
1092                                . $adresse_site
1093                                        . '/'
1094                                        . $adresse_site
1095                                        . '@'
1096                                , $adresse_site
1097                                , $texte
1098                                );
1099        $texte = spiplistes_liens_absolus ($texte);
1100       
1101        return ($texte);
1102}
1103
1104function spiplistes_titre_propre($titre){
1105        $titre = spiplistes_texte_propre($titre);
1106        $titre = substr($titre, 0, 128); // Au cas ou copie/colle
1107        return($titre);
1108}
1109
1110/**
1111 * Recherche les différentes versions de patron possibles
1112 * <patron>._texte.en patron texte anglais
1113 * <patron>._texte patron texte generique
1114 * <patron>.en patron anglais
1115 * <patron> patron generique
1116 * @version CP-20081128
1117 * @param $path_patron string
1118 * @param $lang string
1119 * @param $chercher_texte bool si TRUE, chercher la version texte du patron
1120 * @return string le chemin du patron si patron trouve' ou FALSE si non trouve'
1121 * @todo verifier presence de lang dans les appels a cette fonction
1122 */
1123function spiplistes_patron_find_in_path ($path_patron, $lang, $chercher_texte = false) {
1124        static $t = "_texte", $h = ".html";
1125       
1126        if(!$lang) {
1127                $lang = $GLOBALS['spip_lang'];
1128        }
1129       
1130        if(
1131                $chercher_texte 
1132                && (find_in_path($path_patron . $t . "." . $lang . $h) || find_in_path($path_patron . $t . $h))
1133        ) {
1134                return($path_patron . $t);
1135        }
1136        else if(find_in_path($path_patron . "." . $lang . $h) || find_in_path($path_patron . $h)) {
1137                return($path_patron);
1138       
1139        }
1140        return(false);
1141}
1142
1143/**
1144 * Renvoie le nom du patron pour la composition des messages de gestion
1145 * (confirmation d'abonnement, modification, etc.)
1146 * @todo boite de sélection dans une page de configuration ?
1147 * @return string
1148 * */
1149function spiplistes_patron_message () {
1150        return ('standard');
1151}
1152
1153/**
1154 * Incruster les styles inline
1155 *
1156 * @version CP-20110510
1157 * @param string $texte_html
1158 * @return string
1159 */
1160function spiplistes_html_styles_inline ($texte_html) {
1161       
1162        if (strpos($texte_html, 'spip_documents_center') !== FALSE)
1163        {
1164                $pattern = array(
1165                        "{<span class='spip_document_\d* spip_documents spip_documents_center'>}m"
1166                );
1167                $replacement = array(
1168                        '<span style="display:block;text-align:center">'
1169                );
1170                $texte_html = preg_replace ($pattern, $replacement, $texte_html);
1171        }
1172        return ($texte_html);
1173}
1174
1175/**
1176 * Assembler/calculer un patron
1177 * @version CP-20090427
1178 * @param $patron string nom du patron
1179 * @param $contexte array
1180 * @return array le resultat html et texte seul dans un tableau
1181 */
1182function spiplistes_assembler_patron ($path_patron, $contexte) {
1183
1184        include_spip('inc/distant');
1185       
1186        // Pour recuperer_fond()
1187        // qui est passé en inc/utils en SPIP 2
1188        if (spiplistes_spip_est_inferieur_193()) {
1189                include_spip('public/assembler');
1190        }
1191       
1192        spiplistes_debug_log('Chemin patrons : '.$path_patron);
1193       
1194        $patron_html = spiplistes_patron_find_in_path($path_patron, $contexte['lang'], false);
1195        $contexte['patron_html'] = $patron_html;
1196        spiplistes_debug_log('CREATE html version USING '.$patron_html);
1197       
1198        $result_html =
1199                ($patron_html && find_in_path('patron_switch.html'))
1200                ? recuperer_fond('patron_switch', $contexte)
1201                : ''
1202                ;
1203       
1204        /**
1205         * Calculer le contenu texte à partir
1206         * du {patron}_texte s'il existe
1207         */
1208        $patron_texte = spiplistes_patron_find_in_path($path_patron, $contexte['lang'], true);
1209        unset($contexte['patron_html']);
1210        $contexte['patron_texte'] = $patron_texte;
1211        $result_texte = '';
1212        $texte_ok = false;
1213        if ($patron_texte && ($patron_texte != $patron_html))
1214        {
1215                spiplistes_debug_log('CREATE text version USING '.$patron_texte);
1216       
1217                if (find_in_path('patron_switch.html')) {
1218                        if($result_texte = recuperer_fond('patron_switch', $contexte))
1219                        {
1220                                $result_texte = spiplistes_courrier_version_texte($result_texte);
1221                        }
1222                        $texte_ok = true;
1223                }
1224        }
1225        /**
1226         * si {patron}_texte manque, ou vide,
1227         * calculer a partir de la version html
1228         */
1229        if (!$texte_ok) {
1230                $result_texte = spiplistes_courrier_version_texte($result_html);
1231        }
1232        // eliminer les espaces pour un vrai calcul de poids
1233        $result_html = trim($result_html);
1234        $result_texte = trim($result_texte);
1235        $result = array ($result_html, $result_texte);
1236       
1237        return($result);
1238}
1239
1240/**
1241 * donne contenu tampon au format html (CP-20071013) et texte
1242 * @return array (string $html, string $texte)
1243 */
1244function spiplistes_tampon_assembler_patron () {
1245        //spiplistes_log_api("calculer tampon");
1246        $contexte = array();
1247        $path_patron = spiplistes_pref_lire('tampon_patron');
1248        //spiplistes_log_api($path_patron);
1249        if(!empty($path_patron))
1250        {
1251                foreach(explode(",", _SPIPLISTES_TAMPON_CLES) as $key) {
1252                        $s = spiplistes_pref_lire($key);
1253                        $contexte[$key] = (!empty($s) && ($s != 'non')) ? $s : '';
1254                }
1255                $result = spiplistes_assembler_patron(_SPIPLISTES_PATRONS_TAMPON_DIR . $path_patron, $contexte);
1256        }
1257        else {
1258                $result = array("", "");
1259        }
1260        return($result);
1261}
1262
1263function spiplistes_pied_page_assembler_patron ($id_liste, $lang = false) {
1264       
1265        $result = array("", "");
1266       
1267        if(($id_liste = intval($id_liste)) > 0)
1268        {
1269                $pied_patron = sql_getfetsel('pied_page', 'spip_listes', "id_liste=".sql_quote($id_liste), '','',1);
1270               
1271                $pied_patron =
1272                        (!$pied_patron)
1273                        // si patron vide (ancienne version de SPIP-Listes ?), appliquer le patron par defaut
1274                        ? _SPIPLISTES_PATRONS_PIED_DEFAUT
1275                        : $pied_patron
1276                        ;
1277                if(strlen($pied_patron) > _SPIPLISTES_PATRON_FILENAMEMAX)
1278                {
1279                        // probablement le contenu du pied (SPIP-Listes <= 1.9.2 ?)
1280                        // rester compatible avec les anciennes version de SPIP-Listes
1281                        // qui stoquaient le patron assemble' en base
1282                        $pied_texte = spiplistes_courrier_version_texte($pied_html = $pied_patron);
1283                        $result = array($pied_html, $pied_texte);
1284                }
1285                else if(strlen($pied_patron) && ($pied_patron != _SPIPLISTES_PATRON_PIED_IGNORE)) {
1286                       
1287                        if(!$lang) {
1288                                $lang = spiplistes_listes_langue($id_liste) || $GLOBALS['spip_lang'];
1289                        }
1290                        $contexte = array('lang' => $lang);
1291                        $result = spiplistes_assembler_patron (
1292                                _SPIPLISTES_PATRONS_PIED_DIR . $pied_patron
1293                                , $contexte
1294                        );
1295                }
1296        }
1297        return ($result);
1298}
1299
1300function spiplistes_format_valide ($format) {
1301        return(in_array($format, array("non", "texte", "html")) ? $format : false);
1302}
1303
1304/**
1305 ******************************************************************************
1306        Les fonctions spiplistes_auteurs_*() concernent les auteurs
1307       
1308        Table cible : spip_auteurs
1309       
1310 ******************************************************************************
1311 */
1312
1313/**
1314 * @version CP-20080503
1315 * soit update cookie du cookie transmis
1316 * soit update cookie de l'email transmis
1317 */
1318function spiplistes_auteurs_cookie_oubli_updateq ($cookie_oubli, $where, $where_is_cookie = false) {
1319        if(is_string($where)) {
1320                $where = (($where_is_cookie) ? "cookie_oubli" : "email")
1321                        . "=" . sql_quote($where) . " LIMIT 1";
1322        }
1323        return(sql_update('spip_auteurs', array('cookie_oubli' => sql_quote($cookie_oubli)), $where));
1324}
1325
1326/**
1327 * @version CP-20080629
1328 * soit update cookie du cookie transmis
1329 * soit update cookie de l'email transmis
1330 */
1331function spiplistes_date_heure_valide ($date_heure) {
1332        $date_array = recup_date($date_heure);
1333        if($date_array) {
1334                list($annee, $mois, $jour) = $date_array;
1335                list($heures, $minutes, $secondes) = recup_heure($date_heure);
1336                return(array($annee, $mois, $jour, $heures, $minutes, $secondes));
1337        }
1338        return(false);
1339}
1340
1341/**
1342 * Nombre total d'auteurs (ou visiteur, ou perso) elligibles
1343 * Nota: un compte 'nouveau' est un compte visiteur (inscription) qui ne s'est pas encore connecté
1344 * Nota2: un compte créé via l'espace privé mais pas encore connecté
1345 * n'a pas le statut 'nouveau' mais celui de son groupe
1346 * @version CP-200080519
1347 */
1348function spiplistes_auteurs_elligibles_compter ()
1349{
1350        static $nb;
1351        if(!$nb)
1352        {
1353                $sql_where = array(
1354                          'statut!='.sql_quote('5poubelle')
1355                        , 'statut!='.sql_quote('nouveau')
1356                        );
1357                $nb = sql_countsel('spip_auteurs', $sql_where);
1358        }
1359        return($nb);
1360}
1361
1362/**
1363 * Total des auteurs qui ne sont pas abonnes a une liste
1364 * @version CP-200080519
1365 */
1366function spiplistes_auteurs_non_abonnes_compter ()
1367{
1368        static $nb;
1369        if($nb === null)
1370        {
1371                $selection =
1372                        (spiplistes_spip_est_inferieur_193())
1373                        ? 'SELECT id_auteur FROM spip_auteurs_listes GROUP BY id_auteur'
1374                        : sql_select('id_auteur', 'spip_auteurs_listes', '','id_auteur','','','','',false)
1375                ;
1376                $sql_where = array(
1377                          'statut!='.sql_quote('5poubelle')
1378                        , 'statut!='.sql_quote('nouveau')
1379                        , 'id_auteur NOT IN ('.$selection.')'
1380                        );
1381                $nb = sql_countsel('spip_auteurs', $sql_where);
1382        }
1383        return($nb);
1384}
1385
1386/**
1387 * CP-20080511 20110315
1388 * Renvoie la selection pour un seul auteur
1389 * @return array OR false
1390 */
1391function spiplistes_auteurs_auteur_select ($select, $where = array())
1392{
1393        //$result = sql_select($select, 'spip_auteurs', $where, '', '', 1);
1394        $auteur = sql_fetsel($select, 'spip_auteurs', $where, '', '', 1);
1395        return($auteur);
1396}
1397
1398/**
1399 * CP-20080511
1400 */
1401function spiplistes_auteurs_auteur_delete ($sql_where) {
1402        // détruire ou mettre à la poubelle ?
1403        // SPIP ne détruit pas lui !
1404        // dans le doute...
1405        // if(($result = sql_delete('spip_auteurs', $sql_where." LIMIT 1")) === false) {
1406        if(($result = sql_update(
1407                                        "spip_auteurs"
1408                                        , array('statut' => sql_quote('5poubelle'))
1409                                        , $sql_where . " LIMIT 1"
1410                                )) === false) {
1411                spiplistes_sqlerror_log("auteurs_auteur_delete");
1412        }
1413        return($result);
1414}
1415
1416/**
1417 * CP-20080511
1418 * @return int|bool
1419 */
1420function spiplistes_auteurs_auteur_insertq ($champs_array) {
1421        $id_auteur = sql_insertq('spip_auteurs', $champs_array);
1422        return($id_auteur);
1423}
1424
1425/**
1426 * CP-20090409
1427 */
1428function spiplistes_auteurs_auteur_valider ($id_auteur, $as_redact = false) {
1429        if($id_auteur = intval($id_auteur)) {
1430                if(($result = sql_update(
1431                                                "spip_auteurs_listes"
1432                                                , array('statut' => sql_quote('valide'))
1433                                                , "id_auteur=$id_auteur LIMIT 1"
1434                                        )) === false) {
1435                        spiplistes_sqlerror_log("auteurs_auteur_valider");
1436                }
1437                else {
1438                       
1439                }
1440        }
1441        return($result);
1442}
1443
1444/**
1445 * CP-20110315
1446 * @return bool
1447 */
1448function spiplistes_auteurs_auteur_statut_modifier ($id_auteur, $statut)
1449{
1450        spiplistes_debug_log ('modification status for auteur #'.$id_auteur);
1451        $result = sql_update(
1452                                        'spip_auteurs'
1453                                        , array('statut' => sql_quote($statut))
1454                                        , 'id_auteur='.$id_auteur.' LIMIT 1'
1455                                );
1456        return ($result);
1457}
1458
1459/**
1460 * CP-20110321
1461 * Retourne une version texte pure du nom du site
1462 * @return string
1463 */
1464function spiplistes_nom_site_texte ($lang = '') {
1465       
1466        static $nom_site;
1467        $lang = trim ($lang);
1468        if (empty($lang)) {
1469                $lang = $GLOBALS['meta']['langue_site'];
1470        }
1471       
1472        if ($nom_site === null) 
1473        {
1474                $nom_site = array();
1475        }
1476        if (!isset($nom_site[$lang]))
1477        {
1478                $n = strip_tags(html_entity_decode(extraire_multi($GLOBALS['meta']['nom_site'])));
1479               
1480                // incorrect avec utf-8. Abime les diacritiques
1481                //$n = preg_replace ('@\s*@', ' ', $n);
1482               
1483                $nom_site[$lang] = trim($n);
1484        }
1485        return ($nom_site[$lang]);
1486}
1487
1488/**
1489 * @version CP-20110321
1490 * @return string
1491 */
1492function spiplistes_texte_2_charset ($texte, $charset) {
1493        if ($charset && ($charset != $GLOBALS['meta']['charset'])) {
1494                include_spip('inc/charsets');
1495                $texte = unicode2charset(charset2unicode($texte), $charset);
1496        }
1497        return ($texte);
1498}
1499
1500/**
1501 * Compose le contenu du message via un patron
1502 * Les patrons de messages sont dans ~/patrons/messages_abos
1503 * @param string $objet
1504 * @param string $patron
1505 * @param array $contexte
1506 * @return string
1507 */
1508function spiplistes_preparer_message ($objet, $patron, $contexte) {
1509       
1510        include_once (_DIR_PLUGIN_SPIPLISTES.'inc/spiplistes_mail.inc.php');
1511       
1512        // si pas encore abonne' ou desabonne', pas de format ! donc forcer a texte
1513        $format = ($contexte['format'] == 'html') ? $contexte['format'] : ($contexte['format'] = 'texte');
1514
1515        $contexte['patron'] = $patron;
1516        $path_patron = _SPIPLISTES_PATRONS_MESSAGES_DIR . $patron;
1517       
1518        list($message_html, $message_texte) = spiplistes_assembler_patron($path_patron, $contexte);
1519
1520        $charset = $GLOBALS['meta']['spiplistes_charset_envoi'];
1521       
1522        if($charset != $GLOBALS['meta']['charset'])
1523        {
1524                include_spip('inc/charsets');
1525                if($format == 'html') {
1526                        $message_html = unicode2charset(charset2unicode($message_html), $charset);
1527                }
1528                //$message_texte = unicode2charset(charset2unicode($message_texte), $charset);
1529                $message_texte = spiplistes_translate_2_charset ($message_texte, $charset);
1530        }
1531        $email_a_envoyer = array();
1532        $email_a_envoyer['texte'] = new phpMail('', $objet, '', $message_texte, $charset);
1533        if($format == 'html') {
1534                $email_a_envoyer['html'] = new phpMail('', $objet, $message_html, $message_texte, $charset);
1535                $email_a_envoyer['html']->Body = "<html>\n\n<body>\n\n" . $message_html . "\n\n</body></html>";
1536                $email_a_envoyer['html']->AltBody = $message_texte;
1537        }
1538        $email_a_envoyer['texte']->Body = $message_texte ."\n\n";
1539        $email_a_envoyer[$format]->SetAddress($contexte['email'], $contexte['nom']);
1540       
1541        return($email_a_envoyer);
1542}
1543
1544/**
1545 * Envoyer un message en tenant compte des prefs SPIP-Listes
1546 * (SMTP ou mail(), simuler l'envoi,....)
1547 *
1548 * Le message ($message) peut être
1549 * - soit un string (au format texte)
1550 * - soit un array ('html' => $contenu_html, 'texte' => $contenu_texte)
1551 *
1552 * @param string $to
1553 * @param string $subject
1554 * @param string|array $message
1555 * @param string|bool $from
1556 * @param string $headers
1557 * @param string $format
1558 * @staticvar string|bool $opt_simuler_envoi
1559 * @version CP-20110618
1560 */
1561function spiplistes_envoyer_mail ($to
1562                                                                  , $subject
1563                                                                  , $message
1564                                                                  , $from = false
1565                                                                  , $headers = ''
1566                                                                  , $format = 'texte') {
1567       
1568        static $opt_simuler_envoi;
1569        if(!$opt_simuler_envoi) {
1570                $opt_simuler_envoi = spiplistes_pref_lire('opt_simuler_envoi');
1571        }
1572
1573        /**
1574         * si desabo, plus de format ! donc forcer a texte
1575         */
1576        $format = ($format == 'html') ? $format : 'texte';
1577       
1578        $charset = $GLOBALS['meta']['spiplistes_charset_envoi'];
1579       
1580        if ($charset != $GLOBALS['meta']['charset'])
1581        {
1582                if (isset($message['html']))
1583                {
1584                        $message['html'] = spiplistes_translate_2_charset ($message['html'], $charset, true);
1585                        $message['texte'] = spiplistes_translate_2_charset ($message['texte'], $charset, false);
1586                }
1587                else if (is_string ($message)) {
1588                        $message = array('texte' => $message);
1589                }
1590        }
1591       
1592        if (!$from)
1593        {
1594                $from = spiplistes_email_from_default();
1595        }
1596        if(strpos($from, '<') === false) {
1597                $fromname = spiplistes_nom_site_texte();
1598               
1599                if ($charset != $GLOBALS['meta']['charset']){
1600                        include_spip('inc/charsets');
1601                        $fromname = unicode2charset(charset2unicode($fromname),$charset);
1602                }
1603        }
1604        /**
1605         * @TODO: voir email_reply_to ?
1606         */
1607        $reply_to = 'no-reply'.preg_replace("|.*(@[a-z.]+)|i", "$1", email_valide($from));
1608       
1609        if($opt_simuler_envoi == 'oui') {
1610                spiplistes_log('!!! MAIL SIMULATION MODE !!!');
1611                $result = true;
1612        }
1613        else {
1614                include_once(_DIR_PLUGIN_SPIPLISTES.'inc/spiplistes_mail.inc.php');
1615               
1616                $email_a_envoyer = array();
1617               
1618                $return_path = spiplistes_return_path ($from);
1619               
1620                if(is_array($message) && ($format == 'html'))
1621                {
1622                        if($format=='html' && isset($message[$format])) {
1623                                $email_a_envoyer['html'] = new phpMail($to, $subject, $message['html'], $message['texte'], $charset);
1624                                $email_a_envoyer['html']->From = $from ; 
1625                                if($fromname) $email_a_envoyer['html']->FromName = $fromname ; 
1626                                $email_a_envoyer['html']->AddCustomHeader("Errors-To: ".$return_path); 
1627                                $email_a_envoyer['html']->AddCustomHeader("Reply-To: ".$from); 
1628                                $email_a_envoyer['html']->AddCustomHeader("Return-Path: ".$return_path);       
1629                                $email_a_envoyer['html']->SMTPKeepAlive = true;
1630                                $email_a_envoyer['html']->Body = $message['html'];
1631                                $email_a_envoyer['html']->AltBody = $message['texte'];
1632                        }
1633                }
1634               
1635                //$email_a_envoyer['texte'] = new phpMail($to, $subject, '', html_entity_decode($message), $charset);
1636                $email_a_envoyer['texte'] = new phpMail($to, $subject, '', $message['texte'], $charset);
1637                $email_a_envoyer['texte']->From = $from ;
1638                if($fromname) $email_a_envoyer['html']->FromName = $fromname ; 
1639                $email_a_envoyer['texte']->AddCustomHeader('Errors-To: '.$return_path); 
1640                $email_a_envoyer['texte']->AddCustomHeader('Reply-To: '.$reply_to); 
1641                $email_a_envoyer['texte']->AddCustomHeader('Return-Path: '.$return_path); 
1642                $email_a_envoyer['texte']->SMTPKeepAlive = true;
1643                $email_a_envoyer['texte']->Body = $message['texte'];
1644               
1645                if ($result = $email_a_envoyer[$format]->send())
1646                {
1647                        $email_a_envoyer['html']->SmtpClose();
1648                        $email_a_envoyer['texte']->SmtpClose(); 
1649                }
1650                                                       
1651                $msg = "email from $from to $to";
1652                spiplistes_log(!$result ? 'error: '.$msg.' not sent' : "$msg sent");
1653        }
1654        return($result);
1655}
1656
1657function spiplistes_listes_statuts_periodiques () {
1658        static $s;
1659        if($s === null) {
1660                $s = explode(';', _SPIPLISTES_LISTES_STATUTS_PERIODIQUES);
1661        }
1662        return ($s);
1663}
1664
1665/**
1666 * Creation du login a partir de l email donne'
1667 * @return string or false if error
1668 * @param $mail string
1669 */
1670function spiplistes_login_from_email ($mail) {
1671       
1672        $result = false;
1673
1674        if($mail = email_valide($mail)) {
1675               
1676                // partie gauche du mail
1677                $left = substr($mail, 0, strpos($mail, "@"));
1678               
1679                // demande la liste des logins pour assurer unicite
1680                $sql_result = sql_select('login', 'spip_auteurs');
1681                $logins_base = array();
1682                while($row = sql_fetch($sql_result)) {
1683                        $logins_base[] = $row['login'];
1684                }
1685                // creation du login
1686                for ($ii = 0; $ii < _SPIPLISTES_MAX_LOGIN_NN; $ii++) {
1687                        $login = $left . (($ii > 0) ? $ii : "");
1688                        if(!in_array($login, $logins_base))
1689                        {
1690                                $result = $login;
1691                                break;
1692                        }
1693                }       
1694        }
1695        return($result);
1696}
1697
1698/**
1699 * Donne la langue de la liste
1700 */
1701function spiplistes_listes_langue ($id_liste) {
1702        if(($id_liste = intval($id_liste)) > 0) {
1703                return(
1704                        sql_getfetsel(
1705                                'lang'
1706                                , "spip_listes"
1707                                , "id_liste=".sql_quote($id_liste)." LIMIT 1"
1708                        )
1709                );
1710        }
1711        return(false);
1712}
1713
1714/*
1715 */
1716function spiplistes_return_path ($from) {
1717        return(spiplistes_pref_lire_defaut ('email_return_path_defaut', $from));
1718}
1719
1720/**
1721 * Lire la valeur de $key dans les prefs (meta)
1722 * Si erreur (manquante) appliquer $defaut
1723 */
1724function spiplistes_pref_lire_defaut ($key, $default)
1725{
1726        $value = spiplistes_pref_lire($key);
1727        if(!$value) {
1728                $value = $default;
1729        }
1730        return($value);
1731}
1732
1733function spiplistes_str_auteurs ($nb)
1734{
1735        $result =
1736                ($nb > 0)
1737                ? _T('spiplistes:' . (($nb > 1) ? '_n_auteurs_' : '_1_auteur_'), array('n' => $nb))
1738                : 'erreur param'
1739                ;
1740        return($result);
1741}
1742
1743function spiplistes_str_abonnes ($nb) 
1744{
1745        $result =
1746                ($nb > 0)
1747                ? _T('spiplistes:' . (($nb > 1) ? '_n_abonnes_' : '1_abonne'), array('n' => $nb))
1748                : _T('spiplistes:aucun_abo')
1749                ;
1750        return($result);
1751}
1752
1753function spiplistes_str_abonnements ($nb) 
1754{
1755        $result =
1756                ($nb > 0)
1757                ? _T('spiplistes:' . (($nb > 1) ? '_n_abos_' : '_1_abo_'), array('n' => $nb))
1758                : _T('spiplistes:aucun_abonmt')
1759                ;
1760        return($result);
1761}
1762
1763
1764function spiplistes_str_listes ($nb) 
1765{
1766        $result =
1767                ($nb > 0)
1768                ? _T('spiplistes:' . (($nb > 1) ? 'n_listes' : '1_liste'), array('n' => $nb))
1769                : 'erreur param'
1770                ;
1771        return($result);
1772}
1773
1774
1775/******************************************************************************************/
1776/* SPIP-Listes est un systeme de gestion de listes d'abonnes et d'envoi d'information     */
1777/* par email pour SPIP. http://bloog.net/spip-listes                                      */
1778/* Copyright (C) 2004 Vincent CARON  v.caron<at>laposte.net                               */
1779/*                                                                                        */
1780/* Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes */
1781/* de la Licence Publique Generale GNU publiee par la Free Software Foundation            */
1782/* (version 2).                                                                           */
1783/*                                                                                        */
1784/* Ce programme est distribue car potentiellement utile, mais SANS AUCUNE GARANTIE,       */
1785/* ni explicite ni implicite, y compris les garanties de commercialisation ou             */
1786/* d'adaptation dans un but specifique. Reportez-vous a la Licence Publique Generale GNU  */
1787/* pour plus de details.                                                                  */
1788/*                                                                                        */
1789/* Vous devez avoir recu une copie de la Licence Publique Generale GNU                    */
1790/* en meme temps que ce programme ; si ce n'est pas le cas, ecrivez a la                  */
1791/* Free Software Foundation,                                                              */
1792/* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, Etats-Unis.                   */
1793/******************************************************************************************/
Note: See TracBrowser for help on using the repository browser.