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

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

La maintenance des listes prend en compte les id_auteur absents de la table des auteurs en proposant de les désabonner. Pour une table des abonnements plus propre.

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