source: spip-zone/_plugins_/facteur/trunk/inc/envoyer_mail.php @ 118884

Last change on this file since 118884 was 118884, checked in by Cerdic, 8 months ago

on peut ajouter important=true dans les options de envoyer_mail, ce qui met le flag sur le mail (mais peu supporte), mais surtout notifie l'adresse mail configuree dans facteur en cas d'erreur d'envoi de cet email important
a utiliser pour les emails transactionnels par exemple, si on veut pouvoir gerer quand un email d'un compte est bloque par le service d'envoi d'emails

File size: 13.1 KB
Line 
1<?php
2/**
3 * Plugin Facteur 4
4 * (c) 2009-2019 Collectif SPIP
5 * Distribue sous licence GPL
6 *
7 * @package SPIP\Facteur\Inc\Envoyer_mails
8 */
9
10if (!defined("_ECRIRE_INC_VERSION")) return;
11
12if (!defined('_LOG_FACTEUR')) {
13        define('_LOG_FACTEUR',_LOG_INFO);
14}
15
16include_spip('classes/facteur');
17// inclure le fichier natif de SPIP, pour les fonctions annexes
18include_once _DIR_RESTREINT."inc/envoyer_mail.php";
19
20/**
21 * @param string $destinataire
22 * @param string $sujet
23 * @param string|array $corps
24 *   au format string, c'est un corps d'email au format texte, comme supporte nativement par le core
25 *   au format array, c'est un corps etendu qui peut contenir
26 *     string texte : le corps d'email au format texte
27 *     string html : le corps d'email au format html
28 *     string from : email de l'envoyeur (prioritaire sur argument $from de premier niveau, deprecie)
29 *     string nom_envoyeur : un nom d'envoyeur pour completer l'email from
30 *     string cc : destinataires en copie conforme
31 *     string bcc : destinataires en copie conforme cachee
32 *     string|array repondre_a : une ou plusieurs adresses à qui répondre.
33 *       On peut aussi donner une liste de tableaux du type :
34 *         array('email' => 'test@exemple.com', 'nom' => 'Adresse de test')
35 *       pour spécifier un nom d'envoyeur pour chaque adresse.
36 *     string nom_repondre_a : le nom d'envoyeur pour compléter l'email repondre_a
37 *     string adresse_erreur : addresse de retour en cas d'erreur d'envoi
38 *     array pieces_jointes : listes de pieces a embarquer dans l'email, chacune au format array :
39 *       string chemin : chemin file system pour trouver le fichier a embarquer
40 *       string nom : nom du document tel qu'apparaissant dans l'email
41 *       string encodage : encodage a utiliser, parmi 'base64', '7bit', '8bit', 'binary', 'quoted-printable'
42 *       string mime : mime type du document
43 *     array headers : tableau d'en-tetes personalises, une entree par ligne d'en-tete
44 *     bool exceptions : lancer une exception en cas d'erreur (false par defaut)
45 * @param string $from (deprecie, utiliser l'entree from de $corps)
46 * @param string $headers (deprecie, utiliser l'entree headers de $corps)
47 * @return bool
48 */
49function inc_envoyer_mail($destinataire, $sujet, $corps, $from = "", $headers = "") {
50        $message_html   = '';
51        $message_texte  = '';
52        $nom_envoyeur = $cc = $bcc = $repondre_a = '';
53        $pieces_jointes = array();
54        $important = false;
55
56        // si $corps est un tableau -> fonctionnalites etendues
57        // avec entrees possible : html, texte, pieces_jointes, nom_envoyeur, ...
58        if (is_array($corps)) {
59                $message_html   = isset($corps['html']) ? $corps['html'] : "";
60                $message_texte  = isset($corps['texte']) ? nettoyer_caracteres_mail($corps['texte']) : "";
61                $pieces_jointes = isset($corps['pieces_jointes']) ? $corps['pieces_jointes'] : array();
62                $nom_envoyeur   = isset($corps['nom_envoyeur']) ? $corps['nom_envoyeur'] : "";
63                $from = isset($corps['from']) ? $corps['from']: $from;
64                $cc   = isset($corps['cc']) ? $corps['cc'] : "";
65                $bcc  = isset($corps['bcc']) ? $corps['bcc'] : "";
66                $repondre_a = isset($corps['repondre_a']) ? $corps['repondre_a'] : "";
67                $nom_repondre_a = isset($corps['nom_repondre_a']) ? $corps['nom_repondre_a'] : '';
68                $adresse_erreur = isset($corps['adresse_erreur']) ? $corps['adresse_erreur'] : "";
69                $headers = isset($corps['headers']) ? $corps['headers'] : $headers;
70                if (is_string($headers)){
71                        $headers = array_map('trim',explode("\n",$headers));
72                        $headers = array_filter($headers);
73                }
74                $important = (isset($corps['important']) ? !!$corps['important'] : $important);
75        }
76        // si $corps est une chaine -> compat avec la fonction native SPIP
77        // gerer le cas ou le corps est du html avec un Content-Type: text/html dans les headers
78        else {
79                if (preg_match(',Content-Type:\s*text/html,ims',$headers)){
80                        $message_html   = $corps;
81                }
82                else {
83                        // Autodetection : tester si le mail est en HTML
84                        if (strpos($headers,"Content-Type:")===false
85                                AND strpos($corps,"<")!==false // eviter les tests suivants si possible
86                                AND $ttrim = trim($corps)
87                                AND substr($ttrim,0,1)=="<"
88                                AND substr($ttrim,-1,1)==">"
89                                AND stripos($ttrim,"</html>")!==false){
90
91                                $message_html   = $corps;
92                        }
93                        // c'est vraiment un message texte
94                        else
95                                $message_texte  = nettoyer_caracteres_mail($corps);
96                }
97                $headers = array_map('trim',explode("\n",$headers));
98                $headers = array_filter($headers);
99        }
100
101        if(!strlen($sujet)){
102                if ($message_html) {
103                        // dans ce cas on ruse un peu : extraire le sujet du title
104                        if (preg_match(",<title>(.*)</title>,Uims",$message_html,$m))
105                                $sujet = $m[1];
106                        else {
107                                $ttrim = $message_html;
108                                // fallback, on prend le body si on le trouve
109                                if (preg_match(",<body[^>]*>(.*)</body>,Uims",$message_html,$m))
110                                        $ttrim = $m[1];
111
112                                // et on extrait la premiere ligne de vrai texte...
113                                // nettoyer le html et les retours chariots
114                                $ttrim = textebrut($ttrim);
115                                $ttrim = str_replace("\r\n", "\r", $ttrim);
116                                $ttrim = str_replace("\r", "\n", $ttrim);
117                                // decouper
118                                $ttrim = explode("\n",trim($ttrim));
119                                // extraire la premiere ligne de texte brut
120                                $sujet = array_shift($ttrim);
121                        }
122                }
123                else {
124                        // et on extrait la premiere ligne de vrai texte...
125                        // nettoyer le html et les retours chariots
126                        $ttrim = textebrut($message_texte);
127                        $ttrim = str_replace("\r\n", "\r", $ttrim);
128                        $ttrim = str_replace("\r", "\n", $ttrim);
129                        // decouper
130                        $ttrim = explode("\n",trim($ttrim));
131                        // extraire la premiere ligne de texte brut
132                        $sujet = array_shift($ttrim);
133                }
134        }
135
136        $sujet = nettoyer_titre_email($sujet);
137
138        // si le mail est en texte brut, on l'encapsule dans un modele surchargeable
139        // pour garder le texte brut, il suffit de faire un modele qui renvoie uniquement #ENV*{texte}
140        if ($message_texte AND ! $message_html){
141                $message_html = recuperer_fond("emails/texte",array('texte'=>$message_texte,'sujet'=>$sujet));
142        }
143        // si le mail est en HTML sans alternative, la generer
144        if ($message_html AND !$message_texte){
145                $message_texte = facteur_mail_html2text($message_html);
146        }
147
148        $exceptions = false;
149        if (is_array($corps) AND isset($corps['exceptions'])){
150                $exceptions = $corps['exceptions'];
151        }
152
153        // mode TEST : forcer l'email
154        if (defined('_TEST_EMAIL_DEST')) {
155                if (!_TEST_EMAIL_DEST){
156                        spip_log($e=_T('facteur:erreur_envoi_bloque_constante'), 'mail.' . _LOG_ERREUR);
157                        if ($exceptions) {
158                                throw new Exception($e);
159                        }
160                        return false;
161                }
162                else
163                        $destinataire = _TEST_EMAIL_DEST;
164        }
165
166        // plusieurs destinataires peuvent etre fournis separes par des virgules
167        // c'est un format standard dans l'envoi de mail
168        // les passer au format array pour phpMailer
169        // mais ne pas casser si on a deja un array en entree
170        // si pas destinataire du courriel on renvoie false (eviter les warning PHP : ligne 464 de phpmailer-php5/class.phpmailer.php
171        // suppression des adresses de courriels invalides, si aucune valide, renvoyer false (eviter un warning PHP : ligne 464 de phpmailer-php5/class.phpmailer.php)
172        if (is_array($destinataire))
173                $destinataire = implode(", ",$destinataire);
174
175        if(strlen($destinataire) > 0){
176                $destinataire = array_map('trim',explode(",",$destinataire));
177                foreach ($destinataire as $key => $value) {
178                        if(!email_valide($value))
179                                unset($destinataire[$key]);
180                }
181                if(count($destinataire) == 0) {
182                        spip_log($e="Aucune adresse email de destination valable pour l'envoi du courriel.", 'mail.' . _LOG_ERREUR);
183                        if ($exceptions) {
184                                throw new Exception($e);
185                        }
186                        return false;
187                }
188        }
189        else {
190                if ($bcc) {
191                        // On peut envoyer de mail que en bcc
192                        $destinataire = '';
193                } else {
194                        spip_log($e="Aucune adresse email de destination valable pour l'envoi du courriel.", 'mail.' . _LOG_ERREUR);
195                        if ($exceptions) {
196                                throw new Exception($e);
197                        }
198                        return false;
199                }
200        }
201
202        // On crée l'objet Facteur (PHPMailer) pour le manipuler ensuite
203        $options = array();
204        if (is_array($corps) AND !empty($corps['exceptions'])){
205                $options['exceptions'] = $corps['exceptions'];
206        }
207        include_spip('inc/facteur');
208        $facteur = facteur_factory($options);
209        $facteur->setDest($destinataire);
210        $facteur->setObjet($sujet);
211        $facteur->setMessage($message_html, $message_texte);
212
213        // On ajoute le courriel de l'envoyeur s'il est fournit par la fonction
214        if (empty($from) AND empty($facteur->From)) {
215                $from = $GLOBALS['meta']["email_envoi"];
216                if (empty($from) OR !email_valide($from)) {
217                        spip_log("Meta email_envoi invalide. Le mail sera probablement vu comme spam.", 'mail.' . _LOG_ERREUR);
218                        if(is_array($destinataire) && count($destinataire) > 0)
219                                $from = $destinataire[0];
220                        else
221                                $from = $destinataire;
222                }
223        }
224
225        // "Marie Toto <Marie@toto.com>"
226        if (preg_match(",^([^<>\"]*)<([^<>\"]+)>$,i",$from,$m)){
227                $nom_envoyeur = trim($m[1]);
228                $from = trim($m[2]);
229        }
230        if (!empty($from)){
231                $facteur->From = $from;
232                // la valeur par défaut de la config n'est probablement pas valable pour ce mail,
233                // on l'écrase pour cet envoi
234                $facteur->FromName = '';
235        }
236
237        // On ajoute le nom de l'envoyeur s'il fait partie des options
238        if ($nom_envoyeur){
239                $facteur->FromName = $nom_envoyeur;
240        }
241
242        // Si plusieurs emails dans le from, pas de Name !
243        if (strpos($facteur->From,",")!==false){
244                $facteur->FromName = "";
245        }
246
247        // S'il y a des copies à envoyer
248        if ($cc){
249                if (is_array($cc))
250                        foreach ($cc as $courriel)
251                                $facteur->AddCC($courriel);
252                else
253                        $facteur->AddCC($cc);
254        }
255
256        // S'il y a des copies cachées à envoyer
257        if ($bcc){
258                if (is_array($bcc))
259                        foreach ($bcc as $courriel)
260                                $facteur->AddBCC($courriel);
261                else
262                        $facteur->AddBCC($bcc);
263        }
264
265        // S'il y a une adresse de reply-to
266        if ($repondre_a) {
267                if (is_array($repondre_a)) {
268                        foreach ($repondre_a as $courriel) {
269                                if (is_array($courriel)) {
270                                        $facteur->AddReplyTo($courriel['email'], $courriel['nom']);
271                                } else {
272                                        $facteur->AddReplyTo($courriel);
273                                }
274                        }
275                } elseif ($nom_repondre_a) {
276                        $facteur->AddReplyTo($repondre_a, $nom_repondre_a);
277                } else {
278                        $facteur->AddReplyTo($repondre_a);
279                }
280        }
281
282        // S'il y a des pièces jointes on les ajoute proprement
283        if (count($pieces_jointes)) {
284                foreach ($pieces_jointes as $piece) {
285                        $facteur->AddAttachment(
286                                $piece['chemin'],
287                                isset($piece['nom']) ? $piece['nom']:'',
288                                (isset($piece['encodage']) AND in_array($piece['encodage'],array('base64', '7bit', '8bit', 'binary', 'quoted-printable'))) ? $piece['encodage']:'base64',
289                                isset($piece['mime']) ? $piece['mime']:Facteur::_mime_types(pathinfo($piece['chemin'], PATHINFO_EXTENSION))
290                        );
291                }
292        }
293
294        // Si une adresse email a été spécifiée pour les retours en erreur, on l'ajoute
295        if (!empty($adresse_erreur))
296                $facteur->Sender = $adresse_erreur;
297
298        if ($important) {
299                $facteur->setImportant();
300        }
301
302        // si entetes personalises : les ajouter
303        // attention aux collisions : si on utilise l'option cc de $corps
304        // et qu'on envoie en meme temps un header Cc: xxx, yyy
305        // on aura 2 lignes Cc: dans les headers
306        if (!empty($headers)) {
307                foreach($headers as $h){
308                        // verifions le format correct : il faut au moins un ":" dans le header
309                        // et on filtre le Content-Type: qui sera de toute facon fourni par facteur
310                        if (strpos($h,":")!==false
311                          AND strncmp($h,"Content-Type:",13)!==0)
312                                $facteur->AddCustomHeader($h);
313                }
314        }
315
316        // On passe dans un pipeline pour modifier tout le facteur avant l'envoi
317        $facteur = pipeline('facteur_pre_envoi', $facteur);
318
319        // Et c'est parti on envoie enfin
320        $backtrace = facteur_backtrace();
321        $trace = $facteur->getMessageLog();
322        spip_log("mail via facteur\n$trace",'mail'._LOG_FACTEUR);
323        spip_log("mail\n$backtrace\n$trace",'facteur'._LOG_FACTEUR);
324        $retour = $facteur->Send();
325
326        if (!$retour){
327                spip_log("Erreur Envoi mail via Facteur : ".print_r($facteur->ErrorInfo,true),'mail.'._LOG_ERREUR);
328
329                if ($important
330                  and $dest_alertes = $this->Sender) {
331                        $dest = (is_array($destinataire) ? implode(', ', $destinataire) : $destinataire);
332                        $sujet_alerte = _L("Fail envoi mail pour @dest@ (était: @sujet@)", array('email' => $dest, 'sujet' => $sujet));
333                        $facteur->setDest($dest_alertes);
334                        $facteur->setObjet($sujet_alerte);
335                        $facteur->Send();
336                }
337        }
338
339        return $retour ;
340}
341
342/**
343 * Retourne la pile de fonctions utilisée pour envoyer un mail
344 *
345 * @note
346 *     Ignore les fonctions `include_once`, `include_spip`, `find_in_path`
347 * @return array|string
348 *     pile d'appel
349 **/
350function facteur_backtrace($limit=10) {
351        $trace = debug_backtrace();
352        $caller = array_shift($trace);
353        while (count($trace) and (empty($trace[0]['file']) or $trace[0]['file'] === $caller['file'] or $trace[0]['file'] === __FILE__)) {
354                array_shift($trace);
355        }
356
357        $message = count($trace) ? $trace[0]['file'] . " L" . $trace[0]['line'] : "";
358        $f = array();
359        while (count($trace) and $t = array_shift($trace) and count($f)<$limit) {
360                if (in_array($t['function'], array('include_once', 'include_spip', 'find_in_path'))) {
361                        break;
362                }
363                $f[] = $t['function'];
364        }
365        if (count($f)) {
366                $message .= " [" . implode("(),", $f) . "()]";
367        }
368
369        return $message;
370}
Note: See TracBrowser for help on using the repository browser.