source: spip-zone/_plugins_/spip-listes/trunk/inc/spiplistes_api.php @ 84132

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