1: <?php
  2: /**
  3:  * This file contains the cMail class which should be used for all mail sending
  4:  * purposes.
  5:  *
  6:  * @package Core
  7:  * @subpackage Backend
  8:  * @version SVN Revision $Rev:$
  9:  *
 10:  * @author Rusmir Jusufovic, Simon Sprankel
 11:  * @copyright four for business AG <www.4fb.de>
 12:  * @license http://www.contenido.org/license/LIZENZ.txt
 13:  * @link http://www.4fb.de
 14:  * @link http://www.contenido.org
 15:  */
 16: 
 17: defined('CON_FRAMEWORK') || die('Illegal call: Missing framework initialization - request aborted.');
 18: 
 19: // since CONTENIDO has it's own autoloader, swift_init.php is enough
 20: // we do not need and should not use swift_required.php!
 21: require_once 'swiftmailer/lib/swift_init.php';
 22: 
 23: /**
 24:  * Mailer class which should be used for all mail sending purposes.
 25:  *
 26:  * @package Core
 27:  * @subpackage Backend
 28:  */
 29: class cMailer extends Swift_Mailer {
 30: 
 31:     /**
 32:      * The mail host name
 33:      *
 34:      * @var string
 35:      */
 36:     private $_mailHost = 'localhost';
 37: 
 38:     /**
 39:      * The username for authentication at the host
 40:      *
 41:      * @var string
 42:      */
 43:     private $_mailUser = '';
 44: 
 45:     /**
 46:      * The password for authentication at the host
 47:      *
 48:      * @var string
 49:      */
 50:     private $_mailPass = '';
 51: 
 52:     /**
 53:      * The encryption method (ssl/tls).
 54:      *
 55:      * @var string
 56:      */
 57:     private $_mailEncryption = null;
 58: 
 59:     /**
 60:      * The port to use at the host
 61:      *
 62:      * @var int
 63:      */
 64:     private $_mailPort = 25;
 65: 
 66:     /**
 67:      * The mail address of the sender
 68:      *
 69:      * @var string
 70:      */
 71:     private $_mailSender = 'noreply@contenido.org';
 72: 
 73:     /**
 74:      * The name of the sender
 75:      *
 76:      * @var string
 77:      */
 78:     private $_mailSenderName = 'CONTENIDO Backend';
 79: 
 80:     /**
 81:      * Constructor
 82:      *
 83:      * @param Swift_Transport $transport [optional] the transport type
 84:      */
 85:     public function __construct($transport = null) {
 86:         // get sender mail from system properties
 87:         $mailSender = getSystemProperty('system', 'mail_sender');
 88:         if (Swift_Validate::email($mailSender)) {
 89:             $this->_mailSender = $mailSender;
 90:         }
 91: 
 92:         // get sender name from system properties
 93:         $mailSenderName = getSystemProperty('system', 'mail_sender_name');
 94:         if (!empty($mailSenderName)) {
 95:             $this->_mailSenderName = $mailSenderName;
 96:         }
 97: 
 98:         // if a transport object has been given, use it
 99:         if (!is_null($transport)) {
100:             parent::__construct($transport);
101:             return;
102:         }
103: 
104:         // if no transport object has been given, read system setting and create
105:         // one
106:         // get mailserver host from system properties
107:         $mailHost = getSystemProperty('system', 'mail_host');
108:         if (!empty($mailHost)) {
109:             $this->_mailHost = $mailHost;
110:         }
111: 
112:         // get mailserver user and pass from system properties
113:         $this->_mailUser = (getSystemProperty('system', 'mail_user'))? getSystemProperty('system', 'mail_user') : '';
114:         $this->_mailPass = (getSystemProperty('system', 'mail_pass'))? getSystemProperty('system', 'mail_pass') : '';
115: 
116:         // get mailserver encryption from system properties
117:         $encryptions = array(
118:             'tls',
119:             'ssl'
120:         );
121:         if (in_array(strtolower(getSystemProperty('system', 'mail_encryption')), $encryptions)) {
122:             $this->_mailEncryption = strtolower(getSystemProperty('system', 'mail_encryption'));
123:         }
124: 
125:         // get mailserver port from system properties
126:         if (is_numeric(getSystemProperty('system', 'mail_port'))) {
127:             $this->_mailPort = (int) getSystemProperty('system', 'mail_port');
128:         }
129: 
130:         // try to use SMTP
131:         $transport = self::constructTransport($this->_mailHost, $this->_mailPort, $this->_mailEncryption, $this->_mailUser, $this->_mailPass);
132:         parent::__construct($transport);
133:     }
134: 
135:     /**
136:      * Tries to establish an SMTP connection with the given settings.
137:      * If this is possible, a Swift_SmtpTransport object is returned. Otherwise
138:      * a simple Swift_MailTransport object is returned.
139:      *
140:      * @param string $mailHost the mail host
141:      * @param string $mailPort the mail port
142:      * @param string $mailEncryption [optional] the mail encryption
143:      * @param string $mailUser [optional] the mail user
144:      * @param string $mailPass [optional] the mail password
145:      * @return Swift_SmtpTransport Swift_MailTransport the transport object
146:      */
147:     public static function constructTransport($mailHost, $mailPort, $mailEncryption = null, $mailUser = null, $mailPass = null) {
148:         // try to use SMTP
149:         $transport = Swift_SmtpTransport::newInstance($mailHost, $mailPort, $mailEncryption);
150:         if (!empty($mailUser)) {
151:             $authHandler = new Swift_Transport_Esmtp_AuthHandler(array(
152:                 new Swift_Transport_Esmtp_Auth_PlainAuthenticator(),
153:                 new Swift_Transport_Esmtp_Auth_LoginAuthenticator(),
154:                 new Swift_Transport_Esmtp_Auth_CramMd5Authenticator()
155:             ));
156:             $authHandler->setUsername($mailUser);
157:             if (!empty($mailPass)) {
158:                 $authHandler->setPassword($mailPass);
159:             }
160:             $transport->setExtensionHandlers(array(
161:                 $authHandler
162:             ));
163:         }
164: 
165:         // check if SMTP usage is possible
166:         try {
167:             $transport->start();
168:         } catch (Swift_TransportException $e) {
169:             // if SMTP is not possible, simply use PHP's mail() functionality
170:             $transport = Swift_MailTransport::newInstance();
171:         }
172: 
173:         return $transport;
174:     }
175: 
176:     /**
177:      * Sets the charset of the messages which are sent with this mailer object.
178:      * If you want to use UTF-8, you do not need to call this method.
179:      *
180:      * @param string $charset the character encoding
181:      */
182:     public function setCharset($charset) {
183:         Swift_Preferences::getInstance()->setCharset($charset);
184:     }
185: 
186:     /**
187:      * Wrapper function for sending a mail.
188:      * All parameters which accept mail addresses also accept an array where
189:      * the key is the email address and the value is the name.
190:      *
191:      * @param string|array $from the sender of the mail, if something "empty" is
192:      *        given, default address from CONTENIDO system settings is used
193:      * @param string|array $to one or more recipient addresses
194:      * @param string $subject the subject of the mail
195:      * @param string $body [optional] the body of the mail
196:      * @param string|array $cc [optional] one or more recipient addresses which
197:      *        should get a normal copy
198:      * @param string|array $bcc [optional] one or more recipient addresses which
199:      *        should get a blind copy
200:      * @param string|array $replyTo [optional] address to which replies should
201:      *        be sent
202:      * @param bool $resend [optional] whether the mail is resent
203:      * @return int number of recipients to which the mail has been sent
204:      */
205:     public function sendMail($from, $to, $subject, $body = '', $cc = null, $bcc = null, $replyTo = null, $resend = false, $contentType = 'text/plain') {
206:         $message = Swift_Message::newInstance($subject, $body, $contentType);
207:         if (empty($from) || is_array($from) && count($from) > 1) {
208:             $message->setFrom(array(
209:                 $this->_mailSender => $this->_mailSenderName
210:             ));
211:         } else {
212:             $message->setFrom($from);
213:         }
214:         $message->setTo($to);
215:         $message->setCc($cc);
216:         $message->setBcc($bcc);
217:         $message->setReplyTo($replyTo);
218:         $failedRecipients = array();
219: 
220:         return $this->send($message, $failedRecipients, $resend);
221:     }
222: 
223:     /**
224:      * Sends the given Swift_Mime_Message and logs it if $resend is false.
225:      *
226:      * @see Swift_Mailer::send()
227:      */
228:     public function send(Swift_Mime_Message $message, &$failedRecipients = null, $resend = false) {
229:         if (!is_array($failedRecipients)) {
230:             $failedRecipients = array();
231:         }
232:         $result = parent::send($message, $failedRecipients);
233: 
234:         // log the mail only if it is a new one
235:         if (!$resend) {
236:             $this->_logMail($message, $failedRecipients);
237:         }
238: 
239:         return $result;
240:     }
241: 
242:     /**
243:      * Resends the mail with the given idmailsuccess.
244:      *
245:      * @param int $idmailsuccess the ID of the mail which should be resend
246:      * @throws cInvalidArgumentException if the mail has already been sent
247:      *         successfully or does not exist
248:      */
249:     public function resendMail($idmailsuccess) {
250:         $mailLogSuccess = new cApiMailLogSuccess($idmailsuccess);
251:         if (!$mailLogSuccess->isLoaded() || $mailLogSuccess->get('success') == 1) {
252:             throw new cInvalidArgumentException('The mail which should be resent has already been sent successfully or does not exist.');
253:         }
254: 
255:         // get all fields, json-decode address fields
256:         $idmail = $mailLogSuccess->get('idmail');
257:         $mailLog = new cApiMailLog($idmail);
258:         $from = json_decode($mailLog->get('from'), true);
259:         $to = json_decode($mailLog->get('to'), true);
260:         $replyTo = json_decode($mailLog->get('reply_to'), true);
261:         $cc = json_decode($mailLog->get('cc'), true);
262:         $bcc = json_decode($mailLog->get('bcc'), true);
263:         $subject = $mailLog->get('subject');
264:         $body = $mailLog->get('body');
265:         $contentType = $mailLog->get('content_type');
266:         $this->setCharset($mailLog->get('charset'));
267: 
268:         // decode all fields
269:         $charset = $mailLog->get('charset');
270:         $from = $this->decodeField($from, $charset);
271:         $to = $this->decodeField($to, $charset);
272:         $replyTo = $this->decodeField($replyTo, $charset);
273:         $cc = $this->decodeField($cc, $charset);
274:         $bcc = $this->decodeField($bcc, $charset);
275:         $subject = $this->decodeField($subject, $charset);
276:         $body = $this->decodeField($body, $charset);
277: 
278:         $success = $this->sendMail($from, $to, $subject, $body, $cc, $bcc, $replyTo, true, $contentType);
279: 
280:         if ($success) {
281:             $mailLogSuccess->set('success', 1);
282:             $mailLogSuccess->store();
283:         }
284:     }
285: 
286:     /**
287:      * Encodes the given value / the given array values with htmlentities.
288:      *
289:      * @param string|array $value the value to encode
290:      * @param string $charset the charset to use in htmlentities
291:      * @return string array encoded value
292:      */
293:     private function encodeField($value, $charset) {
294:         if (is_array($value)) {
295:             for ($i = 0; $i < count($value); $i++) {
296:                 if (!empty($value[$i])) {
297:                     $value[$i] = conHtmlEntities($value[$i], ENT_COMPAT, $charset, false);
298:                 }
299:             }
300:             return $value;
301:         } else if (is_string($value)) {
302:             return conHtmlentities($value, ENT_COMPAT, $charset, false);
303:         }
304:         return $value;
305:     }
306: 
307:     /**
308:      * Decodes the given value / the given array values with html_entity_decode.
309:      *
310:      * @param string|array $value the value to decode
311:      * @param string $charset the charset to use in htmlentities
312:      * @return string array decoded value
313:      */
314:     private function decodeField($value, $charset) {
315:         if (is_array($value)) {
316:             for ($i = 0; $i < count($value); $i++) {
317:                 if (!empty($value[$i])) {
318:                     $value[$i] = conHtmlEntityDecode($value[$i], ENT_COMPAT | ENT_HTML401, $charset, false);
319:                 }
320:             }
321:         } else if (is_string($value)) {
322:             return conHtmlEntityDecode($value, ENT_COMPAT | ENT_HTML401, $charset);
323:         }
324:         return $value;
325:     }
326: 
327:     /**
328:      * Log the information about sending the email.
329:      *
330:      * @param Swift_Message $message the message which has been send
331:      * @param array $failedRecipients [optional] the recipient addresses that
332:      *        did not get the mail
333:      * @return the idmail of the inserted table row in con_mail_log
334:      */
335:     private function _logMail(Swift_Mime_Message $message, array $failedRecipients = array()) {
336:         $mailLogCollection = new cApiMailLogCollection();
337: 
338:         // encode all fields
339:         $charset = $message->getCharset();
340:         $from = $this->encodeField($message->getFrom(), $charset);
341:         $to = $this->encodeField($message->getTo(), $charset);
342:         $replyTo = $this->encodeField($message->getReplyTo(), $charset);
343:         $cc = $this->encodeField($message->getCc(), $charset);
344:         $bcc = $this->encodeField($message->getBcc(), $charset);
345:         $subject = $this->encodeField($message->getSubject(), $charset);
346:         $body = $this->encodeField($message->getBody(), $charset);
347:         $contentType = $message->getContentType();
348:         $idmail = $mailLogCollection->create($from, $to, $replyTo, $cc, $bcc, $subject, $body, time(), $charset, $contentType);
349: 
350:         // do not use array_merge here since the mail addresses are array keys
351:         // array_merge will make problems if one recipient is e.g. in cc and bcc
352:         $recipientArrays = array(
353:             $message->getTo(),
354:             $message->getCc(),
355:             $message->getBcc()
356:         );
357:         $mailLogSuccessCollection = new cApiMailLogSuccessCollection();
358:         foreach ($recipientArrays as $recipients) {
359:             if (!is_array($recipients)) {
360:                 continue;
361:             }
362:             foreach ($recipients as $key => $value) {
363:                 $recipient = array(
364:                     $key => $value
365:                 );
366:                 $success = true;
367:                 // TODO how do we get the information why message sending
368:                 // has
369:                 // failed?
370:                 $exception = '';
371:                 if (in_array($key, $failedRecipients)) {
372:                     $success = false;
373:                 }
374:                 $mailLogSuccessCollection->create($idmail, $recipient, $success, $exception);
375:             }
376:         }
377: 
378:         return $idmail;
379:     }
380: }
381: