lib/pkp/classes/mail/PKPMailTemplate.inc.php

   1 <?php
   2
   3 /**
   4  * @file classes/mail/PKPMailTemplate.inc.php
   5  *
   6  * Copyright (c) 2000-2009 John Willinsky
   7  * Distributed under the GNU GPL v2. For full terms see the file docs/COPYING.
   8  *
   9  * @class PKPMailTemplate
  10  * @ingroup mail
  11  *
  12  * @brief Subclass of Mail for mailing a template email.
  13  */
  14
  15 // $Id: PKPMailTemplate.inc.php,v 1.7 2009/09/22 21:18:27 asmecher Exp $
  16
  17
  18 import('mail.Mail');
  19
  20 define('MAIL_ERROR_INVALID_EMAIL', 0x000001);
  21
  22 class PKPMailTemplate extends Mail {
  23
  24         /** @var $emailKey string Key of the email template we are using */
  25         var $emailKey;
  26
  27         /** @var $locale string locale of this template */
  28         var $locale;
  29
  30         /** @var $enabled boolean email template is enabled */
  31         var $enabled;
  32
  33         /** @var $errorMessages array List of errors to display to the user */
  34         var $errorMessages;
  35
  36         /** @var $persistAttachments array List of temporary files belonging to
  37             email; these are maintained between requests and only sent to the
  38             attachment handling functions in Mail.inc.php at time of send. */
  39         var $persistAttachments;
  40         var $attachmentsEnabled;
  41
  42         /** @var $skip boolean If set to true, this message has been skipped
  43             during the editing process by the user. */
  44         var $skip;
  45
  46         /** @var $bccSender boolean whether or not to bcc the sender */
  47         var $bccSender;
  48
  49         /** @var boolean Whether or not email fields are disabled */
  50         var $addressFieldsEnabled;
  51
  52         /**
  53          * Constructor.
  54          * @param $emailKey string unique identifier for the template
  55          * @param $locale string locale of the template
  56          * @param $enableAttachments boolean optional Whether or not to enable article attachments in the template
  57          * @param $includeSignature boolean optional
  58          */
  59         function PKPMailTemplate($emailKey = null, $locale = null, $enableAttachments = null, $includeSignature = true) {
  60                 parent::Mail();
  61                 $this->emailKey = isset($emailKey) ? $emailKey : null;
  62
  63                 // Use current user's locale if none specified
  64                 $this->locale = isset($locale) ? $locale : Locale::getLocale();
  65
  66                 // Record whether or not to BCC the sender when sending message
  67                 $this->bccSender = Request::getUserVar('bccSender');
  68
  69                 // If enableAttachments is null, use the default value from the
  70                 // configuration file
  71                 if ($enableAttachments === null) {
  72                         $enableAttachments = Config::getVar('email', 'enable_attachments')?true:false;
  73                 }
  74
  75                 $user =& Request::getUser();
  76                 if ($enableAttachments && $user) {
  77                         $this->_handleAttachments($user->getId());
  78                 } else {
  79                         $this->attachmentsEnabled = false;
  80                 }
  81
  82                 $this->addressFieldsEnabled = true;
  83         }
  84
  85         /**
  86          * Disable or enable the address fields on the email form.
  87          * NOTE: This affects the displayed form ONLY; if disabling the address
  88          * fields, callers should manually clearAllRecipients and add/set
  89          * recipients just prior to sending.
  90          * @param $addressFieldsEnabled boolean
  91          */
  92         function setAddressFieldsEnabled($addressFieldsEnabled) {
  93                 $this->addressFieldsEnabled = $addressFieldsEnabled;
  94         }
  95
  96         /**
  97          * Get the enabled/disabled state of address fields on the email form.
  98          * @return boolean
  99          */
 100         function getAddressFieldsEnabled() {
 101                 return $this->addressFieldsEnabled;
 102         }
 103
 104         /**
 105          * Check whether or not there were errors in the user input for this form.
 106          * @return boolean true iff one or more error messages are stored.
 107          */
 108         function hasErrors() {
 109                 return ($this->errorMessages != null);
 110         }
 111
 112         /**
 113          * Assigns values to e-mail parameters.
 114          * @param $paramArray array
 115          * @return void
 116          */
 117         function assignParams($paramArray = array()) {
 118                 $subject = $this->getSubject();
 119                 $body = $this->getBody();
 120
 121                 // Replace variables in message with values
 122                 foreach ($paramArray as $key => $value) {
 123                         if (!is_object($value)) {
 124                                 $subject = str_replace('{$' . $key . '}', $value, $subject);
 125                                 $body = str_replace('{$' . $key . '}', $value, $body);
 126                         }
 127                 }
 128
 129                 $this->setSubject($subject);
 130                 $this->setBody($body);
 131         }
 132
 133         /**
 134          * Returns true if the email template is enabled; false otherwise.
 135          * @return boolean
 136          */
 137         function isEnabled() {
 138                 return $this->enabled;
 139         }
 140
 141         /**
 142          * Processes form-submitted addresses for inclusion in
 143          * the recipient list
 144          * @param $currentList array Current recipient/cc/bcc list
 145          * @param $newAddresses array "Raw" form parameter for additional addresses
 146          */
 147         function &processAddresses($currentList, &$newAddresses) {
 148                 foreach ($newAddresses as $newAddress) {
 149                         $regs = array();
 150                         // Match the form "My Name <my_email@my.domain.com>"
 151                         if (String::regexp_match_get('/^([^<>' . "\n" . ']*[^<> ' . "\n" . '])[ ]*<(?P<email>' . PCRE_EMAIL_ADDRESS . ')>$/i', $newAddress, $regs)) {
 152                                 $currentList[] = array('name' => $regs[1], 'email' => $regs['email']);
 153
 154                         } elseif (String::regexp_match_get('/^<?(?P<email>' . PCRE_EMAIL_ADDRESS . ')>?$/i', $newAddress, $regs)) {
 155                                 $currentList[] = array('name' => '', 'email' => $regs['email']);
 156
 157                         } elseif ($newAddress != '') {
 158                                 $this->errorMessages[] = array('type' => MAIL_ERROR_INVALID_EMAIL, 'address' => $newAddress);
 159                         }
 160                 }
 161                 return $currentList;
 162         }
 163
 164         /**
 165          * Displays an edit form to customize the email.
 166          * @param $formActionUrl string
 167          * @param $hiddenFormParams array
 168          * @return void
 169          */
 170         function displayEditForm($formActionUrl, $hiddenFormParams = null, $alternateTemplate = null, $additionalParameters = array()) {
 171                 import('form.Form');
 172                 $form = new Form($alternateTemplate!=null?$alternateTemplate:'email/email.tpl');
 173
 174                 $form->setData('formActionUrl', $formActionUrl);
 175                 $form->setData('subject', $this->getSubject());
 176                 $form->setData('body', $this->getBody());
 177
 178                 $form->setData('to', $this->getRecipients());
 179                 $form->setData('cc', $this->getCcs());
 180                 $form->setData('bcc', $this->getBccs());
 181                 $form->setData('blankTo', Request::getUserVar('blankTo'));
 182                 $form->setData('blankCc', Request::getUserVar('blankCc'));
 183                 $form->setData('blankBcc', Request::getUserVar('blankBcc'));
 184                 $form->setData('from', $this->getFromString(false));
 185
 186                 $form->setData('addressFieldsEnabled', $this->getAddressFieldsEnabled());
 187
 188                 $user =& Request::getUser();
 189                 if ($user) {
 190                         $form->setData('senderEmail', $user->getEmail());
 191                         $form->setData('bccSender', $this->bccSender);
 192                 }
 193
 194                 if ($this->attachmentsEnabled) {
 195                         $form->setData('attachmentsEnabled', true);
 196                         $form->setData('persistAttachments', $this->persistAttachments);
 197                 }
 198
 199                 $form->setData('errorMessages', $this->errorMessages);
 200
 201                 if ($hiddenFormParams != null) {
 202                         $form->setData('hiddenFormParams', $hiddenFormParams);
 203                 }
 204
 205                 foreach ($additionalParameters as $key => $value) {
 206                         $form->setData($key, $value);
 207                 }
 208
 209                 $form->display();
 210         }
 211
 212         /**
 213          * Send the email.
 214          * Aside from calling the parent method, this actually attaches
 215          * the persistent attachments if they are used.
 216          * @param $clearAttachments boolean Whether to delete attachments after
 217          */
 218         function send($clearAttachments = true) {
 219                 if ($this->attachmentsEnabled) {
 220                         foreach ($this->persistAttachments as $persistentAttachment) {
 221                                 $this->addAttachment(
 222                                         $persistentAttachment->getFilePath(),
 223                                         $persistentAttachment->getOriginalFileName(),
 224                                         $persistentAttachment->getFileType()
 225                                 );
 226                         }
 227                 }
 228
 229                 $user =& Request::getUser();
 230
 231                 if ($user && $this->bccSender) {
 232                         $this->addBcc($user->getEmail(), $user->getFullName());
 233                 }
 234
 235                 if (isset($this->skip) && $this->skip) {
 236                         $result = true;
 237                 } else {
 238                         $result = parent::send();
 239                 }
 240
 241                 if ($clearAttachments && $this->attachmentsEnabled) {
 242                         $this->_clearAttachments($user->getId());
 243                 }
 244
 245                 return $result;
 246         }
 247
 248         /**
 249          * Assigns user-specific values to email parameters, sends
 250          * the email, then clears those values.
 251          * @param $paramArray array
 252          * @return void
 253          */
 254         function sendWithParams($paramArray) {
 255                 $savedHeaders = $this->getHeaders();
 256                 $savedSubject = $this->getSubject();
 257                 $savedBody = $this->getBody();
 258
 259                 $this->assignParams($paramArray);
 260
 261                 $ret = $this->send();
 262
 263                 $this->setHeaders($savedHeaders);
 264                 $this->setSubject($savedSubject);
 265                 $this->setBody($savedBody);
 266
 267                 return $ret;
 268         }
 269
 270         /**
 271          * Clears the recipient, cc, and bcc lists.
 272          * @param $clearHeaders boolean if true, also clear headers
 273          * @return void
 274          */
 275         function clearRecipients($clearHeaders = true) {
 276                 $this->setData('recipients', null);
 277                 $this->setData('ccs', null);
 278                 $this->setData('bccs', null);
 279                 if ($clearHeaders) {
 280                         $this->setData('headers', null);
 281                 }
 282         }
 283
 284         /**
 285          * Adds a persistent attachment to the current list.
 286          * Persistent attachments MUST be previously initialized
 287          * with handleAttachments.
 288          */
 289         function addPersistAttachment($temporaryFile) {
 290                 $this->persistAttachments[] = $temporaryFile;
 291         }
 292
 293         /**
 294          * Handles attachments in a generalized manner in situations where
 295          * an email message must span several requests. Called from the
 296          * constructor when attachments are enabled.
 297          */
 298         function _handleAttachments($userId) {
 299                 import('file.TemporaryFileManager');
 300                 $temporaryFileManager = new TemporaryFileManager();
 301
 302                 $this->attachmentsEnabled = true;
 303                 $this->persistAttachments = array();
 304
 305                 $deleteAttachment = Request::getUserVar('deleteAttachment');
 306
 307                 if (Request::getUserVar('persistAttachments') != null) foreach (Request::getUserVar('persistAttachments') as $fileId) {
 308                         $temporaryFile = $temporaryFileManager->getFile($fileId, $userId);
 309                         if (!empty($temporaryFile)) {
 310                                 if ($deleteAttachment != $temporaryFile->getId()) {
 311                                         $this->persistAttachments[] = $temporaryFile;
 312                                 } else {
 313                                         // This file is being deleted.
 314                                         $temporaryFileManager->deleteFile($temporaryFile->getId(), $userId);
 315                                 }
 316                         }
 317                 }
 318
 319                 if (Request::getUserVar('addAttachment') && $temporaryFileManager->uploadedFileExists('newAttachment')) {
 320                         $user =& Request::getUser();
 321
 322                         $this->persistAttachments[] = $temporaryFileManager->handleUpload('newAttachment', $user->getId());
 323                 }
 324         }
 325
 326         function getAttachmentFiles() {
 327                 if ($this->attachmentsEnabled) return $this->persistAttachments;
 328                 return array();
 329         }
 330
 331         /**
 332          * Delete all attachments associated with this message.
 333          * Called from send().
 334          * @param $userId int
 335          */
 336         function _clearAttachments($userId) {
 337                 import('file.TemporaryFileManager');
 338                 $temporaryFileManager = new TemporaryFileManager();
 339
 340                 $persistAttachments = Request::getUserVar('persistAttachments');
 341                 if (is_array($persistAttachments)) foreach ($persistAttachments as $fileId) {
 342                         $temporaryFile = $temporaryFileManager->getFile($fileId, $userId);
 343                         if (!empty($temporaryFile)) {
 344                                 $temporaryFileManager->deleteFile($temporaryFile->getId(), $userId);
 345                         }
 346                 }
 347         }
 348 }
 349
 350 ?>