source: spip-zone/_plugins_/spip-listes/trunk/inc/spiplistes_meleuse.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: 31.0 KB
Line 
1<?php
2/**
3 * La meleuse s'occupe des envois de courriers dont les etiquettes ont
4 * ete preparees par la trieuse, ou dont les courriers ont ete prepares
5 * via le back-office (cas des envois de test).
6 *
7 * Pour en savoir plus,
8 * voir la documentation sur la fonction {@link spiplistes_meleuse()}.
9 * @package spiplistes
10 */
11 // $LastChangedRevision: 84132 $
12 // $LastChangedBy: arthemis78@free.fr $
13 // $LastChangedDate: 2014-08-10 16:09:53 +0000 (Sun, 10 Aug 2014) $
14
15/******************************************************************************************/
16/* SPIP-Listes est un systeme de gestion de listes d'abonnes et d'envoi d'information     */
17/* par email pour SPIP. http://bloog.net/spip-listes                                      */
18/* Copyright (C) 2004 Vincent CARON  v.caron<at>laposte.net                               */
19/*                                                                                        */
20/* Ce programme est libre, vous pouvez le redistribuer et/ou le modifier selon les termes */
21/* de la Licence Publique Generale GNU publiee par la Free Software Foundation            */
22/* (version 2).                                                                           */
23/*                                                                                        */
24/* Ce programme est distribue car potentiellement utile, mais SANS AUCUNE GARANTIE,       */
25/* ni explicite ni implicite, y compris les garanties de commercialisation ou             */
26/* d'adaptation dans un but specifique. Reportez-vous a la Licence Publique Generale GNU  */
27/* pour plus de details.                                                                  */
28/*                                                                                        */
29/* Vous devez avoir recu une copie de la Licence Publique Generale GNU                    */
30/* en meme temps que ce programme ; si ce n'est pas le cas, ecrivez a la                  */
31/* Free Software Foundation,                                                              */
32/* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, Etats-Unis.                   */
33/******************************************************************************************/
34
35if (!defined('_ECRIRE_INC_VERSION')) return;
36
37include_spip ('inc/utils');
38include_spip ('inc/filtres');    /* email_valide() */
39include_spip ('inc/acces');      /* creer_uniqid() */
40include_spip('inc/charsets');
41include_spip('inc/mail');
42
43include_spip('inc/spiplistes_api_globales');
44
45/**
46 * Envoie le courrier pret au depart
47 *
48 * Prend dans le panier des courriers a envoyer (spip_courriers) les encours
49 * - formate le titre, texte pour l'envoi
50 *
51 *
52 * les etiquettes sont dans la queue d'envois (spip_auteurs_courriers)
53 * - id_auteur (pour reprendre l'adresse mail de id_auteur)
54 * - id_courrier (le courrier a dupliquer/envoyer)
55 *
56 * la queue (spip_auteurs_courriers) a ete remplie par cron_spiplistes_cron()
57 * se sert de la queue pour ventiler les envois par lots
58
59 * le courrier (spip_courriers) doit avoir date <= time() et statut 'encour'
60 * si email_test, la meleuse envoie le courrier a email_test,
61 *  supprime email_test du courrier
62 *  et repositionne le statut du courrier en 'redac'
63 * si pas email_test mais id_liste,
64 *  regarde la queue d'envois (spip_auteurs_courriers)
65 *  et passe le statut du courrier (spip_courriers) a :
66 *              'publie' si type == 'nl' (newsletter)
67 *              'auto' si type == 'auto' (liste programmee)
68 *      et envoie les courriers precises aux abonnes de cette liste
69 *      et supprime l'identifiant du courrier dans la queue d'envois (spip_auteurs_courriers)
70
71 * renvoie:
72 * - nul, si la tache n'a pas a etre effectuee
73 * - positif, si la tache a ete effectuee
74 * - negatif, si la tache doit etre poursuivie ou recommencee
75 *
76 * @param int $last_time
77 * @return int
78 */
79function spiplistes_meleuse ($last_time) {
80
81        //spiplistes_debug_log('spiplistes_meleuse()');
82       
83        include_spip('inc/meta');
84        include_spip('inc/texte');
85        include_spip('inc/filtres');
86        include_spip('inc/acces');
87        include_spip('inc/spiplistes_api');
88        include_spip('inc/spiplistes_api_courrier');
89       
90        include_once(_DIR_PLUGIN_SPIPLISTES.'inc/spiplistes_mail.inc.php');
91
92        // initialise les options (preferences)
93        foreach(array(
94                'opt_simuler_envoi'
95                , 'opt_suspendre_meleuse'
96                , 'opt_lien_en_tete_courrier', 'lien_patron'
97                , 'opt_ajout_pied_courrier', 'pied_patron'
98                , 'opt_ajout_tampon_editeur'
99                , 'opt_personnaliser_courrier'
100                , 'opt_log_voir_destinataire'
101                , 'opt_ajout_lien_desabo'
102                ) as $key) {
103                $$key = spiplistes_pref_lire($key);
104        }
105       
106        $sql_vide = sql_quote('');
107        $nb_etiquettes = spiplistes_courriers_en_queue_compter('etat='.$sql_vide);
108       
109       
110        $prefix_log = _SPIPLISTES_PREFIX_LOG;
111       
112        // si meleuse suspendue, signale en log
113        if($opt_suspendre_meleuse == 'oui') {
114                spiplistes_log($prefix_log.'SUSPEND MODE !!!');
115                return(0 - $last_time);
116        }
117
118        if($nb_etiquettes) {
119               
120                $eol = "\n";
121                $eol2 =$eol.$eol;
122                $body_html_debut = '<html>'
123                        . $eol
124                        . '<body TOPMARGIN=0 LEFTMARGIN=0 MARGINHEIGHT=0 MARGINWIDTH=0 style="margin:0;padding:0;">'
125                        . $eol;
126                $body_html_fin = $eol.'</body></html>';
127                $charset_spip = $GLOBALS['meta']['charset'];
128                $charset_dest = $GLOBALS['meta']['spiplistes_charset_envoi'];
129
130                spiplistes_log($prefix_log.$nb_etiquettes.' job(s), distribution...');
131               
132                $log_voir_destinataire = ($opt_log_voir_destinataire == 'oui');
133                $simuler_envoi = ($opt_simuler_envoi == 'oui');
134               
135                // signale en log si mode simulation
136                if($simuler_envoi) {
137                        spiplistes_log($prefix_log.'SIMULATION MODE !!!');
138                }
139
140                // prepare le tampon editeur
141                if($opt_ajout_tampon_editeur == 'oui')
142                {
143                        list($tampon_html, $tampon_texte) = spiplistes_tampon_assembler_patron();
144                }
145                else {
146                        $tampon_html = $tampon_texte = '';
147                }
148               
149                // prendre la premiere etiquette sur le tas et traiter son courrier
150                $sql_courrier_select = array(
151                        'titre', 'texte', 'message_texte', 'type'
152                        , 'id_courrier', 'id_liste', 'email_test', 'total_abonnes', 'date_debut_envoi'
153                        );
154                if($id_courrier = 
155                        intval(spiplistes_courriers_en_queue_premier('id_courrier', 'etat='.$sql_vide))
156                ) {
157                        $sql_courrier_a_traiter = spiplistes_courriers_casier_premier(
158                                  $sql_courrier_select
159                                , 'id_courrier='.sql_quote($id_courrier)
160                        );
161                        spiplistes_debug_log ($prefix_log.'etiquette en cours pour id_courrier #'.$id_courrier);
162                } else {
163                        // un vieux bug dans une ancienne version, eradique depuis (j'espere ;-)
164                        //spiplistes_log($prefix_log."premiere etiquette en erreur. id_courier = 0. Supprimer cette etiquette manuellement !");
165                        spiplistes_log(_T('spiplistes:erreur_queue_supprimer_courrier'
166                                                          , array('s' => $prefix_log))
167                                                   );
168                }
169               
170                // boucle (sur LIMIT 1) pour pouvoir sortir par break si erreur
171                while($row = sql_fetch($sql_courrier_a_traiter)) {
172               
173                        foreach($sql_courrier_select as $key) {
174                                $$key = $row[$key];
175                        }
176                        foreach(array('id_courrier','id_liste','total_abonnes') as $key) {
177                                $$key = intval($$key);
178                        }
179                        // objet (subject) ne peut pas être en html ?!
180                        // sauf pour le webmail (et encore)
181                        $objet_html = filtrer_entites(typo(spiplistes_calculer_balise_titre(extraire_multi($titre))));
182                        $page_html = stripslashes($texte);
183                        $message_texte = stripslashes($message_texte);
184                       
185                        $nb_emails = array();
186                       
187                        // compteur pour la session uniquement
188                        // le total de chaque sera ajoute en fin de session
189                        $nb_emails_envoyes =
190                                $nb_emails_echec = 
191                                $nb_emails_non_envoyes = 
192                                $nb_emails['texte'] = 
193                                $nb_emails['html'] = 0
194                                ;
195                       
196                        $str_log = 'id_courrier #'.$id_courrier;
197                       
198                        //////////////////////////
199                        // Determiner email de l emetteur
200                        if($is_a_test = email_valide($email_test)) {
201                                // courrier a destination adresse email de test
202                                $str_log .= ' TO: '.$email_test.' (TEST)';
203                        } 
204                        else if($id_liste > 0) {
205                                // courrier a destination des abonnes d'une liste
206                                $total_abonnes = spiplistes_listes_nb_abonnes_compter($id_liste);
207                                $str_log .= ' TO id_liste #'.$id_liste.' ('.$total_abonnes.' users)';
208       
209                                $lang = spiplistes_listes_langue($id_liste);
210
211                                if($lang != '') {
212                                        $GLOBALS['spip_lang'] = $lang;
213                                }
214                               
215                                $contexte = array('lang' => $lang);
216                               
217                                list($pied_html, $pied_texte) = spiplistes_pied_page_assembler_patron($id_liste, $lang);
218                        }
219                        else {
220                                // erreur dans un script d'appel ? Ou url ? Ou base erreur ?
221                                $str_log .= ' [ERROR] MISSING PARAMS (id_liste AND email_test)';
222                                spiplistes_courrier_statut_modifier($id_courrier, _SPIPLISTES_COURRIER_STATUT_ERREUR);
223                                // quitte while() principal
224                                break;
225                        }
226                       
227                        /**
228                         * noter email emetteur de la liste
229                         */
230                        $email_envoi = spiplistes_listes_email_emetteur ($id_liste);
231                       
232                        /**
233                         * si pas d'adresse emetteur, va chercher adresse par defaut
234                         */
235                        if (!$email_envoi)
236                        {
237                                $email_envoi = spiplistes_email_from_default();
238                                $email_reply_to = spiplistes_pref_lire_defaut('email_reply_to', $from);
239                        }
240                        else {
241                                $email_reply_to = $email_envoi;
242                        }
243                       
244                        if(!$is_a_test && !($email_envoi)) { 
245                                $str_log .= ' [ERROR] ID_LISTE #'.$id_liste.' or from email MISSING'; 
246                                spiplistes_courrier_statut_modifier($id_courrier, _SPIPLISTES_COURRIER_STATUT_ERREUR);
247                                // quitte while() principal
248                                break;
249                        }
250                        $from = $email_envoi;
251                        if($from_valide = email_valide($from)) {
252                                if(strpos($from, '<') === false) {
253                                        $fromname = spiplistes_nom_site_texte ($lang);
254                                        $fromname = extraire_multi($GLOBALS['meta']['nom_site']);
255                                        if ($charset_dest!=$charset_spip)
256                                        {
257                                                include_spip('inc/charsets');
258                                                $fromname = unicode2charset(charset2unicode($fromname),$charset_dest);
259                                        }
260                                }
261                        }
262                        else {
263                                spiplistes_log('[ERROR] from address incorrect: '.$from);
264                                if($is_a_test) {
265                                        spiplistes_courriers_statut_redac ($id_courrier);
266                                }
267                                // break; // garder pour incrementer les erreurs des listes
268                        }
269                       
270                       
271                       
272                        $return_path = spiplistes_pref_lire_defaut('email_return_path_defaut', $from);
273                       
274                        ////////////////////////////////////
275                        // Prepare la version texte
276                        $objet_texte = $titre;
277                        $page_texte = ($message_texte !='')
278                                ? $message_texte
279                                : spiplistes_courrier_version_texte($page_html)
280                                ;
281                       
282                        /**
283                         * Ajouter le lien de courrier
284                         * en tête du courrier
285                         * si demandé en page de configuration
286                         */
287                        if(
288                                ($opt_lien_en_tete_courrier == 'oui') 
289                                && !empty($lien_patron)
290                        ) {
291                                list($lien_html, $lien_texte) = spiplistes_courriers_assembler_patron (
292                                        _SPIPLISTES_PATRONS_TETE_DIR . $lien_patron
293                                        , array('id_courrier' => $id_courrier
294                                                        , 'lang' => $lang
295                                                        , 'titre' => $objet_html)
296                                        );
297                                $lien_html = spiplistes_html_compacte ($lien_html);
298                                $page_html = $lien_html . $page_html;
299                                $page_texte = $lien_texte . $page_texte;
300                        }
301
302                        /**
303                         * transcrire le contenu
304                         * dans le charset souhaité
305                         * indiqué en page de configuration
306                         */
307                        if ($charset_dest != $charset_spip)
308                        {
309                                spiplistes_debug_log ('TRANSLATION '.$charset_spip.' TO '.$charset_dest);
310                               
311                                include_spip('inc/charsets');
312                                foreach(array(
313                                          'objet_html', 'objet_texte'
314                                        , 'page_html', 'page_texte'
315                                        , 'pied_html', 'pied_texte'
316                                        //, 'pied_rappel_html', 'pied_rappel_texte'
317                                        , 'tampon_html', 'tampon_texte') as $key) 
318                                {
319                                        if(!empty($$key)) {
320                                                $$key = spiplistes_translate_2_charset (
321                                                        $$key
322                                                        , $charset_dest
323                                                        , (strpos($key, 'texte') === false)
324                                                        );
325                                        }
326                                }
327                        }
328                       
329                        /**
330                         * corrige les liens relatifs
331                         * (celui de texte a deja ete corrige par la trieuse (cron)
332                         */
333                        foreach(array('pied_html', 'pied_texte'
334                                //, 'pied_rappel_html', 'pied_rappel_texte'
335                                , 'tampon_html', 'tampon_texte') as $key) {
336                                if(!empty($$key)) {
337                                        $$key = spiplistes_liens_absolus ($$key);
338                                }
339                        }
340
341                        /**
342                         * Adapter le CSS produit par SPIP
343                         * (les class spip-center, etc.
344                         * sont remplacées par style en inline)
345                         */
346                        foreach(array(
347                                  'objet_html'
348                                , 'page_html'
349                                , 'pied_html'
350                                //, 'pied_rappel_html', 'pied_rappel_texte'
351                                , 'tampon_html') as $key) 
352                        {
353                                if(!empty($$key)) {
354                                        $$key = spiplistes_html_styles_inline ($$key);
355                                }
356                        }
357                       
358                        $email_a_envoyer = array();
359                        $email_a_envoyer['texte'] = new phpMail('', $objet_texte, ''
360                                                                                                        , $page_texte, $charset_dest);
361                        $email_a_envoyer['texte']->From = $from ; 
362                        if($fromname) $email_a_envoyer['texte']->FromName = $fromname ;
363                        // Errors-To:,    Non-standard @see: http://www.ietf.org/rfc/rfc2076.txt
364                        //$email_a_envoyer['texte']->AddCustomHeader('Errors-To: '.$return_path);
365                        $email_a_envoyer['texte']->AddCustomHeader('Reply-To: '.$email_reply_to); 
366                        $email_a_envoyer['texte']->AddCustomHeader('Return-Path: '.$return_path); 
367                        $email_a_envoyer['texte']->SMTPKeepAlive = true;
368
369                        //$email_a_envoyer['html'] = new phpMail('', $objet_html, $page_html, $page_texte, $charset_dest);
370                        $email_a_envoyer['html'] = new phpMail(''
371                                                                                                   , $objet_html
372                                                                                                   , $page_html
373                                                                                                   , $page_texte
374                                                                                                   , $charset_dest
375                                                                                                   );
376                        $email_a_envoyer['html']->From = $from ; 
377                        if($fromname) {
378                                $email_a_envoyer['html']->FromName = $fromname ;
379                        }
380                        //$email_a_envoyer['html']->AddCustomHeader('Errors-To: '.$return_path);
381                        $email_a_envoyer['html']->AddCustomHeader('Reply-To: '.$email_reply_to); 
382                        $email_a_envoyer['html']->AddCustomHeader('Return-Path: '.$return_path);       
383                        $email_a_envoyer['html']->SMTPKeepAlive = true;
384               
385                        $str_log .= ' FROM: ' . $from
386                                . ' FROMNAME: ' . $fromname
387                                . ' REPLY-TO: ' . $email_reply_to
388                                . ' RETURN-PATH: ' . $return_path;
389                       
390                        if($total_abonnes) {
391                                // Fix bug : La meleuse tourne en boucle si spiplistes_lots non définie dans les varaibles meta
392                                if(!isset($GLOBALS['meta']['spiplistes_lots'])) {
393                                        $GLOBALS['meta']['spiplistes_lots'] = _SPIPLISTES_LOT_TAILLE;
394                                }
395                                $limit = intval($GLOBALS['meta']['spiplistes_lots']); // nombre de messages envoyes par boucles.
396                               
397                                if($is_a_test) {
398                                        $sql_adresses_dest = sql_select('id_auteur,nom,email', 'spip_auteurs'
399                                                , 'email='.sql_quote($email_test).' LIMIT 1');
400                                }
401                                else {
402                                        // Pour memo: les etiquettes sont creees par la trieuse
403                                        // ou directement en backoffice
404                                        // - pour les envois de test
405                                        // - pour les envoyer maintenant des courriers
406                                       
407                                        // Traitement d'une liasse d'etiquettes
408                                        // un id pour ce processus (le tampon est unique par liasse)
409                                        $id_process = intval(substr(creer_uniqid(),0,5));
410                                        $prefix_log .= '['.$id_process.'] ';
411                       
412                                        // un coup de tampon sur les etiquettes
413                                        // des courriers qui vont partir
414                                        spiplistes_courriers_en_queue_modifier(
415                                                array(
416                                                          'etat' => sql_quote($id_process))
417                                                        , 'etat='.$sql_vide.' AND id_courrier='.sql_quote($id_courrier).' LIMIT '.$limit
418                                        );
419                                       
420                                        // prendre la liasse des etiquettes tamponnees
421                                        $sql_adresses_dest = sql_select(
422                                                  array('a.nom', 'a.id_auteur', 'a.email')
423                                                , array('spip_auteurs AS a', 'spip_auteurs_courriers AS b')
424                                                , array(
425                                                        'etat='.sql_quote($id_process)
426                                                        , 'a.id_auteur=b.id_auteur'
427                                                        , 'b.id_courrier='.sql_quote($id_courrier)
428                                                        )
429                                                , 'a.email'
430                                        );
431                                }
432                                       
433                                $nb_destinataires = sql_count($sql_adresses_dest);
434                                spiplistes_log($prefix_log.'nb etiquettes a traiter: '.$nb_destinataires);
435                                if($nb_destinataires > 0) {
436
437                                        spiplistes_debug_log($prefix_log.'total_abos: '.$total_abonnes.', en cours: '.$nb_destinataires.', limit: '.$limit);
438
439                                        //envoyer le lot d'emails selectionne' (la liasse)
440                                        while($adresse = sql_fetch($sql_adresses_dest)) {
441
442                                                if($log_voir_destinataire) {
443                                                        $str_temp = '';
444                                                }
445
446                                                $id_auteur = intval($adresse['id_auteur']);
447                                                $nom_auteur = $adresse['nom'];
448                                                $email = $adresse['email'];
449
450                                                // Marquer le debut de l'envoi
451                                                if(!intval($date_debut_envoi)) {
452                                                        spiplistes_courrier_modifier ($id_courrier, array('date_debut_envoi' => 'NOW()'), false);
453                                                }
454                               
455                                                $format_abo = spiplistes_format_abo_demande($id_auteur);
456
457                                                $total++;
458                                                if($log_voir_destinataire) {
459                                                        $str_temp .= $nom_auteur.'('.$format_abo.') - '.$email;
460                                                }
461                                                unset ($cookie);
462               
463                                                if(($format_abo=='html') || ($format_abo=='texte')) {
464                                                        $cookie = creer_uniqid();
465                                                        spiplistes_auteurs_cookie_oubli_updateq($cookie, $email);
466               
467                                                        if($from_valide) {
468                                                                //$_url = generer_url_public('abonnement','d='.$cookie);
469                                                               
470                                                                if($opt_personnaliser_courrier == 'oui')
471                                                                {
472                                                                        list($ventre_html, $ventre_texte) =
473                                                                                spiplistes_personnaliser_courrier (
474                                                                                                                                $page_html
475                                                                                                                                , $page_texte
476                                                                                                                                , $id_auteur
477                                                                                                                                , $format_abo
478                                                                                                                        );
479                                                                }
480                                                                else {
481                                                                        $ventre_html = $page_html;
482                                                                        $ventre_texte = $page_texte;
483                                                                }
484                                                                // le &amp; semble poser probleme sur certains MUA. A suivre...
485                                                                //$_url = preg_replace(',(&amp;),','&', $_url);
486                                                               
487                                                               
488                                                                /**
489                                                                 * Insérer le pied de rappel
490                                                                 * qui permet de gérer l'abonnement
491                                                                 *
492                                                                 * Rajoute le lien si la pseudo
493                                                                 * balise _COOKIE_ABONNE_ est absente du courrier
494                                                                 */
495                                                                $new_ventre = spiplistes_personnaliser_cookie (
496                                                                                $ventre_html
497                                                                                , $cookie);
498                                                                if ($new_ventre === FALSE)
499                                                                {
500                                                                        /**
501                                                                         * Pour le moment (27/03/2011), un seul patron connu
502                                                                         */
503                                                                        $lien_rappel = 'lien_standard';
504                                                                       
505                                                                        list($pied_rappel_html, $pied_rappel_texte) = spiplistes_courriers_assembler_patron (
506                                                                                _SPIPLISTES_PATRONS_LIEN_DIR . $lien_rappel
507                                                                                , array('id_courrier' => $id_courrier
508                                                                                                , 'id_liste' => $id_liste
509                                                                                                , '_url' => generer_url_public('')
510                                                                                                , 'lang' => $lang
511                                                                                                , 'd' => $cookie
512                                                                                                , 'lien_desabo' => ($opt_ajout_lien_desabo == 'oui')
513                                                                                                )
514                                                                        );
515                                                                        $pied_rappel_texte = spiplistes_translate_2_charset ($pied_rappel_texte
516                                                                                                                                                                                 , $charset_dest
517                                                                                                                                                                                 , true);
518                                                                }
519                                                                else {
520                                                                        $ventre_html = $new_ventre;
521                                                                        /**
522                                                                         * Calculer la version texte
523                                                                         * Si pas de {patron}_texte, le _COOKIE_ABONNE_
524                                                                         * n'existe plus, car strip_tags a enlevé
525                                                                         * le lien <a> de la version html.
526                                                                         * Solution: créer le {patron}_texte
527                                                                         */
528                                                                        $new_ventre = spiplistes_personnaliser_cookie (
529                                                                                $ventre_texte
530                                                                                , $cookie);
531                                                                        if ($new_ventre === FALSE) {
532                                                                                spiplistes_log('main patron text version MISSING');
533                                                                        }
534                                                                        else {
535                                                                                $ventre_texte = $new_ventre;
536                                                                        }
537                                                                }
538                                                       
539                                                                switch($format_abo) {
540                                                                        case 'html':
541                                                                                /**
542                                                                                 * Si on ne trouve pas les tags HTML
543                                                                                 * alors on les ajoutes
544                                                                                 */
545                                                                                if (FALSE === strpos($ventre_html, '</html>')) {
546                                                                                        $email_a_envoyer[$format_abo]->Body =
547                                                                                                  $body_html_debut . $eol
548                                                                                                . $ventre_html . $eol
549                                                                                                . $pied_html . $eol
550                                                                                                . $pied_rappel_html . $eol
551                                                                                                . $tampon_html . $eol
552                                                                                                . $body_html_fin
553                                                                                                ;                                                                               
554                                                                                } else {
555                                                                                        /**
556                                                                                         * Si on trouve les tags HTML cela veut
557                                                                                         * dire que l'auteur veut pouvoir gerer lui meme
558                                                                                         * la partie <head> ainsi que le lien de desabonnement
559                                                                                         * donc on ne prend en compte que la partie ventre_html.
560                                                                                         */
561                                                                                        $tags_perso = array('http://%URL_ABONNEMENT%' => generer_url_public('abonnement','d='.$cookie),);
562                                                                                        $email_a_envoyer[$format_abo]->Body = str_replace(array_keys($tags_perso), array_values($tags_perso), $ventre_html);
563                                                                                }
564                                                                                // la version alternative texte
565                                                                                $email_a_envoyer[$format_abo]->AltBody = 
566                                                                                        $ventre_texte .$eol2
567                                                                                        . $pied_texte . $eol2
568                                                                                        . $pied_rappel_texte . $eol2
569                                                                                        . $tampon_texte
570                                                                                        ;
571                                                                                break;
572                                                                        case 'texte':
573                                                                                $email_a_envoyer[$format_abo]->Body =
574                                                                                        $ventre_texte .$eol2
575                                                                                        . $pied_texte . $eol2
576                                                                                        . $pied_rappel_texte . $eol2
577                                                                                        . $tampon_texte
578                                                                                        ;
579                                                                                break;
580                                                                }
581
582                                                                $email_a_envoyer[$format_abo]->SetAddress($email, $nom_auteur);
583                                                               
584                                                                $to = $email;
585                                                                /**
586                                                                 * @todo les caractères accentués ne passent pas dans le sujet. A revoir.
587                                                                 */
588                                                                $subject = $objet_texte;
589                                                               
590                                                                $body = array(
591                                                                                          'html' => $email_a_envoyer['html']->Body,
592                                                                                          'texte' => $email_a_envoyer['texte']->AltBody
593                                                                                          );
594                                                               
595                                                                /**
596                                                                 * @todo completer l'adresse from par le nom de l'émetteur
597                                                                 * du style 'John Doe' <jd@foo.bar>
598                                                                 */
599                                                                $from = $from; // $fromname?
600                                                               
601                                                                $headers = array (
602                                                                                                'Reply-To: '.$email_reply_to,
603                                                                                                'Return-Path: '.$return_path
604                                                                                                );
605                                                                $headers = array (
606                                                                                                'Reply-To' => $email_reply_to,
607                                                                                                'Return-Path' => $return_path
608                                                                                                );
609                                                               
610                                                               
611                                                                // marche pas
612                                                                $headers = array (
613                                                                                                'Reply-To: reply2me@foo.bar',
614                                                                                                'Return-Path: return-path@foo.bar'
615                                                                                                );
616                                                                // marche pas
617                                                                $headers = array (
618                                                                                                'Reply-To' => 'reply2me@foo.bar',
619                                                                                                'Return-Path' => 'return-path@foo.bar'
620                                                                                                );
621                                                                // marche pas
622                                                                $headers = 'Reply-To: reply2me@quesaco.org';
623                                                                /**
624                                                                 * @todo le header est perdu au passage. Vérifier facteur ?
625                                                                 */
626                                                               
627                                                               
628                                                                $format = $format_abo;
629
630                                                               
631                                                               
632                                                               
633                                                               
634                                                               
635                                                                // envoie le mail                                                                                                                               
636                                                                //if($simuler_envoi || $email_a_envoyer[$format_abo]->send()) {
637                                                               
638                                                                if ( $simuler_envoi ||
639                                                                        spiplistes_envoyer_mail (
640                                                                                                                                $to,
641                                                                                                                                $subject,
642                                                                                                                                $body,
643                                                                                                                                $from,
644                                                                                                                                $headers,
645                                                                                                                                $format
646                                                                                                                         ) 
647                                                                        ) {
648                                                                        $nb_emails_envoyes++;
649                                                                        $nb_emails[$format_abo]++;
650                                                                        if($log_voir_destinataire) {
651                                                                                $str_temp .= '  [OK]';
652                                                                        }
653                                                                }
654                                                                else {
655                                                                        $nb_emails_echec++;
656                                                                        if($log_voir_destinataire) {
657                                                                                $str_temp .= _T('spiplistes:erreur_mail');
658                                                                        }
659                                                                }
660                                                        }
661                                                        else {
662                                                                $nb_emails_echec++;
663                                                                if($log_voir_destinataire) {
664                                                                        $str_temp .= _T('spiplistes:sans_adresse');
665                                                                }
666                                                        } 
667                                                       
668                                                } // end if(($format_abo=='html') || ($format_abo=='texte'))
669                                                else { 
670                                                        $nb_emails_non_envoyes++; 
671                                                        if($log_voir_destinataire) {
672                                                                $str_temp .= ' '._T('spiplistes:msg_abonne_sans_format');
673                                                        }
674                                                        // prevenir qu'il manque le format
675                                                        spiplistes_log($prefix_log.' destination format MISSING FOR ID_AUTEUR #'.$id_auteur);
676                                                } /* fin abo*/
677                                               
678                                                if($log_voir_destinataire) {
679                                                        spiplistes_log($prefix_log.$str_temp);
680                                                }
681                                               
682                                        } // fin while
683                                       
684                                        // supprime la liasse de la queue d'envois
685                                        spiplistes_debug_log($prefix_log."envoi OK. Supprimer queue $id_process");
686                                        spiplistes_courriers_en_queue_supprimer('etat='.sql_quote($id_process));
687                                       
688                                        // si c'est un test on repasse le courrier en redac
689                                        if($is_a_test) {
690                                                spiplistes_courriers_statut_redac ($id_courrier);
691                                        }
692                                        $email_a_envoyer['texte']->SmtpClose();
693                                        $email_a_envoyer['html']->SmtpClose();
694                                } // end if
695                        }
696                        else {
697                                //aucun destinataire connu pour ce message
698                                spiplistes_debug_log($prefix_log._T('spiplistes:erreur_sans_destinataire')
699                                                                         . '---' . _T('spiplistes:envoi_annule')
700                                                                         );
701                                spiplistes_courrier_statut_modifier($id_courrier, _SPIPLISTES_COURRIER_STATUT_IGNORE);
702                                spiplistes_courrier_supprimer_queue_envois('id_courrier', $id_courrier);
703                                $str_log .= ' END #'.$id_courrier;
704                                //
705                                break;
706                        }
707
708                        if(!$is_a_test) {
709                                // faire le bilan apres l'envoi d'un lot
710                                $sql_set_array = array(
711                                          'nb_emails_envoyes' => sql_quote('nb_emails_envoyes').'+'.$nb_emails_envoyes
712                                        , 'nb_emails_texte' => sql_quote('nb_emails_texte').'+'.$nb_emails['texte']
713                                        , 'nb_emails_html' => sql_quote('nb_emails_html').'+'.$nb_emails['html']
714                                );
715                                if($nb_emails_echec) {
716                                        $sql_set_array['nb_emails_echec'] = sql_quote('nb_emails_echec').'+'.$nb_emails_echec;
717                                }
718                                if($nb_emails_non_envoyes) {
719                                        $sql_set_array['nb_emails_non_envoyes'] = sql_quote('nb_emails_non_envoyes').'+'.$nb_emails_non_envoyes;
720                                }
721
722                                spiplistes_log($prefix_log.$str_log);
723                               
724                                $str_log = spiplistes_trace_compteur ($id_courrier
725                                                                                                   , $nb_emails_envoyes
726                                                                                                   , $nb_emails['html']
727                                                                                                   , $nb_emails['texte']
728                                                                                                   , $nb_emails_non_envoyes
729                                                                                                   , $nb_emails_echec
730                                                                                                   , 'SESSION');
731
732                                // si courrier pas termine, redemande la main au CRON, sinon nettoyage.
733                                if($t = spiplistes_courriers_en_queue_compter('id_courrier='.sql_quote($id_courrier))) {
734                                        $str_log .= ' LEFT '.$t.' jobs'; 
735                                }
736                                else {
737                                        $statut = ($type == _SPIPLISTES_COURRIER_TYPE_NEWSLETTER) ? _SPIPLISTES_COURRIER_STATUT_PUBLIE : _SPIPLISTES_COURRIER_STATUT_AUTO;
738                                        spiplistes_debug_log($prefix_log."nouveau statut $statut");
739                                        $sql_set_array['statut'] = sql_quote($statut);
740                                        $sql_set_array['date_fin_envoi'] = 'NOW()';
741                                        $str_log .= ' END #'.$id_courrier;
742                                }
743                                spiplistes_courrier_modifier($id_courrier, $sql_set_array, false);
744                               
745                                // placer en log le suivi des compteurs si mode debug
746                                if (spiplistes_debug_log())
747                                {                                       
748                                        if ($row = sql_fetch(sql_select(
749                                                'nb_emails_envoyes,nb_emails_echec,nb_emails_non_envoyes,nb_emails_texte,nb_emails_html'
750                                                , 'spip_courriers'
751                                                , 'id_courrier='.sql_quote($id_courrier)
752                                                , '', '', 1
753                                                ))
754                                        ) {
755                                                spiplistes_log($prefix_log.$str_log);
756                                               
757                                                $str_log = spiplistes_trace_compteur ($id_courrier
758                                                                                                   , $row['nb_emails_envoyes']
759                                                                                                   , $row['nb_emails_html']
760                                                                                                   , $row['nb_emails_texte']
761                                                                                                   , $row['nb_emails_non_envoyes']
762                                                                                                   , $row['nb_emails_echec']
763                                                                                                   , 'FROM_DB')
764                                                                                                . ' END #'.$id_courrier;
765                                                                                                ;
766                                        }
767                                }
768                               
769                        }
770                } // end while()
771        } // end if($nb_etiquettes)
772        else {
773                $str_log = 'no job'; 
774        }
775
776        spiplistes_log($prefix_log.$str_log);
777
778        if(($ii = spiplistes_courriers_total_abonnes()) > 0) {
779                // il en reste apres la meleuse ? Signale au CRON tache non terminee
780                $nb_etiquettes = spiplistes_courriers_en_queue_compter('etat='.$sql_vide);
781                spiplistes_log($prefix_log.'courriers prets au depart ('.$nb_etiquettes.'/'.$ii.')');
782                $last_time = -$last_time;
783        }
784       
785        return($last_time);
786} // end spiplistes_meleuse()
787
788
789
790/**
791 * Remplacer les url_site
792 *
793 * Ex., pour url_site = "foo.bar" :
794 * _HREF_AUTEUR_URL_SITE_ = "href='http://foo.bar'"
795 * _AUTEUR_URL_SITE_ = "foo.bar"
796 *
797 * @author CP
798 * @version 20090426
799 * @return string
800 */
801function spiplistes_personnaliser_courrier_urls ($txt, $url) {
802
803        // commencer par href (voir patron details_auteurs pour exemple)
804        if(!empty($url)) {
805                $txt = preg_replace("@(_HREF_AUTEUR_URL_SITE_)@"
806                                                        , " href='" . ((!preg_match(',^https?://.+$,', $url)) ? "http://" : "") . $url . "'"
807                                                        , $txt);
808        }
809        // et url_site seul
810        $txt = preg_replace("@(_AUTEUR_URL_SITE_)@", $url, $txt);
811        return($txt);
812}
813
814/**
815 * Personnalisation du courrier
816 *
817 * Recherche/remplace les tags _AUTEUR_CLE_ dans le corps du message.
818 * (toutes les cles presentes dans la table *_auteur sont utilisables)
819 * @author CP
820 * @version 20080608
821 * @param string $page_html
822 * @param string $page_texte
823 * @param int $id_auteur
824 * @param string $format_abo
825 * @return array
826 */
827function spiplistes_personnaliser_courrier ($page_html, $page_texte, $id_auteur, $format_abo) {
828
829        $result_html = $result_texte = "";
830       
831        //if($auteur = sql_fetsel("*", 'spip_auteurs', "id_auteur=".sql_quote($id_auteur), '','', 1)) {
832        if ($auteur = spiplistes_auteurs_auteur_select ('*', 'id_auteur='.sql_quote($id_auteur)))
833        {
834                $ii = 0;
835                $pattern = array();
836                $replace = array();
837                krsort($auteur);
838                foreach($auteur as $key => $val) {
839                        if($key == "url_site") continue;
840                        $pattern[$ii] = ",(_AUTEUR_" . strtoupper($key) .")_,";
841                        $replace[$ii] = $auteur[$key];
842                        $ii++;
843                }
844                $url = trim($auteur['url_site']);
845               
846                if($format_abo == 'html') {
847                        $result_html = preg_replace($pattern, $replace, $page_html);
848                       
849                        // traiter url_site a part (href et corrige' par l'assembleur ou un filtre en amont)
850                        $result_html = spiplistes_personnaliser_courrier_urls ($result_html, $url);
851                }
852               
853                $result_texte = preg_replace($pattern, $replace, $page_texte);
854                $result_texte = spiplistes_personnaliser_courrier_urls($result_texte, $url);
855               
856                spiplistes_debug_log(_SPIPLISTES_PREFIX_LOG.'personnalisation du courrier pour id_auteur #'.$id_auteur);
857        } 
858        return(array($result_html, $result_texte));
859}
860
861/**
862 * Si la pseudo balise _COOKIE_ABONNE_ est détectée
863 * dans le courrier, remplace par le cookie
864 * et confirme la modification pour éviter
865 * l'insertion du pied de rappel
866 *
867 * @param string $texte
868 * @param string $cookie
869 * @staticvar string $tag
870 * @return bool|string
871 */
872function spiplistes_personnaliser_cookie ($texte, $cookie) {
873       
874        static $tag = '_COOKIE_ABONNE_';
875       
876        if (($r = strpos($texte, $tag)) !== FALSE)
877        {
878                $r = str_replace ($tag, $cookie, $texte);
879        }
880        return ($r);
881}
882
883/**
884 * Repasse un courrier en mode redac (en general, un test d'envoi)
885 *
886 * Change le statut d'un courrier pour <em>en cours</em>.
887 * @param int $id_courrier
888 * @return boolean
889 */
890function spiplistes_courriers_statut_redac ($id_courrier) {
891        spiplistes_courrier_modifier(
892                $id_courrier
893                , array(
894                        'email_test' => ''
895                        , 'total_abonnes' => 0
896                        , 'statut' => _SPIPLISTES_COURRIER_STATUT_REDAC
897                )                                               
898        );
899        spiplistes_debug_log(_SPIPLISTES_PREFIX_LOG.'repasse document en statut redac');
900        return(true);
901}
902
903/**
904 * Renvoie une ligne pour tracer les envois dans le log
905 *
906 * Permet de completer le log par les compteurs d'envoi
907 * (nb mails envoyes, dans quel format, ...)
908 * @author CP
909 * @version 20110421
910 * @param int $id identificateur du courrier
911 * @param int $sent nombre de mails envoyes
912 * @param int $html au format html
913 * @param int $text
914 * @param int $none sans format
915 * @param int $echec nombre d'echecs
916 * @param string $type
917 * @return string
918*/
919function spiplistes_trace_compteur ($id, $sent, $html, $text, $none, $echec, $type='TOTAL')
920{
921        $str = $type.': id_courrier #'.$id
922                // nombre total de courrier transmis
923                .' SENT: '.$sent
924                // dont aux formats
925                .' (HTML: '.$html.', TEXT: '.$text
926                // dont ceux sans format pour le destinataire
927                .', NONE: '.$none
928                // et ceux en echec
929                .', ECHEC: '.$echec
930                .')';
931        return($str);
932}
Note: See TracBrowser for help on using the repository browser.