PKPEmailTemplateService.inc.php

<?php
namespace PKP\Services;
 
use \Application;
use \DAOResultFactory;
use \DAORegistry;
use \DBResultRange;
use \HookRegistry;
use \Services;
use \PKP\Services\interfaces\EntityPropertyInterface;
use \PKP\Services\interfaces\EntityReadInterface;
use \PKP\Services\interfaces\EntityWriteInterface;
use \PKP\Services\QueryBuilders\PKPEmailTemplateQueryBuilder;
 
define('EMAIL_TEMPLATE_STAGE_DEFAULT', 0);
 
import('lib.pkp.classes.db.DBResultRange');
 
class PKPEmailTemplateService implements EntityPropertyInterface, EntityReadInterface, EntityWriteInterface {
 
   public function get($emailTemplateId) {
      throw new \Exception('Use the PKPEmailTemplateService::getByKey() method to retrieve an email template.');
   }
 
   public function getByKey($contextId, $key) {
      $emailTemplateQB = new PKPEmailTemplateQueryBuilder();
      $emailTemplateQueryParts = $emailTemplateQB
         ->filterByContext($contextId)
         ->filterByKeys([$key])
         ->getCompiledQuery();
      $emailTemplateDao = DAORegistry::getDAO('EmailTemplateDAO'); /* @var $emailTemplateDao EmailTemplateDAO */
      $result = $emailTemplateDao->retrieve($emailTemplateQueryParts[0], $emailTemplateQueryParts[1]);
      if ($result->RecordCount() !== 0) {
         $emailTemplate = $emailTemplateDao->_fromRow($result->GetRowAssoc(false));
      }
      $result->Close();
      return !empty($emailTemplate) ? $emailTemplate : null;
   }
 
   public function getCount($args = []) {
      return $this->getQueryBuilder($args)->getCount();
   }
 
   public function getIds($args = []) {
      throw new \Exception('PKPEmailTemplateService::getIds() is not supported. Email templates should be referenced by key instead of id.');
   }
 
   public function getMany($args = []) {
      $emailTemplateQueryParts = $this->getQueryBuilder($args)->getCompiledQuery();
      $emailTemplateDao = DAORegistry::getDAO('EmailTemplateDAO'); /* @var $emailTemplateDao EmailTemplateDAO */
      $result = $emailTemplateDao->retrieveRange($emailTemplateQueryParts[0], $emailTemplateQueryParts[1]);
      $queryResults = new DAOResultFactory($result, $emailTemplateDao, '_fromRow');
 
      return $queryResults->toIterator();
   }
 
   public function getMax($args = []) {
      // Count/offset is not supported so getMax is always
      // the same as getCount
      return $this->getCount();
   }
 
   public function getQueryBuilder($args = []) {
      $context = Application::get()->getRequest()->getContext();
 
      $defaultArgs = array(
         'contextId' => $context ? $context->getId() : CONTEXT_SITE,
         'isEnabled' => null,
         'isCustom' => null,
         'fromRoleIds' => null,
         'toRoleIds' => null,
         'stageIds' => null,
         'searchPhrase' => null,
      );
 
      $args = array_merge($defaultArgs, $args);
 
      $emailTemplateQB = new PKPEmailTemplateQueryBuilder();
      $emailTemplateQB
         ->filterByContext($args['contextId'])
         ->filterByIsEnabled($args['isEnabled'])
         ->filterByIsCustom($args['isCustom'])
         ->filterByFromRoleIds($args['fromRoleIds'])
         ->filterByToRoleIds($args['toRoleIds'])
         ->filterByStageIds($args['stageIds'])
         ->searchPhrase($args['searchPhrase']);
 
      HookRegistry::call('EmailTemplate::getMany::queryBuilder', array($emailTemplateQB, $args));
 
      return $emailTemplateQB;
   }
 
   public function getProperties($emailTemplate, $props, $args = null) {
 
      $values = array();
 
      foreach ($props as $prop) {
         switch ($prop) {
            case '_href':
               if ($emailTemplate->getData('contextId')) {
                  $context = Services::get('context')->get($emailTemplate->getData('contextId'));
               } else {
                  $context = $args['request']->getContext();
               }
               $values[$prop] = $args['request']->getDispatcher()->url(
                  $args['request'],
                  ROUTE_API,
                  $context->getData('urlPath'),
                  'emailTemplates/' . $emailTemplate->getData('key')
               );
               break;
            default:
               $values[$prop] = $emailTemplate->getData($prop);
               break;
         }
      }
 
      if ($args['supportedLocales']) {
         $values = Services::get('schema')->addMissingMultilingualValues(SCHEMA_EMAIL_TEMPLATE, $values, $args['supportedLocales']);
      }
 
      HookRegistry::call('EmailTemplate::getProperties', array(&$values, $emailTemplate, $props, $args));
 
      ksort($values);
 
      return $values;
   }
 
   public function getSummaryProperties($emailTemplate, $args = null) {
      $props = Services::get('schema')->getSummaryProps(SCHEMA_EMAIL_TEMPLATE);
 
      return $this->getProperties($emailTemplate, $props, $args);
   }
 
   public function getFullProperties($emailTemplate, $args = null) {
      $props = Services::get('schema')->getFullProps(SCHEMA_EMAIL_TEMPLATE);
 
      return $this->getProperties($emailTemplate, $props, $args);
   }
 
   public function validate($action, $props, $allowedLocales, $primaryLocale) {
      $schemaService = Services::get('schema');
 
      import('lib.pkp.classes.validation.ValidatorFactory');
      $validator = \ValidatorFactory::make(
         $props,
         $schemaService->getValidationRules(SCHEMA_EMAIL_TEMPLATE, $allowedLocales)
      );
 
      \AppLocale::requireComponents(
         LOCALE_COMPONENT_PKP_MANAGER,
         LOCALE_COMPONENT_APP_MANAGER
      );
 
      // Check required fields
      \ValidatorFactory::required(
         $validator,
         $action,
         $schemaService->getRequiredProps(SCHEMA_EMAIL_TEMPLATE),
         $schemaService->getMultilingualProps(SCHEMA_EMAIL_TEMPLATE),
         $allowedLocales,
         $primaryLocale
      );
 
      if ($action === VALIDATE_ACTION_ADD) {
 
         // Require a context id
         $validator->after(function($validator) use ($props) {
            if (!isset($props['contextId'])) {
               $validator->errors()->add('contextId', __('manager.emails.emailTemplate.contextRequired'));
            }
         });
 
         // Don't allow duplicate keys in the same context
         $validator->after(function($validator) use ($props) {
            if (!isset($props['contextId'])) {
               return;
            }
            $existingEmailTemplate = $this->getByKey($props['contextId'], $props['key']);
            if (!empty($existingEmailTemplate) && !empty($existingEmailTemplate->getData('id'))) {
               $validator->errors()->add('key', __('manager.emails.emailTemplate.noDuplicateKeys'));
            }
         });
      }
 
      // Check for input from disallowed locales
      \ValidatorFactory::allowedLocales($validator, $schemaService->getMultilingualProps(SCHEMA_EMAIL_TEMPLATE), $allowedLocales);
 
      if ($validator->fails()) {
         $errors = $schemaService->formatValidationErrors($validator->errors(), $schemaService->get(SCHEMA_EMAIL_TEMPLATE), $allowedLocales);
      }
 
      HookRegistry::call('EmailTemplate::validate', array(&$errors, $action, $props, $allowedLocales, $primaryLocale));
 
      return $errors;
   }
 
   public function add($emailTemplate, $request) {
      if ($emailTemplate->getData('contextId')) {
         $contextId = $emailTemplate->getData('contextId');
      } else {
         $context = $request->getContext();
         $contextId = $context ? $context->getId() : CONTEXT_SITE;
      }
 
      $emailTemplateDao = DAORegistry::getDAO('EmailTemplateDAO'); /* @var $emailTemplateDao EmailTemplateDAO */
      $emailTemplateDao->insertObject($emailTemplate);
      $emailTemplate = $this->getByKey($contextId, $emailTemplate->getData('key'));
 
      HookRegistry::call('EmailTemplate::add', array($emailTemplate, $request));
 
      return $emailTemplate;
   }
 
   public function edit($emailTemplate, $params, $request) {
      $emailTemplateDao = DAORegistry::getDAO('EmailTemplateDAO'); /* @var $emailTemplateDao EmailTemplateDAO */
      $newEmailTemplate = $emailTemplateDao->newDataObject();
      $newEmailTemplate->_data = array_merge($emailTemplate->_data, $params);
 
      HookRegistry::call('EmailTemplate::edit', array($newEmailTemplate, $emailTemplate, $params, $request));
 
      $emailTemplateKey = $emailTemplate->getData('key');
 
      // When editing a default template for the first time, we must insert a new entry
      // in the email_templates table.
      if ($newEmailTemplate->getData('id')) {
         $emailTemplateDao->updateObject($newEmailTemplate);
      } else {
         $emailTemplateDao->insertObject($newEmailTemplate);
      }
 
      if ($newEmailTemplate->getData('contextId')) {
         $contextId = $newEmailTemplate->getData('contextId');
      } else {
         $context = $request->getContext();
         $contextId = $context ? $context->getId() : CONTEXT_SITE;
      }
 
      $newEmailTemplate = $this->getByKey($contextId, $newEmailTemplate->getData('key'));
 
      return $newEmailTemplate;
   }
 
   public function delete($emailTemplate) {
      HookRegistry::call('EmailTemplate::delete::before', array($emailTemplate));
      $emailTemplateDao = DAORegistry::getDAO('EmailTemplateDAO'); /* @var $emailTemplateDao EmailTemplateDAO */
      $emailTemplateDao->deleteObject($emailTemplate);
      HookRegistry::call('EmailTemplate::delete', array($emailTemplate));
   }
 
   public function restoreDefaults($contextId) {
      $emailTemplateQB = new PKPEmailTemplateQueryBuilder();
      $emailTemplateQB->filterByContext($contextId);
      $emailTemplateQO = $emailTemplateQB->getModified();
      $emailTemplateDao = DAORegistry::getDAO('EmailTemplateDAO'); /* @var $emailTemplateDao EmailTemplateDAO */
      $result = $emailTemplateDao->retrieve($emailTemplateQO->toSql(), $emailTemplateQO->getBindings());
      $queryResults = new DAOResultFactory($result, $emailTemplateDao, '_fromRow');
      $deletedKeys = [];
      while ($emailTemplate = $queryResults->next()) {
         $deletedKeys[] = $emailTemplate->getData('key');
         $this->delete($emailTemplate);
      }
      HookRegistry::call('EmailTemplate::restoreDefaults', array(&$deletedKeys, $contextId));
      return $deletedKeys;
   }
}