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

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

une ligne de debug pour identifier le charset

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