back.inc.php

<?php
 
class OAIMetadataFormat_JATS extends OAIMetadataFormat {
   protected function _findJats($article, $galleys) {
      import('lib.pkp.classes.submission.SubmissionFile'); // SUBMISSION_FILE_... constants
      $submissionFileDao = DAORegistry::getDAO('SubmissionFileDAO');
      $candidateFiles = array();
 
      // First, look for candidates in the galleys area (published content).
      foreach ($galleys as $galley) {
         $galleyFiles = $submissionFileDao->getLatestRevisionsByAssocId(ASSOC_TYPE_GALLEY, $galley->getId(), $galley->getSubmissionId(), SUBMISSION_FILE_PROOF);
         foreach ($galleyFiles as $galleyFile) {
            if ($this->_isCandidateFile($galleyFile)) $candidateFiles[] = $galleyFile;
         }
      }
 
      // If no candidates were found, look in the layout area (unpublished content).
      if (empty($candidateFiles)) {
         $layoutFiles = $submissionFileDao->getLatestRevisions($article->getId(), SUBMISSION_FILE_PRODUCTION_READY);
         foreach ($layoutFiles as $layoutFile) {
            if ($this->_isCandidateFile($layoutFile)) $candidateFiles[] = $layoutFile;
         }
      }
 
      $doc = null;
      HookRegistry::call('OAIMetadataFormat_JATS::findJats', array(&$this, &$candidateFiles, &$doc));
 
      // If no candidate files were located, return the null XML.
      if (!$doc && empty($candidateFiles)) {
         return null;
      }
      if (count($candidateFiles) > 1) error_log('WARNING: More than one JATS XML candidate documents were located for submission ' . $article->getId() . '.');
 
      // Fetch the XML document
      if (!$doc) {
         $candidateFile = array_shift($candidateFiles);
         $doc = new DOMDocument;
         $doc->loadXML(file_get_contents($candidateFile->getFilePath()));
      }
 
      return $doc;
   }
 
   public function toXml($record, $format = null) {
      $oaiDao = DAORegistry::getDAO('OAIDAO');
      $journal = $record->getData('journal');
      $article = $record->getData('article');
      $galleys = $record->getData('galleys');
      $section = $record->getData('section');
      $issue = $record->getData('issue');
 
      // Check access
      import('classes.issue.IssueAction');
      $subscriptionRequired = IssueAction::subscriptionRequired($issue, $journal);
      $isSubscribedDomain = IssueAction::subscribedDomain(Application::get()->getRequest(), $journal, $issue->getId(), $article->getId());
      if ($subscriptionRequired && !$subscriptionRequired) {
         $oaiDao->oai->error('cannotDisseminateFormat', 'Cannot disseminate format (JATS XML not available)');
      }
 
      $doc = $this->_findJats($article, $galleys);
      if (!$doc) {
         $oaiDao->oai->error('cannotDisseminateFormat', 'Cannot disseminate format (JATS XML not available)');
      }
 
      $this->_mungeMetadata($doc, $journal, $article, $section, $issue);
 
      return $doc->saveXml($doc->getElementsByTagName('article')->item(0));
   }
 
   protected function _addChildInOrder($parentNode, $childNode) {
      $permittedElementOrders = array(
         'article-meta' => array('article-id', 'article-categories', 'title-group', 'contrib-group', 'aff', 'aff-alternatives', 'x', 'author-notes', 'pub-date', 'volume', 'volume-id', 'volume-series', 'issue', 'issue-id', 'issue-title', 'issue-sponsor', 'issue-part', 'isbn', 'supplement', 'fpage', 'lpage', 'page-range', 'elocation-id', 'email', 'ext-link', 'uri', 'product', 'supplementary-material', 'history', 'permissions', 'self-uri', 'related-article', 'related-object', 'abstract', 'trans-abstract', 'kwd-group', 'funding-group', 'conference', 'counts', 'custom-meta-group'),
         'journal-meta' => array('journal-id', 'journal-title-group', 'contrib-group', 'aff', 'aff-alternatives', 'issn', 'issn-l', 'isbn', 'publisher', 'notes', 'self-uri', 'custom-meta-group'),
      );
      assert(isset($permittedElementOrders[$parentNode->nodeName])); // We have an order list for the parent node
      $order = $permittedElementOrders[$parentNode->nodeName];
      $position = array_search($childNode->nodeName, $order);
      assert($position !== false); // The child node appears in the order list
 
      $followingElements = array_slice($order, $position);
      $followingElement = null;
      foreach ($parentNode->childNodes as $node) {
         if (in_array($node->nodeName, $followingElements)) {
            $followingElement = $node;
            break;
         }
      }
 
      return $parentNode->insertBefore($childNode, $followingElement);
   }
 
   protected function _mungeMetadata($doc, $journal, $article, $section, $issue) {
      $xpath = new DOMXPath($doc);
      $articleMetaNode = $xpath->query('//article/front/article-meta')->item(0);
      $journalMetaNode = $xpath->query('//article/front/journal-meta')->item(0);
      if (!$journalMetaNode) {
         $frontNode = $xpath->query('//article/front')->item(0);
         $journalMetaNode = $this->_addChildInOrder($frontNode, $doc->createElement('journal-meta'));
      }
 
      // Set the article language.
      $xpath->query('//article')->item(0)->setAttribute('xml:lang', substr($article->getLocale(),0,2));
 
      // Set the publication date.
      if ($datePublished = $article->getDatePublished()) {
         $datePublished = strtotime($datePublished);
         $match = $xpath->query("//article/front/article-meta/pub-date[@date-type='pub' and publication-format='epub']");
         if ($match->length) {
            // An existing pub-date was found; empty and re-use.
            $dateNode = $match->item(0);
            while ($dateNode->hasChildNodes()) $dateNode->removeChild($dateNode->firstChild);
         } else {
            // No pub-date was found; create a new one.
            $dateNode = $this->_addChildInOrder($articleMetaNode, $doc->createElement('pub-date'));
            $dateNode->setAttribute('date-type', 'pub');
            $dateNode->setAttribute('publication-format', 'epub');
         }
 
         $dateNode->setAttribute('iso-8601-date', strftime('%Y-%m-%d', $datePublished));
         $dateNode->appendChild($doc->createElement('day'))->nodeValue = strftime('%d', $datePublished);
         $dateNode->appendChild($doc->createElement('month'))->nodeValue = strftime('%m', $datePublished);
         $dateNode->appendChild($doc->createElement('year'))->nodeValue = strftime('%Y', $datePublished);
      }
 
      $issueYear = null;
      if ($issue && $issue->getShowYear()) $issueYear = $issue->getYear();
      if (!$issueYear && $datePublished) $issueYear = strftime('%Y', $datePublished);
      if ($issueYear) {
         $match = $xpath->query("//article/front/article-meta/pub-date[@date-type='issue' and publication-format='epub']");
         if ($match->length) {
            // An existing pub-date was found; empty and re-use.
            $dateNode = $match->item(0);
            while ($dateNode->hasChildNodes()) $dateNode->removeChild($dateNode->firstChild);
         } else {
            // No pub-date was found; create a new one.
            $dateNode = $this->_addChildInOrder($articleMetaNode, $doc->createElement('pub-date'));
            $dateNode->setAttribute('date-type', 'issue');
            $dateNode->setAttribute('publication-format', 'epub');
         }
         $dateNode->setAttribute('iso-8601-date', strftime('%Y-%m-%d', $datePublished));
         $dateNode->appendChild($doc->createElement('day'))->nodeValue = strftime('%d', $datePublished);
         $dateNode->appendChild($doc->createElement('month'))->nodeValue = strftime('%m', $datePublished);
         $dateNode->appendChild($doc->createElement('year'))->nodeValue = strftime('%Y', $datePublished);
      }
 
      // Set the article title.
      $titleGroupNode = $xpath->query('//article/front/article-meta/title-group')->item(0);
      foreach ($titleGroupNode->getElementsByTagName('article-title') as $titleNode) $titleGroupNode->removeChild($titleNode);
      foreach ($article->getTitle(null) as $locale => $title) {
         $titleNode = $titleGroupNode->appendChild($doc->createElement('article-title'));
         $titleNode->setAttribute('xml:lang', substr($locale,0,2));
         $titleNode->nodeValue = $title;
      }
 
      // Set the article abstract.
      static $purifier;
      if (!$purifier) {
         $config = HTMLPurifier_Config::createDefault();
         $config->set('HTML.Allowed', 'p');
         $config->set('Cache.SerializerPath', 'cache');
         $purifier = new HTMLPurifier($config);
      }
      foreach ($articleMetaNode->getElementsByTagName('abstract') as $abstractNode) $articleMetaNode->removeChild($abstractNode);
      foreach ((array) $article->getAbstract(null) as $locale => $abstract) {
         $abstractNode = $this->_addChildInOrder($articleMetaNode, $doc->createElement('abstract'));
         $abstractNode->setAttribute('xml:lang', substr($locale,0,2));
         $abstractNode->nodeValue = $purifier->purify($abstract);
      }
 
      // Set the journal-id[publisher-id']
      $match = $xpath->query("//article/front/journal-meta/journal-id[@journal-id-type='publisher-id']");
      if ($match->length) $match->item(0)->nodeValue = $journal->getPath();
      else {
         $journalIdNode = $this->_addChildInOrder($journalMetaNode, $doc->createElement('journal-id'));
         $journalIdNode->setAttribute('journal-id-type', 'publisher-id');
         $journalIdNode->nodeValue = $journal->getPath();
      }
 
      // Store the DOI
      if ($doi = trim($article->getStoredPubId('doi'))) {
         $match = $xpath->query("//article/front/article-meta/article-id[@pub-id-type='doi']");
         if ($match->length) $match->item(0)->nodeValue = $doi;
         else {
            $articleIdNode = $this->_addChildInOrder($articleMetaNode, $doc->createElement('article-id'));
            $articleIdNode->setAttribute('pub-id-type', 'doi');
            $articleIdNode->nodeValue = $doi;
         }
      }
 
      // Override permissions, when not supplied in the document
      $match = $xpath->query('//article/front/article-meta/permissions');
      $copyrightHolder = $article->getLocalizedCopyrightHolder($article->getLocale());
      $copyrightYear = $article->getCopyrightYear();
      $licenseUrl = $article->getLicenseURL();
      if (!$match->length && ($copyrightHolder || $copyrightYear || $licenseUrl)) {
         $permissionsNode = $this->_addChildInOrder($articleMetaNode, $doc->createElement('permissions'));
         if ($copyrightYear) $permissionsNode->appendChild($doc->createElement('copyright-year'))->nodeValue = $copyrightYear;
         if ($copyrightHolder) $permissionsNode->appendChild($doc->createElement('copyright-holder'))->nodeValue = $copyrightHolder;
         if ($licenseUrl) {
            $licenseNode = $permissionsNode->appendChild($doc->createElement('license'));
            $licenseNode->setAttribute('xlink:href', $licenseUrl);
         }
      }
 
      // Section information
      $match = $xpath->query("//article/front/article-meta/article-categories");
      if ($match->length) $articleCategoriesNode = $match->item(0);
      else {
         $articleCategoriesNode = $this->_addChildInOrder($articleMetaNode, $doc->createElement('article-categories'));
      }
      $match = $xpath->query('//article/front/article-meta/subj-group[@subj-group-type="heading"]');
      if ($match->length) $subjGroupNode = $match->item(0);
      else {
         $subjGroupNode = $articleCategoriesNode->appendChild($doc->createElement('subj-group'));
         $subjGroupNode->setAttribute('subj-group-type', 'heading');
      }
      $subjectNode = $subjGroupNode->appendChild($doc->createElement('subject'));
      $subjectNode->nodeValue = $section->getTitle($journal->getPrimaryLocale());
 
      // Article sequence information
      $publishedArticleDao = DAORegistry::getDAO('PublishedArticleDAO');
      $articleIds = array_map(function($publishedArticle) {
         return $publishedArticle->getId();
      }, $publishedArticleDao->getPublishedArticles($issue->getId()));
      foreach (array('volume', 'number') as $nodeName) {
         $match = $xpath->query("//article/front/article-meta/$nodeName");
         if ($match->length) $match->item(0)->setAttribute('seq', array_search($article->getId(), $articleIds));
      }
 
      // Issue ID
      $match = $xpath->query("//article/front/article-meta/issue-id");
      if ($match->length) $match->item(0)->nodeValue = $issue->getId();
      else {
         $issueIdNode = $this->_addChildInOrder($articleMetaNode, $doc->createElement('issue-id'));
         $issueIdNode->nodeValue = $issue->getId();
      }
 
      // Article type
      if ($articleType = trim($section->getLocalizedIdentifyType())) {
         $articleNode = $xpath->query("//article")->item(0);
         $articleNode->setAttribute('article-type', $articleType);
      }
 
      // Editorial team
      $userGroupDao = DAORegistry::getDAO('UserGroupDAO');
      $userGroups = $userGroupDao->getByContextId($journal->getId());
      $journalMetaNode = $xpath->query('//article/front/journal-meta')->item(0);
      $contribGroupNode = $this->_addChildInOrder($journalMetaNode, $doc->createElement('contrib-group'));
      $keyContribTypeMapping = array(
         'default.groups.name.manager' => 'jmanager',
         'default.groups.name.editor' => 'editor',
         'default.groups.name.sectionEditor' => 'secteditor',
      );
      while ($userGroup = $userGroups->next()) {
         if (!isset($keyContribTypeMapping[$userGroup->getData('nameLocaleKey')])) continue;
 
         $users = $userGroupDao->getUsersById($userGroup->getId());
         while ($user = $users->next()) {
            $contribNode = $contribGroupNode->appendChild($doc->createElement('contrib'));
            $contribNode->setAttribute('contrib-type', $keyContribTypeMapping[$userGroup->getData('nameLocaleKey')]);
            $nameNode = $contribNode->appendChild($doc->createElement('name'));
            $surnameNode = $nameNode->appendChild($doc->createElement('surname'));
            $surnameNode->nodeValue = method_exists($user, 'getLastName')?$user->getLastName():$user->getLocalizedFamilyName();
            $givenNamesNode = $nameNode->appendChild($doc->createElement('given-names'));
            $givenNamesNode->nodeValue = method_exists($user, 'getFirstName')?$user->getFirstName():$user->getLocalizedGivenName();
            if (method_exists($user, 'getMiddleName') && $s = $user->getMiddleName()) $givenNamesNode->nodeValue .= " $s";
         }
      }
 
   }
 
   protected function _isCandidateFile($submissionFile) {
      // The file type isn't XML.
      if (!in_array($submissionFile->getFileType(), array('application/xml', 'text/xml'))) return false;
 
      static $genres = array();
      $genreDao = DAORegistry::getDAO('GenreDAO');
      $genreId = $submissionFile->getGenreId();
      if (!isset($genres[$genreId])) $genres[$genreId] = $genreDao->getById($genreId);
      assert($genres[$genreId]);
      $genre = $genres[$genreId];
 
      // The genre doesn't look like a main submission document.
      if ($genre->getCategory() != GENRE_CATEGORY_DOCUMENT) return false;
      if ($genre->getDependent()) return false;
      if ($genre->getSupplementary()) return false;
 
      return true;
   }
}