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

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

Le cookie oubli pour le lien direct sur la page d'abonnement

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