MarkupGatewayPlugin.inc.php

<?php
 
import('lib.pkp.classes.plugins.GatewayPlugin');
 
class MarkupGatewayPlugin extends GatewayPlugin {
   
   protected $_parentPluginName = null;
 
   protected $_user = null;
 
   protected $_plugin = null;
 
   protected $_xmlpsWrapper = null;
 
   protected $_fileId = null;
 
   protected $_stageId = null;
 
   protected $_jobId = null;
 
   function __construct($parentPluginName) {
      parent::__construct();
 
      $this->_parentPluginName = $parentPluginName;
      $this->_plugin = PluginRegistry::getPlugin('generic', $parentPluginName);
   }
   
   protected function _initXMLPSWrapper($request) {
      $this->import('classes.MarkupConversionHelper');
      $this->_xmlpsWrapper = MarkupConversionHelper::getOTSWrapperInstance(
         $this->_plugin,
         $request->getJournal(),
         $this->_user
      );
   }
   
   function getHideManagement() {
      return true;
   }
   
   function getName() {
      return 'MarkupGatewayPlugin';
   }
   
   function getDisplayName() {
      return __('plugins.generic.markup.displayName');
   }
 
   function getDescription() {
      return __('plugins.generic.markup.description');
   }
   
   function &getMarkupPlugin() {
      return $this->_plugin;
   }
   
   function getPluginPath() {
      $plugin =& $this->getMarkupPlugin();
      return $plugin->getPluginPath();
   }
   
   function getTemplatePath() {
      $plugin =& $this->getMarkupPlugin();
      return $plugin->getTemplatePath();
   }
   
   function getCssPath() {
      $plugin =& $this->getMarkupPlugin();
      return $plugin->getCssPath();
   }
   
   function getJsPath() {
      $plugin =& $this->getMarkupPlugin();
      return $plugin->getJsPath();
   }
   
   function getEnabled() {
      $plugin =& $this->getMarkupPlugin();
      return $plugin->getEnabled(); // Should always be true anyway if this is loaded
   }
   
   function getManagementVerbs() {
      return array();
   }
   
   function fetch($args, $request) {
      
      // Parse keys and values from arguments
      $keys = array();
      $values = array();
      foreach ($args as $index => $arg) {
         if ($arg == 'true') $arg = true;
         if ($arg == 'false') $arg = false;
 
         if ($index % 2 == 0) {
            $keys[] = $arg;
         } else {
            $values[] = $arg;
         }
      }
      $args = array_combine($keys, $values);
 
      // TODO validate that filestage and target arguments are available
 
      if (!$this->getEnabled()) {
         echo __('plugins.generic.markup.archive.enable');
         exit;
      }
 
      // Make sure we're within a Journal context
      $journal = $this->getRequest()->getJournal();
      if (!$journal) {
         echo __('plugins.generic.markup.archive.noJournal');
         exit;
      }
 
      // load submission
      $fileId = isset($args['fileId']) ? (int) $args['fileId'] : false;
      if (!$fileId) {
         echo __('plugins.generic.markup.archive.noArticleID');
         exit;
      }
 
      // load user 
      $userDao = DAORegistry::getDAO('UserDAO');
      $userId = isset($args['userId']) ? (int) $args['userId'] : false;
      if (!$userId) {
         fatalError(__('plugins.generic.markup.archive.noArticleID'));
         exit;
      }
 
      // access key
      $accessKey = isset($args['accessKey']) ? $args['accessKey'] : null;
      if (empty($accessKey)) {
         fatalError(__('plugins.generic.markup.archive.noAccessKey'));
         exit;
      }
 
      $submissionFileDao = DAORegistry::getDAO('SubmissionFileDAO');
      $submissionFile = $submissionFileDao->getLatestRevision($fileId);
      if (empty($submissionFile)) {
         echo __('plugins.generic.markup.archive.noArticle');
         exit;
      }
 
      $this->_fileId = $fileId;
      $this->_user = $userDao->getById($args['userId']);
      $this->_jobId = isset($args['jobId']) ? $args['jobId'] : '';
      $this->_stageId = isset($args['stageId']) ? (int) $args['stageId'] : false;
 
      // validate access key
      $this->_plugin->import('classes.MarkupConversionHelper');
      if (!$this->_user || !MarkupConversionHelper::validateAccessToken($this->_user, $accessKey)) {
         fatalError(__('plugins.generic.markup.archive.noAccessKey'));
         exit;
      }
 
      // initialize OTS wrapper
      $this->_initXMLPSWrapper($request);
 
      // initialize conversion helper object
      $this->_conversionHelper = new MarkupConversionHelper($this->_plugin, $this->_xmlpsWrapper, $this->_user);
 
      // process
      $stageId = (int)$args['stageId'];
      $target = strval($args['target']);
      $this->_process($submissionFile, $submissionFile->getFileStage(), $target);
   }
   
   function _process($submissionFile, $fileStage, $target) {
      $journal = $this->getRequest()->getJournal();
      $journalId = $journal->getId();
 
      $submissionDao = DAORegistry::getDAO('SubmissionDAO'); /* @var $submissionDao SubmissionDAO */
      $submission = $submissionDao->getById($submissionFile->getSubmissionId());
 
      $tmpZipFile = null;
 
      try {
         $jobId = $this->_conversionHelper->triggerConversion($journal, $submissionFile, $stage, $target, $this->_jobId);
         $tmpZipFile = $this->_conversionHelper->retrieveConversionJobArchive($submissionFile, $jobId);
         if (($tmpZipFile == false) || !file_exists($tmpZipFile)) {
            return;
         }
         
      }
      catch (Exception $e) {
         // @TODO log error
         error_log('EXCEPTION!!! ' . $e->getMessage());
         return;
      }
 
      // save archive as production ready file
      // @TODO @TBD
 
      // Extract archive
      $extractionPath = null;
      if (($extractionPath = $this->_conversionHelper->unzipArchive($tmpZipFile)) === false) {
         return;
      }
      // find current user's group
      $userGroupDao = DAORegistry::getDAO('UserGroupDAO');
      $userGroups = $userGroupDao->getByUserId($this->_user->getId(), $journal->getId());
      $userGroup = $userGroups->next();
 
      $fileName = "document" . '__' . date('Y-m-d_h:i:s');
      switch ($target) {
         case 'xml-conversion':
            $this->_conversionHelper->handleArchiveExtractionAfterXmlConversion(
               $extractionPath,
               $journal,
               $submission,
               $submissionFile, 
               $fileStage,
               $fileName
            );
            break;
 
         case 'galley-generate':
            $this->_conversionHelper->handleArchiveExtractionAfterGalleyGenerate(
               $extractionPath,
               $journal,
               $submission,
               $submissionFile,
               $fileName
            );
            break;
      }
 
      @unlink($tmpZipFile);
      @rmdir($extractionPath);
   }
 
}