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

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

documentaiton code + optimisation + ajout textes manquant dans lang

  • Property svn:keywords set to LastChangedBy LastChangedDate LastChangedRevision
File size: 47.3 KB
Line 
1<?php
2/**
3 * @package spiplistes
4 */
5 // $LastChangedRevision: 48255 $
6 // $LastChangedBy: paladin@quesaco.org $
7 // $LastChangedDate: 2011-05-29 08:34:27 +0000 (Sun, 29 May 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_formats_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 * Incruster les styles inline
1154 *
1155 * @version CP-20110510
1156 * @param string $texte_html
1157 * @return string
1158 */
1159function spiplistes_html_styles_inline ($texte_html) {
1160       
1161        if (strpos($texte_html, 'spip_documents_center') !== FALSE)
1162        {
1163                $pattern = array(
1164                        "{<span class='spip_document_\d* spip_documents spip_documents_center'>}m"
1165                );
1166                $replacement = array(
1167                        '<span style="display:block;text-align:center">'
1168                );
1169                $texte_html = preg_replace ($pattern, $replacement, $texte_html);
1170        }
1171        return ($texte_html);
1172}
1173
1174/**
1175 * Assembler/calculer un patron
1176 * @version CP-20090427
1177 * @param $patron string nom du patron
1178 * @param $contexte array
1179 * @return array le resultat html et texte seul dans un tableau
1180 */
1181function spiplistes_assembler_patron ($path_patron, $contexte) {
1182
1183        include_spip('inc/distant');
1184       
1185        // Pour recuperer_fond()
1186        // qui est passé en inc/utils en SPIP 2
1187        if (spiplistes_spip_est_inferieur_193()) {
1188                include_spip('public/assembler');
1189        }
1190       
1191        $patron_html = spiplistes_patron_find_in_path($path_patron, $contexte['lang'], false);
1192        $contexte['patron_html'] = $patron_html;
1193       
1194        $result_html =
1195                ($patron_html && find_in_path('patron_switch.html'))
1196                ? recuperer_fond('patron_switch', $contexte)
1197                : ''
1198                ;
1199       
1200        /**
1201         * Calculer le contenu texte à partir
1202         * du {patron}_texte s'il existe
1203         */
1204        $patron_texte = spiplistes_patron_find_in_path($path_patron, $contexte['lang'], true);
1205        unset($contexte['patron_html']);
1206        $contexte['patron_texte'] = $patron_texte;
1207        $result_texte = '';
1208        $texte_ok = false;
1209        if ($patron_texte && ($patron_texte != $patron_html))
1210        {
1211                spiplistes_debug_log('CREATE text version USING '.$patron_texte);
1212       
1213                if (find_in_path('patron_switch.html')) {
1214                        if($result_texte = recuperer_fond('patron_switch', $contexte))
1215                        {
1216                                $result_texte = spiplistes_courrier_version_texte($result_texte);
1217                        }
1218                        $texte_ok = true;
1219                }
1220        }
1221        /**
1222         * si {patron}_texte manque, ou vide,
1223         * calculer a partir de la version html
1224         */
1225        if (!$texte_ok) {
1226                $result_texte = spiplistes_courrier_version_texte($result_html);
1227        }
1228        // eliminer les espaces pour un vrai calcul de poids
1229        $result_html = trim($result_html);
1230        $result_texte = trim($result_texte);
1231        $result = array ($result_html, $result_texte);
1232       
1233        return($result);
1234}
1235
1236/**
1237 * donne contenu tampon au format html (CP-20071013) et texte
1238 * @return array (string $html, string $texte)
1239 */
1240function spiplistes_tampon_assembler_patron () {
1241        //spiplistes_log_api("calculer tampon");
1242        $contexte = array();
1243        $path_patron = spiplistes_pref_lire('tampon_patron');
1244        //spiplistes_log_api($path_patron);
1245        if(!empty($path_patron))
1246        {
1247                foreach(explode(",", _SPIPLISTES_TAMPON_CLES) as $key) {
1248                        $s = spiplistes_pref_lire($key);
1249                        $contexte[$key] = (!empty($s) && ($s != 'non')) ? $s : '';
1250                }
1251                $result = spiplistes_assembler_patron(_SPIPLISTES_PATRONS_TAMPON_DIR . $path_patron, $contexte);
1252        }
1253        else {
1254                $result = array("", "");
1255        }
1256        return($result);
1257}
1258
1259function spiplistes_pied_page_assembler_patron ($id_liste, $lang = false) {
1260       
1261        $result = array("", "");
1262       
1263        if(($id_liste = intval($id_liste)) > 0)
1264        {
1265                $pied_patron = sql_getfetsel('pied_page', 'spip_listes', "id_liste=".sql_quote($id_liste), '','',1);
1266               
1267                $pied_patron =
1268                        (!$pied_patron)
1269                        // si patron vide (ancienne version de SPIP-Listes ?), appliquer le patron par defaut
1270                        ? _SPIPLISTES_PATRONS_PIED_DEFAUT
1271                        : $pied_patron
1272                        ;
1273                if(strlen($pied_patron) > _SPIPLISTES_PATRON_FILENAMEMAX)
1274                {
1275                        // probablement le contenu du pied (SPIP-Listes <= 1.9.2 ?)
1276                        // rester compatible avec les anciennes version de SPIP-Listes
1277                        // qui stoquaient le patron assemble' en base
1278                        $pied_texte = spiplistes_courrier_version_texte($pied_html = $pied_patron);
1279                        $result = array($pied_html, $pied_texte);
1280                }
1281                else if(strlen($pied_patron) && ($pied_patron != _SPIPLISTES_PATRON_PIED_IGNORE)) {
1282                       
1283                        if(!$lang) {
1284                                $lang = spiplistes_listes_langue($id_liste) || $GLOBALS['spip_lang'];
1285                        }
1286                        $contexte = array('lang' => $lang);
1287                        $result = spiplistes_assembler_patron (
1288                                _SPIPLISTES_PATRONS_PIED_DIR . $pied_patron
1289                                , $contexte
1290                        );
1291                }
1292        }
1293        return ($result);
1294}
1295
1296function spiplistes_format_valide ($format) {
1297        return(in_array($format, array("non", "texte", "html")) ? $format : false);
1298}
1299
1300/**
1301 ******************************************************************************
1302        Les fonctions spiplistes_auteurs_*() concernent les auteurs
1303       
1304        Table cible : spip_auteurs
1305       
1306 ******************************************************************************
1307 */
1308
1309/**
1310 * @version CP-20080503
1311 * soit update cookie du cookie transmis
1312 * soit update cookie de l'email transmis
1313 */
1314function spiplistes_auteurs_cookie_oubli_updateq ($cookie_oubli, $where, $where_is_cookie = false) {
1315        if(is_string($where)) {
1316                $where = (($where_is_cookie) ? "cookie_oubli" : "email")
1317                        . "=" . sql_quote($where) . " LIMIT 1";
1318        }
1319        return(sql_update('spip_auteurs', array('cookie_oubli' => sql_quote($cookie_oubli)), $where));
1320}
1321
1322/**
1323 * @version CP-20080629
1324 * soit update cookie du cookie transmis
1325 * soit update cookie de l'email transmis
1326 */
1327function spiplistes_date_heure_valide ($date_heure) {
1328        $date_array = recup_date($date_heure);
1329        if($date_array) {
1330                list($annee, $mois, $jour) = $date_array;
1331                list($heures, $minutes, $secondes) = recup_heure($date_heure);
1332                return(array($annee, $mois, $jour, $heures, $minutes, $secondes));
1333        }
1334        return(false);
1335}
1336
1337/**
1338 * Nombre total d'auteurs (ou visiteur, ou perso) elligibles
1339 * Nota: un compte 'nouveau' est un compte visiteur (inscription) qui ne s'est pas encore connecté
1340 * Nota2: un compte créé via l'espace privé mais pas encore connecté
1341 * n'a pas le statut 'nouveau' mais celui de son groupe
1342 * @version CP-200080519
1343 */
1344function spiplistes_auteurs_elligibles_compter ()
1345{
1346        static $nb;
1347        if(!$nb)
1348        {
1349                $sql_where = array(
1350                          'statut!='.sql_quote('5poubelle')
1351                        , 'statut!='.sql_quote('nouveau')
1352                        );
1353                $nb = sql_countsel('spip_auteurs', $sql_where);
1354        }
1355        return($nb);
1356}
1357
1358/**
1359 * Total des auteurs qui ne sont pas abonnes a une liste
1360 * @version CP-200080519
1361 */
1362function spiplistes_auteurs_non_abonnes_compter ()
1363{
1364        static $nb;
1365        if($nb === null)
1366        {
1367                $selection =
1368                        (spiplistes_spip_est_inferieur_193())
1369                        ? 'SELECT id_auteur FROM spip_auteurs_listes GROUP BY id_auteur'
1370                        : sql_select('id_auteur', 'spip_auteurs_listes', '','id_auteur','','','','',false)
1371                ;
1372                $sql_where = array(
1373                          'statut!='.sql_quote('5poubelle')
1374                        , 'statut!='.sql_quote('nouveau')
1375                        , 'id_auteur NOT IN ('.$selection.')'
1376                        );
1377                $nb = sql_countsel('spip_auteurs', $sql_where);
1378        }
1379        return($nb);
1380}
1381
1382/**
1383 * CP-20080511 20110315
1384 * Renvoie la selection pour un seul auteur
1385 * @return array OR false
1386 */
1387function spiplistes_auteurs_auteur_select ($select, $where = array())
1388{
1389        //$result = sql_select($select, 'spip_auteurs', $where, '', '', 1);
1390        $auteur = sql_fetsel($select, 'spip_auteurs', $where, '', '', 1);
1391        return($auteur);
1392}
1393
1394/**
1395 * CP-20080511
1396 */
1397function spiplistes_auteurs_auteur_delete ($sql_where) {
1398        // détruire ou mettre à la poubelle ?
1399        // SPIP ne détruit pas lui !
1400        // dans le doute...
1401        // if(($result = sql_delete('spip_auteurs', $sql_where." LIMIT 1")) === false) {
1402        if(($result = sql_update(
1403                                        "spip_auteurs"
1404                                        , array('statut' => sql_quote('5poubelle'))
1405                                        , $sql_where . " LIMIT 1"
1406                                )) === false) {
1407                spiplistes_sqlerror_log("auteurs_auteur_delete");
1408        }
1409        return($result);
1410}
1411
1412/**
1413 * CP-20080511
1414 * @return int|bool
1415 */
1416function spiplistes_auteurs_auteur_insertq ($champs_array) {
1417        $id_auteur = sql_insertq('spip_auteurs', $champs_array);
1418        return($id_auteur);
1419}
1420
1421/**
1422 * CP-20090409
1423 */
1424function spiplistes_auteurs_auteur_valider ($id_auteur, $as_redact = false) {
1425        if($id_auteur = intval($id_auteur)) {
1426                if(($result = sql_update(
1427                                                "spip_auteurs_listes"
1428                                                , array('statut' => sql_quote('valide'))
1429                                                , "id_auteur=$id_auteur LIMIT 1"
1430                                        )) === false) {
1431                        spiplistes_sqlerror_log("auteurs_auteur_valider");
1432                }
1433                else {
1434                       
1435                }
1436        }
1437        return($result);
1438}
1439
1440/**
1441 * CP-20110315
1442 * @return bool
1443 */
1444function spiplistes_auteurs_auteur_statut_modifier ($id_auteur, $statut)
1445{
1446        spiplistes_debug_log ('modification status for auteur #'.$id_auteur);
1447        $result = sql_update(
1448                                        'spip_auteurs'
1449                                        , array('statut' => sql_quote($statut))
1450                                        , 'id_auteur='.$id_auteur.' LIMIT 1'
1451                                );
1452        return ($result);
1453}
1454
1455/**
1456 * CP-20110321
1457 * Retourne une version texte pure du nom du site
1458 * @return string
1459 */
1460function spiplistes_nom_site_texte ($lang = '') {
1461       
1462        static $nom_site;
1463        $lang = trim ($lang);
1464        if (empty($lang)) {
1465                $lang = $GLOBALS['meta']['langue_site'];
1466        }
1467       
1468        if ($nom_site === null) 
1469        {
1470                $nom_site = array();
1471        }
1472        if (!isset($nom_site[$lang]))
1473        {
1474                $n = strip_tags(html_entity_decode(extraire_multi($GLOBALS['meta']['nom_site'])));
1475               
1476                // incorrect avec utf-8. Abime les diacritiques
1477                //$n = preg_replace ('@\s*@', ' ', $n);
1478               
1479                $nom_site[$lang] = trim($n);
1480        }
1481        return ($nom_site[$lang]);
1482}
1483
1484/**
1485 * @version CP-20110321
1486 * @return string
1487 */
1488function spiplistes_texte_2_charset ($texte, $charset) {
1489        if ($charset && ($charset != $GLOBALS['meta']['charset'])) {
1490                include_spip('inc/charsets');
1491                $texte = unicode2charset(charset2unicode($texte), $charset);
1492        }
1493        return ($texte);
1494}
1495
1496/**
1497 * utiliser l'api pour pouvoir envoyer par smtp si besoin
1498 * @version CP-20090111
1499 */
1500function spiplistes_envoyer_mail ($to, $subject, $message, $from = false, $headers = '', $format = 'texte') {
1501       
1502        static $opt_simuler_envoi;
1503
1504        // si desabo, plus de format ! donc forcer a texte
1505        $format = ($format == 'html') ? $format : 'texte';
1506       
1507        $charset = $GLOBALS['meta']['spiplistes_charset_envoi'];
1508        if(!$opt_simuler_envoi) {
1509                $opt_simuler_envoi = spiplistes_pref_lire('opt_simuler_envoi');
1510        }
1511        if (!$from)
1512        {
1513                $from = spiplistes_email_from_default();
1514        }
1515        if(strpos($from, '<') === false) {
1516                $fromname = spiplistes_nom_site_texte();
1517               
1518                if ($charset != $GLOBALS['meta']['charset']){
1519                        include_spip('inc/charsets');
1520                        $fromname = unicode2charset(charset2unicode($fromname),$charset);
1521                }
1522        }
1523        // @TODO: voir email_reply_to ?
1524        $reply_to = 'no-reply'.preg_replace("|.*(@[a-z.]+)|i", "$1", email_valide($from));
1525       
1526        if($opt_simuler_envoi == 'oui') {
1527                spiplistes_log("!!! MAIL SIMULATION MODE !!!");
1528                $result = true;
1529        }
1530        else {
1531                include_once(_DIR_PLUGIN_SPIPLISTES.'inc/spiplistes_mail.inc.php');
1532               
1533                $email_a_envoyer = array();
1534               
1535                $return_path = spiplistes_return_path($from);
1536               
1537                if(is_array($message))
1538                {
1539                        if($format=='html' && isset($message[$format])) {
1540                                $email_a_envoyer['html'] = new phpMail($to, $subject, $message['html'], $message['texte'], $charset);
1541                                $email_a_envoyer['html']->From = $from ; 
1542                                if($fromname) $email_a_envoyer['html']->FromName = $fromname ; 
1543                                $email_a_envoyer['html']->AddCustomHeader("Errors-To: ".$return_path); 
1544                                $email_a_envoyer['html']->AddCustomHeader("Reply-To: ".$from); 
1545                                $email_a_envoyer['html']->AddCustomHeader("Return-Path: ".$return_path);       
1546                                $email_a_envoyer['html']->SMTPKeepAlive = true;
1547                                $email_a_envoyer['html']->Body = $message['html']->Body;
1548                                $email_a_envoyer['html']->AltBody = $message['html']->AltBody;
1549                        }
1550                        $message = $message['texte']->Body;
1551                }
1552                //$message = spiplistes_html_entity_decode ($message, $charset);
1553                $message = spiplistes_translate_2_charset ($message, $charset, true);
1554               
1555                //$email_a_envoyer['texte'] = new phpMail($to, $subject, '', html_entity_decode($message), $charset);
1556                $email_a_envoyer['texte'] = new phpMail($to, $subject, '', $message, $charset);
1557                $email_a_envoyer['texte']->From = $from ;
1558                if($fromname) $email_a_envoyer['html']->FromName = $fromname ; 
1559                $email_a_envoyer['texte']->AddCustomHeader('Errors-To: '.$return_path); 
1560                $email_a_envoyer['texte']->AddCustomHeader('Reply-To: '.$reply_to); 
1561                $email_a_envoyer['texte']->AddCustomHeader('Return-Path: '.$return_path); 
1562                $email_a_envoyer['texte']->SMTPKeepAlive = true;
1563               
1564                $result = $email_a_envoyer[$format]->send();
1565               
1566                $msg = "email from $from to $to";
1567                spiplistes_log(!$result ? "error: $msg not sent" : "$msg sent");
1568        }
1569        return($result);
1570}
1571
1572function spiplistes_listes_statuts_periodiques () {
1573        static $s;
1574        if($s === null) {
1575                $s = explode(';', _SPIPLISTES_LISTES_STATUTS_PERIODIQUES);
1576        }
1577        return ($s);
1578}
1579
1580/**
1581 * Creation du login a partir de l email donne'
1582 * @return string or false if error
1583 * @param $mail string
1584 */
1585function spiplistes_login_from_email ($mail) {
1586       
1587        $result = false;
1588
1589        if($mail = email_valide($mail)) {
1590               
1591                // partie gauche du mail
1592                $left = substr($mail, 0, strpos($mail, "@"));
1593               
1594                // demande la liste des logins pour assurer unicite
1595                $sql_result = sql_select('login', 'spip_auteurs');
1596                $logins_base = array();
1597                while($row = sql_fetch($sql_result)) {
1598                        $logins_base[] = $row['login'];
1599                }
1600                // creation du login
1601                for ($ii = 0; $ii < _SPIPLISTES_MAX_LOGIN_NN; $ii++) {
1602                        $login = $left . (($ii > 0) ? $ii : "");
1603                        if(!in_array($login, $logins_base))
1604                        {
1605                                $result = $login;
1606                                break;
1607                        }
1608                }       
1609        }
1610        return($result);
1611}
1612
1613/**
1614 * Donne la langue de la liste
1615 */
1616function spiplistes_listes_langue ($id_liste) {
1617        if(($id_liste = intval($id_liste)) > 0) {
1618                return(
1619                        sql_getfetsel(
1620                                'lang'
1621                                , "spip_listes"
1622                                , "id_liste=".sql_quote($id_liste)." LIMIT 1"
1623                        )
1624                );
1625        }
1626        return(false);
1627}
1628
1629/*
1630 */
1631function spiplistes_return_path ($from) {
1632        return(spiplistes_pref_lire_defaut ('email_return_path_defaut', $from));
1633}
1634
1635/**
1636 * Lire la valeur de $key dans les prefs (meta)
1637 * Si erreur (manquante) appliquer $defaut
1638 */
1639function spiplistes_pref_lire_defaut ($key, $default)
1640{
1641        $value = spiplistes_pref_lire($key);
1642        if(!$value) {
1643                $value = $default;
1644        }
1645        return($value);
1646}
1647
1648function spiplistes_str_auteurs ($nb)
1649{
1650        $result =
1651                ($nb > 0)
1652                ? _T('spiplistes:' . (($nb > 1) ? '_n_auteurs_' : '_1_auteur_'), array('n' => $nb))
1653                : 'erreur param'
1654                ;
1655        return($result);
1656}
1657
1658function spiplistes_str_abonnes ($nb) 
1659{
1660        $result =
1661                ($nb > 0)
1662                ? _T('spiplistes:' . (($nb > 1) ? '_n_abonnes_' : '1_abonne'), array('n' => $nb))
1663                : _T('spiplistes:aucun_abo')
1664                ;
1665        return($result);
1666}
1667
1668function spiplistes_str_abonnements ($nb) 
1669{
1670        $result =
1671                ($nb > 0)
1672                ? _T('spiplistes:' . (($nb > 1) ? '_n_abos_' : '_1_abo_'), array('n' => $nb))
1673                : _T('spiplistes:aucun_abonmt')
1674                ;
1675        return($result);
1676}
1677
1678
1679function spiplistes_str_listes ($nb) 
1680{
1681        $result =
1682                ($nb > 0)
1683                ? _T('spiplistes:' . (($nb > 1) ? 'n_listes' : '1_liste'), array('n' => $nb))
1684                : 'erreur param'
1685                ;
1686        return($result);
1687}
1688
1689/******************************************************************************************/
1690/* SPIP-Listes est un systeme de gestion de listes d'abonnes et d'envoi d'information     */
1691/* par email pour SPIP. http://bloog.net/spip-listes                                      */
1692/* Copyright (C) 2004 Vincent CARON  v.caron<at>laposte.net                               */
1693/*                                                                                        */
1694/* Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes */
1695/* de la Licence Publique Generale GNU publiee par la Free Software Foundation            */
1696/* (version 2).                                                                           */
1697/*                                                                                        */
1698/* Ce programme est distribue car potentiellement utile, mais SANS AUCUNE GARANTIE,       */
1699/* ni explicite ni implicite, y compris les garanties de commercialisation ou             */
1700/* d'adaptation dans un but specifique. Reportez-vous a la Licence Publique Generale GNU  */
1701/* pour plus de details.                                                                  */
1702/*                                                                                        */
1703/* Vous devez avoir recu une copie de la Licence Publique Generale GNU                    */
1704/* en meme temps que ce programme ; si ce n'est pas le cas, ecrivez a la                  */
1705/* Free Software Foundation,                                                              */
1706/* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, Etats-Unis.                   */
1707/******************************************************************************************/
Note: See TracBrowser for help on using the repository browser.