source: spip-zone/_plugins_/spip-listes/spip-listes_1_9_3/inc/spiplistes_meleuse.php @ 48147

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

Si patron en version texte manquant et insert du cookie dans le courrier, il sera absent de la version texte. Le signaler dans le log

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