NativeXmlPublicationFilter.inc.php

<?php
 
import('lib.pkp.plugins.importexport.native.filter.NativeXmlPKPPublicationFilter');
 
class NativeXmlPublicationFilter extends NativeXmlPKPPublicationFilter {
   //
   // Implement template methods from PersistableFilter
   //
   function getClassName() {
      return 'plugins.importexport.native.filter.NativeXmlPublicationFilter';
   }
 
   function populateObject($publication, $node) {
      $deployment = $this->getDeployment();
      $context = $deployment->getContext();
 
      $seriesPath = $node->getAttribute('series');
      $seriesPosition = $node->getAttribute('series_position');
      if ($seriesPath !== '') {
         $seriesDao = DAORegistry::getDAO('SeriesDAO'); 
         $series = $seriesDao->getByPath($seriesPath, $context->getId());
         if (!$series) {
            $deployment->addError(ASSOC_TYPE_PUBLICATION, $publication->getId(), __('plugins.importexport.native.error.unknownSeries', array('param' => $seriesPath)));
         } else {
            $publication->setData('seriesId', $series->getId());
            $publication->setData('seriesPosition', $seriesPosition);
         }
      }
 
      return parent::populateObject($publication, $node);
   }
 
   function handleChildElement($n, $publication) {
      switch ($n->tagName) {
         case 'publication_format':
            $this->parsePublicationFormat($n, $publication);
            break;
         case 'chapters':
            $this->parseChapters($n, $publication);
            break;
         case 'covers':
            $this->parsePublicationCovers($this, $n, $publication);
            break;
         default:
            parent::handleChildElement($n, $publication);
      }
   }
 
   function getImportFilter($elementName) {
      $deployment = $this->getDeployment();
      $publication = $deployment->getPublication();
      $importClass = null; // Scrutinizer
      switch ($elementName) {
         case 'publication_format':
            $importClass='PublicationFormat';
            break;
         case 'chapter':
            $importClass='Chapter';
            break;
         default:
            $deployment->addError(ASSOC_TYPE_PUBLICATION, $publication->getId(), __('plugins.importexport.common.error.unknownElement', array('param' => $elementName)));
      }
      // Caps on class name for consistency with imports, whose filter
      // group names are generated implicitly.
      $filterDao = DAORegistry::getDAO('FilterDAO'); /* @var $filterDao FilterDAO */
      $importFilters = $filterDao->getObjectsByGroup('native-xml=>' . $importClass);
      $importFilter = array_shift($importFilters);
      return $importFilter;
   }
 
   function parsePublicationFormat($n, $publication) {
      $importFilter = $this->getImportFilter($n->tagName);
      assert($importFilter); // There should be a filter
 
      $existingDeployment = $this->getDeployment();
      $request = Application::get()->getRequest();
      
      $onixDeployment = new Onix30ExportDeployment($request->getContext(), $request->getUser());
      $onixDeployment->setPublication($existingDeployment->getPublication());
      $onixDeployment->setFileDBIds($existingDeployment->getFileDBIds());
      $onixDeployment->setAuthorDBIds($existingDeployment->getAuthorDBIds());
      $importFilter->setDeployment($existingDeployment);
      $formatDoc = new DOMDocument();
      $formatDoc->appendChild($formatDoc->importNode($n, true));
      return $importFilter->execute($formatDoc);
   }
 
   function parseChapters($node, $publication) {
      $deployment = $this->getDeployment();
 
      $chapters = array();
 
      for ($n = $node->firstChild; $n !== null; $n=$n->nextSibling) {
         if (is_a($n, 'DOMElement')) {
            switch ($n->tagName) {
               case 'chapter':
                  $chapter = $this->parseChapter($n, $publication);
                  $chapters[] = $chapter;
                  break;
               default:
                  $deployment->addWarning(ASSOC_TYPE_PUBLICATION, $publication->getId(), __('plugins.importexport.common.error.unknownElement', array('param' => $n->tagName)));
            }
         }
      }
 
      $publication->setData('chapters', $chapters);
   }
 
   function parseChapter($n, $publication) {
      $importFilter = $this->getImportFilter($n->tagName);
      assert($importFilter); // There should be a filter
 
      $existingDeployment = $this->getDeployment();
      $request = Application::get()->getRequest();
 
      $importFilter->setDeployment($existingDeployment);
      $chapterDoc = new DOMDocument();
      $chapterDoc->appendChild($chapterDoc->importNode($n, true));
      return $importFilter->execute($chapterDoc);
   }
 
   function parsePublicationCovers($filter, $node, $object) {
      $deployment = $filter->getDeployment();
 
      $coverImages = array();
 
      for ($n = $node->firstChild; $n !== null; $n=$n->nextSibling) {
         if (is_a($n, 'DOMElement')) {
            switch ($n->tagName) {
               case 'cover':
                  $coverImage = $this->parsePublicationCover($filter, $n, $object);
                  $coverImages[key($coverImage)] = reset($coverImage);
                  break;
               default:
                  $deployment->addWarning(ASSOC_TYPE_PUBLICATION, $object->getId(), __('plugins.importexport.common.error.unknownElement', array('param' => $n->tagName)));
            }
         }
      }
 
      $object->setData('coverImage', $coverImages);
   }
 
   function parsePublicationCover($filter, $node, $object) {
      $deployment = $filter->getDeployment();
 
      $context = $deployment->getContext();
 
      $locale = $node->getAttribute('locale');
      if (empty($locale)) $locale = $context->getPrimaryLocale();
 
      $coverImagelocale = array();
      $coverImage = array();
 
      for ($n = $node->firstChild; $n !== null; $n=$n->nextSibling) {
         if (is_a($n, 'DOMElement')) {
            switch ($n->tagName) {
               case 'cover_image': 
                  $coverImage['uploadName'] = $n->textContent; 
                  break;
               case 'cover_image_alt_text':
                  $coverImage['altText'] = $n->textContent; 
                  break;
               case 'embed':
                  import('classes.file.PublicFileManager');
                  $publicFileManager = new PublicFileManager();
                  $filePath = $publicFileManager->getContextFilesPath($context->getId()) . '/' . $coverImage['uploadName'];
                  file_put_contents($filePath, base64_decode($n->textContent));
                  break;
               default:
                  $deployment->addWarning(ASSOC_TYPE_PUBLICATION, $object->getId(), __('plugins.importexport.common.error.unknownElement', array('param' => $n->tagName)));
            }
         }
      }
 
      $coverImagelocale[$locale] = $coverImage;
 
      return $coverImagelocale;
   }
 
   function getRepresentationExportFilterGroupName() {
      return 'publication-format=>native-xml';
   }
}