NativeXmlPKPPublicationFilter.inc.php

<?php
 
import('lib.pkp.plugins.importexport.native.filter.NativeImportFilter');
 
class NativeXmlPKPPublicationFilter extends NativeImportFilter {
   function __construct($filterGroup) {
      $this->setDisplayName('Native XML publication import');
      parent::__construct($filterGroup);
   }
 
 
   //
   // Implement template methods from PersistableFilter
   //
   function getClassName() {
      return 'lib.pkp.plugins.importexport.native.filter.NativeXmlPKPPublicationFilter';
   }
 
 
   //
   // Implement template methods from NativeImportFilter
   //
   function getPluralElementName() {
      return 'publications';
   }
 
   function getSingularElementName() {
      return 'publication';
   }
 
   function handleElement($node) {
      $deployment = $this->getDeployment();
      $context = $deployment->getContext();
 
      $submission = $deployment->getSubmission();
 
      $publicationDao = DAORegistry::getDAO('PublicationDAO');
      $publication = $publicationDao->newDataObject(); 
      $publication->setData('submissionId', $submission->getId());
 
      $publication->stampModified();
      $publication = $this->populateObject($publication, $node);
 
      $publicationLocale = $node->getAttribute('locale');
      if (empty($publicationLocale)) 
         $publicationLocale = $context->getPrimaryLocale();
 
      $publication->setData('locale', $publicationLocale);
      $publication->setData('version', $node->getAttribute('version'));
      $publication->setData('seq', $node->getAttribute('seq'));
      $publication->setData('accessStatus', $node->getAttribute('access_status'));
      $publication->setData('status', $node->getAttribute('status'));
      $publication->setData('primaryContactId', $node->getAttribute('primary_contact_id'));
      $publication->setData('urlPath', $node->getAttribute('url_path'));
 
      $publication = Services::get('publication')->add($publication, Application::get()->getRequest());
      $deployment->setPublication($publication);
 
      for ($n = $node->firstChild; $n !== null; $n=$n->nextSibling) {
         if (is_a($n, 'DOMElement')) {
            $this->handleChildElement($n, $publication);
         }
      }
 
      $publication = Services::get('publication')->edit($publication, array(), Application::get()->getRequest());
 
      return $publication;
   }
 
   function populateObject($publication, $node) {
 
      if ($datePublished = $node->getAttribute('date_published')) {
         $publication->setData('datePublished', $datePublished);
      }
 
      return $publication;
   }
 
   function handleChildElement($n, $publication) {
      $setterMappings = $this->_getLocalizedPublicationFields();
      $controlledVocabulariesMappings = $this->_getControlledVocabulariesMappings();
 
      list($locale, $value) = $this->parseLocalizedContent($n);
      if (empty($locale)) $locale = $publication->getData('locale');
 
      if (in_array($n->tagName, $setterMappings)) {
         $publication->setData($n->tagName, $value, $locale);
      } elseif (isset($controlledVocabulariesMappings[$n->tagName])) {
         $controlledVocabulariesDao = $submissionKeywordDao = DAORegistry::getDAO($controlledVocabulariesMappings[$n->tagName][0]);
         $insertFunction = $controlledVocabulariesMappings[$n->tagName][1];
 
         $controlledVocabulary = array();
         for ($nc = $n->firstChild; $nc !== null; $nc=$nc->nextSibling) {
            if (is_a($nc, 'DOMElement')) {
               $controlledVocabulary[] = $nc->textContent;
            }
         }
         
         $controlledVocabulariesValues = array();
         $controlledVocabulariesValues[$locale] = $controlledVocabulary;
 
         $controlledVocabulariesDao->$insertFunction($controlledVocabulariesValues, $publication->getId(), false);
 
         $publicationNew = Services::get('publication')->get($publication->getId());
         $publication->setData($n->tagName, $publicationNew->getData($n->tagName));
      } else switch ($n->tagName) {
         // Otherwise, delegate to specific parsing code
         case 'id':
            $this->parseIdentifier($n, $publication);
            break;
         case 'authors':
            $this->parseAuthors($n, $publication);
            break;
         case 'citations':
            $this->parseCitations($n, $publication);
            break;
         case 'copyrightYear':
            $publication->setData('copyrightYear', $n->textContent);
            break;
         case 'licenseUrl':
            $publication->setData('licenseUrl', $n->textContent);
            break;
         default:
            $deployment = $this->getDeployment();
            $deployment->addWarning(ASSOC_TYPE_PUBLICATION, $publication->getId(), __('plugins.importexport.common.error.unknownElement', array('param' => $n->tagName)));
      }
   }
 
   //
   // Element parsing
   //
   function parseIdentifier($element, $publication) {
      $deployment = $this->getDeployment();
      $submission = $deployment->getSubmission();
 
      $advice = $element->getAttribute('advice');
      switch ($element->getAttribute('type')) {
         case 'internal':
            // "update" advice not supported yet.
            assert(!$advice || $advice == 'ignore');
 
            if ($element->textContent == $submission->getData('currentPublicationId')) {
               $submission->setData('currentPublicationId', $publication->getId());
            }
 
            break;
         case 'public':
            if ($advice == 'update') {
               $publication->setData('pub-id::publisher-id', $element->textContent);
            }
            break;
         default:
            if ($advice == 'update') {
               $pubIdPlugins = PluginRegistry::loadCategory('pubIds', true, $deployment->getContext()->getId());
               $publication->setData('pub-id::'.$element->getAttribute('type'), $element->textContent);
            }
      }
   }
 
   function parseAuthors($node, $publication) {
      for ($n = $node->firstChild; $n !== null; $n=$n->nextSibling) {
         if (is_a($n, 'DOMElement')) {
            assert($n->tagName == 'author');
            $this->parseAuthor($n, $publication);
         }
      }
   }
 
   function parseAuthor($n, $publication) {
      $filterDao = DAORegistry::getDAO('FilterDAO'); 
      $importFilters = $filterDao->getObjectsByGroup('native-xml=>author');
      assert(count($importFilters)==1); // Assert only a single unserialization filter
      $importFilter = array_shift($importFilters);
      $importFilter->setDeployment($this->getDeployment());
      $authorDoc = new DOMDocument();
      $authorDoc->appendChild($authorDoc->importNode($n, true));
      return $importFilter->execute($authorDoc);
   }
 
   function parseCitations($n, $publication) {
      $publicationId = $publication->getId();
      $citationsString = $n->textContent;
      $citationDao = DAORegistry::getDAO('CitationDAO'); 
      $citationDao->importCitations($publicationId, $citationsString);
   }
 
   //
   // Helper functions
   //
   function _getLocalizedPublicationFields() {
      return array(
         'title',
         'prefix',
         'subtitle',
         'abstract',
         'coverage',
         'type',
         'source',
         'rights',
         'copyrightHolder',
      );
   }
 
   function _getControlledVocabulariesMappings() {
      return array(
         'keywords' => array('SubmissionKeywordDAO', 'insertKeywords'),
         'agencies' => array('SubmissionAgencyDAO', 'insertAgencies'),
         'disciplines' => array('SubmissionDisciplineDAO', 'insertDisciplines'),
         'subjects' => array('SubmissionSubjectDAO', 'insertSubjects'),
      );
   }
 
   function getRepresentationExportFilterGroupName() {
      assert(false); // Subclasses must override
   }
 
   function getImportFilter($elementName) {
      assert(false); // Subclasses should override
   }
}