PKPPubIdPlugin.inc.php

<?php
 
import('lib.pkp.classes.plugins.Plugin');
 
abstract class PKPPubIdPlugin extends LazyLoadPlugin {
 
   //
   // Implement template methods from Plugin
   //
   function register($category, $path, $mainContextId = null) {
      if (!parent::register($category, $path, $mainContextId)) return false;
      if ($this->getEnabled($mainContextId)) {
         // Enable storage of additional fields.
         foreach($this->getDAOs() as $dao) {
            // Augment the object with the additional properties required by the pub ID plugin.
            if ($dao instanceof SchemaDAO) {
               // Schema-backed DAOs need the schema extended.
               HookRegistry::register('Schema::get::' . $dao->schemaName, array($this, 'addToSchema'));
            } else {
               // For non-schema-backed DAOs, DAOName::getAdditionalFieldNames can be used.
               HookRegistry::register(strtolower_codesafe(get_class($dao)).'::getAdditionalFieldNames', array($this, 'getAdditionalFieldNames'));
               if (strtolower_codesafe(get_class($dao)) == 'submissionfiledao') {
                  // if it is a file, consider all file delegates
                  $fileDAOdelegates = $this->getFileDAODelegates();
                  foreach ($fileDAOdelegates as $fileDAOdelegate) {
                     HookRegistry::register(strtolower_codesafe($fileDAOdelegate).'::getAdditionalFieldNames', array($this, 'getAdditionalFieldNames'));
                  }
               }
            }
         }
      }
      $this->addLocaleData();
      return true;
   }
 
   function getActions($request, $actionArgs) {
      $router = $request->getRouter();
      import('lib.pkp.classes.linkAction.request.AjaxModal');
      return array_merge(
         $this->getEnabled()?array(
            new LinkAction(
               'settings',
               new AjaxModal(
                  $router->url($request, null, null, 'manage', null, $actionArgs),
                  $this->getDisplayName()
               ),
               __('manager.plugins.settings'),
               null
            ),
         ):array(),
         parent::getActions($request, $actionArgs)
      );
   }
 
   function manage($args, $request) {
      $user = $request->getUser();
      $router = $request->getRouter();
      $context = $router->getContext($request);
 
      $form = $this->instantiateSettingsForm($context->getId());
      $notificationManager = new NotificationManager();
      switch ($request->getUserVar('verb')) {
         case 'save':
            $form->readInputData();
            if ($form->validate()) {
               $form->execute();
               $notificationManager->createTrivialNotification($user->getId(), NOTIFICATION_TYPE_SUCCESS);
               return new JSONMessage(true);
            }
            return new JSONMessage(true, $form->fetch($request));
         case 'clearPubIds':
            if (!$request->checkCSRF()) return new JSONMessage(false);
            $contextDao = Application::getContextDAO();
            $contextDao->deleteAllPubIds($context->getId(), $this->getPubIdType());
            return new JSONMessage(true);
         default:
            $form->initData();
            return new JSONMessage(true, $form->fetch($request));
      }
      return parent::manage($args, $request);
   }
 
 
   //
   // Protected template methods to be implemented by sub-classes.
   //
   abstract function getPubId($pubObject);
 
   abstract function constructPubId($pubIdPrefix, $pubIdSuffix, $contextId);
 
   abstract function getPubIdType();
 
   abstract function getPubIdDisplayType();
 
   abstract function getPubIdFullName();
 
   abstract function getResolvingURL($contextId, $pubId);
 
   abstract function getPubIdMetadataFile();
 
   function addJavaScript($request, $templateMgr) { }
 
   abstract function getPubIdAssignFile();
 
   abstract function instantiateSettingsForm($contextId);
 
   abstract function getFormFieldNames();
 
   abstract function getAssignFormFieldName();
 
   abstract function getPrefixFieldName();
 
   abstract function getSuffixFieldName();
 
   abstract function getLinkActions($pubObject);
 
   abstract function getSuffixPatternsFieldNames();
 
   abstract function getDAOFieldNames();
 
   function getPubObjectTypes()  {
      return array('Publication', 'Representation', 'SubmissionFile');
   }
 
   abstract function isObjectTypeEnabled($pubObjectType, $contextId);
 
   abstract function getNotUniqueErrorMsg();
 
   function verifyData($fieldName, $fieldValue, $pubObject, $contextId, &$errorMsg) {
      // Verify pub id uniqueness.
      if ($fieldName == $this->getSuffixFieldName()) {
         if (empty($fieldValue)) return true;
 
         // Construct the potential new pub id with the posted suffix.
         $pubIdPrefix = $this->getSetting($contextId, $this->getPrefixFieldName());
         if (empty($pubIdPrefix)) return true;
         $newPubId = $this->constructPubId($pubIdPrefix, $fieldValue, $contextId);
 
         if (!$this->checkDuplicate($newPubId, $pubObject->getId(), get_class($pubObject), $contextId)) {
            $errorMsg = $this->getNotUniqueErrorMsg();
            return false;
         }
      }
      return true;
   }
 
   function validatePubId($pubId) {
      return true; // Assume a valid ID by default;
   }
 
   function getDAOs() {
      return  array(
         DAORegistry::getDAO('PublicationDAO'),
         DAORegistry::getDAO('SubmissionDAO'),
         Application::getRepresentationDAO(),
         DAORegistry::getDAO('SubmissionFileDAO'),
      );
   }
 
   function getFileDAODelegates()  {
      return array('SubmissionFileDAODelegate', 'SupplementaryFileDAODelegate', 'SubmissionArtworkFileDAODelegate');
   }
 
   function canBeAssigned($pubObject) {
      // Has the pub id already been assigned.
      $pubIdType = $this->getPubIdType();
      $storedPubId = $pubObject->getStoredPubId($pubIdType);
      if ($storedPubId) return false;
      // Get the pub id.
      $pubId = $this->getPubId($pubObject);
      // Is the custom suffix empty i.e. the pub id null.
      if (!$pubId) return false;
      // Does the suffix contain unresolved pattern.
      $containPatterns = strpos($pubId, '%') !== false;
      return !$containPatterns;
   }
 
   public function addToSchema($hookName, $params) {
      $schema =& $params[0];
      foreach (array_merge($this->getFormFieldNames(), $this->getDAOFieldNames()) as $fieldName) {
         $schema->properties->{$fieldName} = (object) [
            'type' => 'string',
            'apiSummary' => true,
            'validation' => ['nullable'],
         ];
      }
      return false;
   }
 
   function getAdditionalFieldNames($hookName, $params) {
      $fields =& $params[1];
      foreach (array_merge($this->getFormFieldNames(), $this->getDAOFieldNames()) as $fieldName) {
         $fields[] = $fieldName;
      }
      return false;
   }
 
   function getPubObjectType($pubObject) {
      $allowedTypes = $this->getPubObjectTypes();
      $pubObjectType = null;
      foreach ($allowedTypes as $allowedType) {
         if (is_a($pubObject, $allowedType)) {
            $pubObjectType = $allowedType;
            break;
         }
      }
      if (is_null($pubObjectType)) {
         // This must be a dev error, so bail with an assertion.
         assert(false);
         return null;
      }
      return $pubObjectType;
   }
 
   function setStoredPubId(&$pubObject, $pubId) {
      $dao = $pubObject->getDAO();
      $dao->changePubId($pubObject->getId(), $this->getPubIdType(), $pubId);
      $pubObject->setStoredPubId($this->getPubIdType(), $pubId);
   }
 
 
   //
   // Public API
   //
   function checkDuplicate($pubId, $pubObjectType, $excludeId, $contextId) {
      foreach ($this->getPubObjectTypes() as $type) {
         if ($type === 'Publication') {
            $typeDao = DAORegistry::getDAO('PublicationDAO'); /* @var $typeDao PublicationDAO */
         } elseif ($type === 'Representation') {
            $typeDao = Application::getRepresentationDAO();
         } elseif ($type === 'SubmissionFile') {
            $typeDao = DAORegistry::getDAO('SubmissionFileDAO'); /* @var $typeDao SubmissionFileDAO */
         }
         $excludeTypeId = $type === $pubObjectType ? $excludeId : null;
         if (isset($typeDao) && $typeDao->pubIdExists($this->getPubIdType(), $pubId, $excludeTypeId, $contextId)) {
            return false;
         }
      }
 
      return true;
   }
 
   function getContext($contextId) {
      assert(is_numeric($contextId));
 
      // Get the context object from the context (optimized).
      $request = Application::get()->getRequest();
      $router = $request->getRouter();
      $context = $router->getContext($request);
      if ($context && $context->getId() == $contextId) return $context;
 
      // Fall back the database.
      $contextDao = Application::getContextDAO();
      return $contextDao->getById($contextId);
   }
 
}