classes/mail/MailTemplate.inc.php

<?php

// $Id: MailTemplate.inc.php,v 1.62 2008/07/01 01:16:10 asmecher Exp $


import('mail.Mail');

define('MAIL_ERROR_INVALID_EMAIL', 0x000001);
class MailTemplate extends Mail {

   var $emailKey;

   var $locale;

   var $journal;

   var $enabled;

   var $errorMessages;

   var $persistAttachments;
   var $attachmentsEnabled;

   var $skip;

   var $bccSender;

   var $addressFieldsEnabled;

   function MailTemplate($emailKey = null, $locale = null, $enableAttachments = null, $journal = null) {
      parent::Mail();
      $this->emailKey = isset($emailKey) ? $emailKey : null;


      // Use current user's locale if none specified
      $this->locale = isset($locale) ? $locale : Locale::getLocale();

      // If a journal wasn't specified, use the current request.
      if ($journal === null) $journal = &Request::getJournal();

      if (isset($this->emailKey)) {
         $emailTemplateDao = &DAORegistry::getDAO('EmailTemplateDAO');
         $emailTemplate = &$emailTemplateDao->getEmailTemplate($this->emailKey, $this->locale, $journal == null ? 0 : $journal->getJournalId());
      }

      $userSig = '';
      $user =& Request::getUser();
      if ($user) {
         $userSig = $user->getUserSignature();
         if (!empty($userSig)) $userSig = "\n" . $userSig;
      }

      if (isset($emailTemplate) && Request::getUserVar('subject')==null && Request::getUserVar('body')==null) {
         $this->setSubject($emailTemplate->getSubject());
         $this->setBody($emailTemplate->getBody() . $userSig);
         $this->enabled = $emailTemplate->getEnabled();

         if (Request::getUserVar('usePostedAddresses')) {
            $to = Request::getUserVar('to');
            if (is_array($to)) {
               $this->setRecipients($this->processAddresses ($this->getRecipients(), $to));
            }
            $cc = Request::getUserVar('cc');
            if (is_array($cc)) {
               $this->setCcs($this->processAddresses ($this->getCcs(), $cc));
            }
            $bcc = Request::getUserVar('bcc');
            if (is_array($bcc)) {
               $this->setBccs($this->processAddresses ($this->getBccs(), $bcc));
            }
         }
      } else {
         $this->setSubject(Request::getUserVar('subject'));
         $body = Request::getUserVar('body');
         if (empty($body)) $this->setBody($userSig);
         else $this->setBody($body);
         $this->skip = (($tmp = Request::getUserVar('send')) && is_array($tmp) && isset($tmp['skip']));
         $this->enabled = true;

         if (is_array($toEmails = Request::getUserVar('to'))) {
            $this->setRecipients($this->processAddresses ($this->getRecipients(), $toEmails));
         }
         if (is_array($ccEmails = Request::getUserVar('cc'))) {
            $this->setCcs($this->processAddresses ($this->getCcs(), $ccEmails));
         }
         if (is_array($bccEmails = Request::getUserVar('bcc'))) {
            $this->setBccs($this->processAddresses ($this->getBccs(), $bccEmails));
         }
      }

      // Record whether or not to BCC the sender when sending message
      $this->bccSender = Request::getUserVar('bccSender');

      // Default "From" to user if available, otherwise site/journal principal contact
      $user = &Request::getUser();
      if ($user) {
         $this->setFrom($user->getEmail(), $user->getFullName());
      } elseif ($journal == null) {
         $site = &Request::getSite();
         $this->setFrom($site->getSiteContactEmail(), $site->getSiteContactName());

      } else {
         $this->setFrom($journal->getSetting('contactEmail'), $journal->getSetting('contactName'));
      }

      if ($journal && !Request::getUserVar('continued')) {
         $this->setSubject('[' . $journal->getLocalizedSetting('initials') . '] ' . $this->getSubject());
      }

      // If enableAttachments is null, use the default value from the
      // configuration file
      if ($enableAttachments === null) {
         $enableAttachments = Config::getVar('email', 'enable_attachments')?true:false;
      }

      if ($enableAttachments && $user) {
         $this->_handleAttachments($user->getUserId());
      } else {
         $this->attachmentsEnabled = false;
      }

      $this->addressFieldsEnabled = true;
      $this->journal =& $journal;
   }

   function setAddressFieldsEnabled($addressFieldsEnabled) {
      $this->addressFieldsEnabled = $addressFieldsEnabled;
   }

   function getAddressFieldsEnabled() {
      return $this->addressFieldsEnabled;
   }

   function hasErrors() {
      return ($this->errorMessages != null);
   }

   function assignParams($paramArray = array()) {
      $subject = $this->getSubject();
      $body = $this->getBody();

      // Add commonly-used variables to the list
      if (isset($this->journal)) {
         // FIXME Include affiliation, title, etc. in signature?
         $paramArray['journalName'] = $this->journal->getJournalTitle();
         $paramArray['principalContactSignature'] = $this->journal->getSetting('contactName');
      } else {
         $site = &Request::getSite();
         $paramArray['principalContactSignature'] = $site->getSiteContactName();
      }
      if (!isset($paramArray['journalUrl'])) $paramArray['journalUrl'] = Request::url(Request::getRequestedJournalPath());

      // Replace variables in message with values
      foreach ($paramArray as $key => $value) {
         if (!is_object($value)) {
            $subject = str_replace('{$' . $key . '}', $value, $subject);
            $body = str_replace('{$' . $key . '}', $value, $body);
         }
      }

      $this->setSubject($subject);
      $this->setBody($body);
   }

   function isEnabled() {
      return $this->enabled;
   }

   function &processAddresses($currentList, &$newAddresses) {
      foreach ($newAddresses as $newAddress) {
         $regs = array();
         // Match the form "My Name <my_email@my.domain.com>"
         if (ereg('^([^<>' . "\n" . ']*[^<> ' . "\n" . '])[ ]*<([-A-Za-z0-9]+([-_\+\.][A-Za-z0-9]+)*@[A-Za-z0-9]+([-_\.][A-Za-z0-9]+)*\.[A-Za-z]{2,})>$', $newAddress, $regs)) {
            $currentList[] = array('name' => $regs[1], 'email' => $regs[2]);
         } elseif (ereg('^[A-Za-z0-9]+([-_\+\.][A-Za-z0-9]+)*@[A-Za-z0-9]+([-_\.][A-Za-z0-9]+)*\.[A-Za-z]{2,}$', $newAddress)) {
            $currentList[] = array('name' => '', 'email' => $newAddress);
         } else if ($newAddress != '') {
            $this->errorMessages[] = array('type' => MAIL_ERROR_INVALID_EMAIL, 'address' => $newAddress);
         }
      }
      return $currentList;
   }

   function displayEditForm($formActionUrl, $hiddenFormParams = null, $alternateTemplate = null, $additionalParameters = array()) {
      import('form.Form');
      $form = &new Form($alternateTemplate!=null?$alternateTemplate:'email/email.tpl');

      $form->setData('formActionUrl', $formActionUrl);
      $form->setData('subject', $this->getSubject());
      $form->setData('body', $this->getBody());

      $form->setData('to', $this->getRecipients());
      $form->setData('cc', $this->getCcs());
      $form->setData('bcc', $this->getBccs());
      $form->setData('blankTo', Request::getUserVar('blankTo'));
      $form->setData('blankCc', Request::getUserVar('blankCc'));
      $form->setData('blankBcc', Request::getUserVar('blankBcc'));
      $form->setData('from', $this->getFromString(false));

      $form->setData('addressFieldsEnabled', $this->getAddressFieldsEnabled());

      $user = &Request::getUser();
      if ($user) {
         $form->setData('senderEmail', $user->getEmail());
         $form->setData('bccSender', $this->bccSender);
      }

      if ($this->attachmentsEnabled) {
         $form->setData('attachmentsEnabled', true);
         $form->setData('persistAttachments', $this->persistAttachments);
      }

      $form->setData('errorMessages', $this->errorMessages);

      if ($hiddenFormParams != null) {
         $form->setData('hiddenFormParams', $hiddenFormParams);
      }

      foreach ($additionalParameters as $key => $value) {
         $form->setData($key, $value);
      }

      $templateMgr = &TemplateManager::getManager();
      $templateMgr->assign('helpTopicId', 'journal.managementPages.emails');

      $form->display();
   }

   function send($clearAttachments = true) {
      if (isset($this->journal)) {
         //If {$templateSignature} exists in the body of the
         // message, replace it with the journal signature;
         // otherwise just append it. This is here to
         // accomodate MIME-encoded messages or other cases
         // where the signature cannot just be appended.
         $searchString = '{$templateSignature}';
         if (strstr($this->getBody(), $searchString) === false) {
            $this->setBody($this->getBody() . "\n" . $this->journal->getSetting('emailSignature'));
         } else {
            $this->setBody(str_replace($searchString, $this->journal->getSetting('emailSignature'), $this->getBody()));
         }

         $envelopeSender = $this->journal->getSetting('envelopeSender');
         if (!empty($envelopeSender) && Config::getVar('email', 'allow_envelope_sender')) $this->setEnvelopeSender($envelopeSender);
      }

      if ($this->attachmentsEnabled) {
         foreach ($this->persistAttachments as $persistentAttachment) {
            $this->addAttachment(
               $persistentAttachment->getFilePath(),
               $persistentAttachment->getOriginalFileName(),
               $persistentAttachment->getFileType()
            );
         }
      }

      $user = &Request::getUser();

      if ($user && $this->bccSender) {
         $this->addBcc($user->getEmail(), $user->getFullName());
      }

      if (isset($this->skip) && $this->skip) {
         $result = true;
      } else {
         $result = parent::send();
      }

      if ($clearAttachments && $this->attachmentsEnabled) {
         $this->_clearAttachments($user->getUserId());
      }

      return $result;
   }

   function sendWithParams($paramArray) {
      $savedHeaders = $this->getHeaders();
      $savedSubject = $this->getSubject();
      $savedBody = $this->getBody();

      $this->assignParams($paramArray);

      $ret = $this->send();

      $this->setHeaders($savedHeaders);
      $this->setSubject($savedSubject);
      $this->setBody($savedBody);

      return $ret;
   }

   function clearRecipients($clearHeaders = true) {
      $this->setData('recipients', null);
      $this->setData('ccs', null);
      $this->setData('bccs', null);
      if ($clearHeaders) {
         $this->setData('headers', null);
      }
   }

   function addPersistAttachment($temporaryFile) {
      $this->persistAttachments[] = $temporaryFile;
   }

   function _handleAttachments($userId) {
      import('file.TemporaryFileManager');
      $temporaryFileManager = &new TemporaryFileManager();

      $this->attachmentsEnabled = true;
      $this->persistAttachments = array();

      $deleteAttachment = Request::getUserVar('deleteAttachment');

      if (Request::getUserVar('persistAttachments') != null) foreach (Request::getUserVar('persistAttachments') as $fileId) {
         $temporaryFile = $temporaryFileManager->getFile($fileId, $userId);
         if (!empty($temporaryFile)) {
            if ($deleteAttachment != $temporaryFile->getFileId()) {
               $this->persistAttachments[] = $temporaryFile;
            } else {
               // This file is being deleted.
               $temporaryFileManager->deleteFile($temporaryFile->getFileId(), $userId);
            }
         }
      }

      if (Request::getUserVar('addAttachment')) {
         $user = &Request::getUser();

         $this->persistAttachments[] = $temporaryFileManager->handleUpload('newAttachment', $user->getUserId());
      }
   }

   function getAttachmentFiles() {
      if ($this->attachmentsEnabled) return $this->persistAttachments;
      return array();
   }

   function _clearAttachments($userId) {
      import('file.TemporaryFileManager');
      $temporaryFileManager = &new TemporaryFileManager();

      $persistAttachments = Request::getUserVar('persistAttachments');
      if (is_array($persistAttachments)) foreach ($persistAttachments as $fileId) {
         $temporaryFile = $temporaryFileManager->getFile($fileId, $userId);
         if (!empty($temporaryFile)) {
            $temporaryFileManager->deleteFile($temporaryFile->getFileId(), $userId);
         }
      }
   }
}

?>

---