classes/monograph/MonographFile.inc.php

<?php

import('lib.pkp.classes.submission.SubmissionFile');

// Define the file stage identifiers.
define('MONOGRAPH_FILE_PUBLIC', 1);
define('MONOGRAPH_FILE_SUBMISSION', 2);
define('MONOGRAPH_FILE_NOTE', 3);
define('MONOGRAPH_FILE_REVIEW_FILE', 4);
define('MONOGRAPH_FILE_REVIEW_ATTACHMENT', 5);
// MONOGRAPH_FILE_REVIEW_REVISION defined below (FIXME: re-order before release)
define('MONOGRAPH_FILE_FINAL', 6);
define('MONOGRAPH_FILE_FAIR_COPY', 7);
define('MONOGRAPH_FILE_EDITOR', 8);
define('MONOGRAPH_FILE_COPYEDIT', 9);
define('MONOGRAPH_FILE_PROOF', 10);
define('MONOGRAPH_FILE_PRODUCTION_READY', 11);
define('MONOGRAPH_FILE_LAYOUT', 12);
define('MONOGRAPH_FILE_ATTACHMENT', 13);
define('MONOGRAPH_FILE_SIGNOFF', 14);
define('MONOGRAPH_FILE_REVIEW_REVISION', 15);

class MonographFile extends SubmissionFile {

   function MonographFile() {
      parent::SubmissionFile();
   }


   //
   // Get/set methods
   //
   function setUploaderUserId($uploaderUserId) {
      $this->setData('uploaderUserId', $uploaderUserId);
   }

   function getUploaderUserId() {
      return $this->getData('uploaderUserId');
   }

   function setUserGroupId($userGroupId) {
      $this->setData('userGroupId', $userGroupId);
   }

   function getUserGroupId() {
      return $this->getData('userGroupId');
   }

   function getAssocType() {
      return $this->getData('assocType');
   }

   function setAssocType($assocType) {
      return $this->setData('assocType', $assocType);
   }

   function getAssocId() {
      return $this->getData('assocId');
   }

   function setAssocId($assocId) {
      return $this->setData('assocId', $assocId);
   }

   function getMonographId() {
      return $this->getSubmissionId();
   }

   function setMonographId($monographId) {
      return $this->setSubmissionId($monographId);
   }

   function getDirectSalesPrice() {
      return $this->getData('directSalesPrice');
   }

   function setDirectSalesPrice($directSalesPrice) {
      return $this->setData('directSalesPrice', $directSalesPrice);
   }

   function setName($name, $locale) {
      $this->setData('name', $name, $locale);
   }

   function getName($locale) {
      return $this->getData('name', $locale);
   }

   function getLocalizedName() {
      return $this->getLocalizedData('name');
   }

   function getExtension() {
      import('lib.pkp.classes.file.FileManager');
      $fileManager = new FileManager();
      return strtoupper($fileManager->parseFileExtension($this->getOriginalFileName()));
   }

   function getDocumentType() {
      import('lib.pkp.classes.file.FileManager');
      $fileManager = new FileManager();
      return $fileManager->getDocumentType($this->getFileType());
   }

   function setGenreId($genreId) {
      $this->setData('genreId', $genreId);
   }

   function getGenreId() {
      return $this->getData('genreId');
   }

   function getFileLabel($locale = null) {
      // Retrieve the localized file name as basis for the label.
      if ($locale) {
         $fileLabel = $this->getName($locale);
      } else {
         $fileLabel = $this->getLocalizedName();
      }

      // If we have no file name then use a default name.
      if (empty($fileLabel)) $fileLabel = $this->getOriginalFileName();

      // Add the revision number to the label if we have more than one revision.
      if ($this->getRevision() > 1) $fileLabel .= ' (' . $this->getRevision() . ')';

      return $fileLabel;
   }

   function copyEditableMetadataFrom($monographFile) {
      assert(is_a($monographFile, 'MonographFile'));
      $this->setName($monographFile->getName(null), null);
   }

   //
   // Overridden public methods from PKPFile
   //
   function getFileName() {
      // FIXME: Need to move this to PKPFile or remove PKPFile's getFileName()
      // implementation and place it into app-specific classes, see #6446.
      return $this->_generateFileName();
   }

   function setFileName($fileName) {
      // FIXME: Remove this setter from PKPFile, too? See #6446.
      assert(false);
   }


   //
   // Implementation of template methods from SubmissionFile
   //
   function getFilePath() {
      // Get the press ID
      $monographDao =& DAORegistry::getDAO('MonographDAO');
      $monograph =& $monographDao->getById($this->getMonographId());
      if (!$monograph) return null;
      $pressId = $monograph->getPressId();
      unset($monograph);

      // Construct the file path
      import('classes.file.MonographFileManager');
      $monographFileManager = new MonographFileManager($pressId, $this->getMonographId());
      return $monographFileManager->getBasePath() . $this->_fileStageToPath($this->getFileStage()) . '/' . $this->getFileName();
   }


   //
   // Private helper methods
   //
   function _fileStageToPath($fileStage) {
      static $fileStageToPath = array(
            MONOGRAPH_FILE_PUBLIC => 'public',
            MONOGRAPH_FILE_SUBMISSION => 'submission',
            MONOGRAPH_FILE_NOTE => 'note',
            MONOGRAPH_FILE_REVIEW_FILE => 'submission/review',
            MONOGRAPH_FILE_REVIEW_ATTACHMENT => 'submission/review/attachment',
            MONOGRAPH_FILE_REVIEW_REVISION => 'submission/review/revision',
            MONOGRAPH_FILE_FINAL => 'submission/final',
            MONOGRAPH_FILE_FAIR_COPY => 'submission/fairCopy',
            MONOGRAPH_FILE_EDITOR => 'submission/editor',
            MONOGRAPH_FILE_COPYEDIT => 'submission/copyedit',
            MONOGRAPH_FILE_PROOF => 'submission/proof',
            MONOGRAPH_FILE_PRODUCTION_READY => 'submission/productionReady',
            MONOGRAPH_FILE_LAYOUT => 'submission/layout',
            MONOGRAPH_FILE_ATTACHMENT => 'attachment',
            MONOGRAPH_FILE_SIGNOFF => 'submission/signoff',
      );

      assert(isset($fileStageToPath[$fileStage]));
      return $fileStageToPath[$fileStage];
   }

   function _generateFileName() {
      // Remember the ID information we generated the file name
      // on so that we only have to re-generate the name if the
      // relevant information changed.
      static $lastIds = array();
      static $fileName = null;

      // Retrieve the current id information.
      $currentIds = array(
         'genreId' => $this->getGenreId(),
         'dateUploaded' => $this->getDateUploaded(),
         'monographId' => $this->getMonographId(),
         'fileId' => $this->getFileId(),
         'revision' => $this->getRevision(),
         'fileStage' => $this->getFileStage(),
         'extension' => strtolower_codesafe($this->getExtension())
      );

      // Check whether we need a refresh.
      $refreshRequired = false;
      foreach($currentIds as $key => $currentId) {
         if (!isset($lastIds[$key]) || $lastIds[$key] !== $currentId) {
            $refreshRequired = true;
            $lastIds = $currentIds;
            break;
         }
      }

      // Refresh the file name if required.
      if ($refreshRequired) {
         // If the file has a file genre set then include
         // human readable genre information.
         $genreName = '';
         if ($currentIds['genreId']) {
            $primaryLocale = AppLocale::getPrimaryLocale();
            $genreDao =& DAORegistry::getDAO('GenreDAO'); /* @var $genreDao GenreDAO */
            $genre =& $genreDao->getById($currentIds['genreId']);
            assert(is_a($genre, 'Genre'));
            $genreName = $genre->getDesignation($primaryLocale).'_'.$genre->getName($primaryLocale).'-';
         }

         // Generate a human readable time stamp.
         $timestamp = date('Ymd', strtotime($currentIds['dateUploaded']));

         // Make the file name unique across all files and file revisions.
         // Also make sure that files can be ordered sensibly by file name.
         $fileName = $currentIds['monographId'].'-'.$genreName.$currentIds['fileId'].'-'.$currentIds['revision'].'-'.$currentIds['fileStage'].'-'.$timestamp.'.'.$currentIds['extension'];
      }

      return $fileName;
   }
}

?>