classes/file/PaperFileManager.inc.php

Go to the documentation of this file.

<?php

//$Id$

import('file.FileManager');

/* File type suffixes */
define('PAPER_FILE_SUBMISSION',  'SM');
define('PAPER_FILE_REVIEW',      'RV');
define('PAPER_FILE_DIRECTOR',    'DR');
define('PAPER_FILE_LAYOUT',      'LE');
define('PAPER_FILE_PUBLIC',      'PB');
define('PAPER_FILE_SUPP',     'SP');
define('PAPER_FILE_NOTE',     'NT');

class PaperFileManager extends FileManager {

   var $filesDir;

   var $paperId;

   var $paper;

   function PaperFileManager($paperId) {
      $this->paperId = $paperId;
      $paperDao =& DAORegistry::getDAO('PaperDAO');
      $this->paper =& $paperDao->getPaper($paperId);
      $schedConfId = $this->paper->getSchedConfId();
      $schedConfDao =& DAORegistry::getDAO('SchedConfDAO');
      $schedConf =& $schedConfDao->getSchedConf($schedConfId);
      $this->filesDir = Config::getVar('files', 'files_dir') . '/conferences/' . $schedConf->getConferenceId() . '/schedConfs/' . $schedConfId .
      '/papers/' . $paperId . '/';
   }

   function uploadSubmissionFile($fileName, $fileId = null, $overwrite = false) {
      return $this->handleUpload($fileName, PAPER_FILE_SUBMISSION, $fileId, $overwrite);
   }

   function writeSubmissionFile($fileName, &$contents, $mimeType, $fileId = null, $overwrite = true) {
      return $this->handleWrite($fileName, $contents, $mimeType, PAPER_FILE_SUBMISSION, $fileId, $overwrite);
   }

   function copySubmissionFile($url, $mimeType, $fileId = null, $overwrite = true) {
      return $this->handleCopy($url, $mimeType, PAPER_FILE_SUBMISSION, $fileId, $overwrite);
   }

   function uploadReviewFile($fileName, $fileId = null) {
      return $this->handleUpload($fileName, PAPER_FILE_REVIEW, $fileId);
   }

   function uploadDirectorDecisionFile($fileName, $fileId = null) {
      return $this->handleUpload($fileName, PAPER_FILE_DIRECTOR, $fileId);
   }

   function uploadLayoutFile($fileName, $fileId = null, $overwrite = true) {
      return $this->handleUpload($fileName, PAPER_FILE_LAYOUT, $fileId, $overwrite);
   }  

   function uploadSuppFile($fileName, $fileId = null, $overwrite = true) {
      return $this->handleUpload($fileName, PAPER_FILE_SUPP, $fileId, $overwrite);
   }  

   function uploadPublicFile($fileName, $fileId = null, $overwrite = true) {
      return $this->handleUpload($fileName, PAPER_FILE_PUBLIC, $fileId, $overwrite);
   }  

   function uploadSubmissionNoteFile($fileName, $fileId = null, $overwrite = true) {
      return $this->handleUpload($fileName, PAPER_FILE_NOTE, $fileId, $overwrite);
   }

   function writePublicFile($fileName, &$contents, $mimeType, $fileId = null, $overwrite = true) {
      return $this->handleWrite($fileName, $contents, $mimeType, PAPER_FILE_PUBLIC, $fileId, $overwrite);
   }

   function copyPublicFile($url, $mimeType, $fileId = null, $overwrite = true) {
      return $this->handleCopy($url, $mimeType, PAPER_FILE_PUBLIC, $fileId, $overwrite);
   }

   function writeSuppFile($fileName, &$contents, $mimeType, $fileId = null, $overwrite = true) {
      return $this->handleWrite($fileName, $contents, $mimeType, PAPER_FILE_SUPP, $fileId, $overwrite);
   }

   function copySuppFile($url, $mimeType, $fileId = null, $overwrite = true) {
      return $this->handleCopy($url, $mimeType, PAPER_FILE_SUPP, $fileId, $overwrite);
   }

   function &getFile($fileId, $revision = null) {
      $paperFileDao =& DAORegistry::getDAO('PaperFileDAO');
      $paperFile =& $paperFileDao->getPaperFile($fileId, $revision, $this->paperId);
      return $paperFile;
   }

   function readFile($fileId, $revision = null, $output = false) {
      $paperFile =& $this->getFile($fileId, $revision);

      if (isset($paperFile)) {
         $fileType = $paperFile->getFileType();
         $filePath = $this->filesDir . $paperFile->getType() . '/' . $paperFile->getFileName();

         return parent::readFile($filePath, $output);

      } else {
         return false;
      }
   }

   function deleteFile($fileId, $revision = null) {
      $paperFileDao =& DAORegistry::getDAO('PaperFileDAO');

      $files = array();
      if (isset($revision)) {
         $file =& $paperFileDao->getPaperFile($fileId, $revision);
         if (isset($file)) {
            $files[] = $file;
         }

      } else {
         $files =  &$paperFileDao->getPaperFileRevisions($fileId);
      }

      foreach ($files as $f) {
         parent::deleteFile($this->filesDir . $f->getType() . '/' . $f->getFileName());
      }

      $paperFileDao->deletePaperFileById($fileId, $revision);

      return count($files);
   }

   function deletePaperTree() {
      parent::rmtree($this->filesDir);
   }

   function downloadFile($fileId, $revision = null, $inline = false) {
      $paperFile =& $this->getFile($fileId, $revision);
      if (isset($paperFile)) {
         $fileType = $paperFile->getFileType();
         $filePath = $this->filesDir . $paperFile->getType() . '/' . $paperFile->getFileName();

         return parent::downloadFile($filePath, $fileType, $inline);

      } else {
         return false;
      }
   }

   function viewFile($fileId, $revision = null) {
      $this->downloadFile($fileId, $revision, true);
   }

   function copyToReviewFile($fileId, $revision = null, $destFileId = null) {
      return $this->copyAndRenameFile($fileId, $revision, PAPER_FILE_REVIEW, $destFileId);
   }

   function copyToDirectorFile($fileId, $revision = null, $destFileId = null) {
      return $this->copyAndRenameFile($fileId, $revision, PAPER_FILE_DIRECTOR, $destFileId);
   }

   function copyToLayoutFile($fileId, $revision = null) {
      return $this->copyAndRenameFile($fileId, $revision, PAPER_FILE_LAYOUT);
   }

   function typeToPath($type) {
      switch ($type) {
         case PAPER_FILE_PUBLIC: return 'public';
         case PAPER_FILE_SUPP: return 'supp';
         case PAPER_FILE_NOTE: return 'note';
         case PAPER_FILE_REVIEW: return 'submission/review';
         case PAPER_FILE_DIRECTOR: return 'submission/director';
         case PAPER_FILE_LAYOUT: return 'submission/layout';
         case PAPER_FILE_SUBMISSION: default: return 'submission/original';
      }
   }

   function copyAndRenameFile($sourceFileId, $sourceRevision, $destType, $destFileId = null) {
      $paperFileDao =& DAORegistry::getDAO('PaperFileDAO');
      $paperFile = new PaperFile();

      $destTypePath = $this->typeToPath($destType);
      $destDir = $this->filesDir . $destTypePath . '/';

      if ($destFileId != null) {
         $currentRevision = $paperFileDao->getRevisionNumber($destFileId);
         $revision = $currentRevision + 1;
      } else {
         $revision = 1;
      }  

      $sourcePaperFile = $paperFileDao->getPaperFile($sourceFileId, $sourceRevision, $this->paperId);

      if (!isset($sourcePaperFile)) {
         return false;
      }

      $sourceDir = $this->filesDir . $sourcePaperFile->getType() . '/';

      if ($destFileId != null) {
         $paperFile->setFileId($destFileId);
      }
      $paperFile->setPaperId($this->paperId);
      $paperFile->setFileName($sourcePaperFile->getFileName());
      $paperFile->setFileType($sourcePaperFile->getFileType());
      $paperFile->setFileSize($sourcePaperFile->getFileSize());
      $paperFile->setOriginalFileName(PaperFileManager::truncateFileName($sourcePaperFile->getFileName(), 127));
      $paperFile->setType($destTypePath);
      $paperFile->setDateUploaded(Core::getCurrentDate());
      $paperFile->setDateModified(Core::getCurrentDate());
      $paperFile->setStage($this->paper->getCurrentStage());
      $paperFile->setRevision($revision);

      $fileId = $paperFileDao->insertPaperFile($paperFile);

      // Rename the file.
      $fileExtension = $this->parseFileExtension($sourcePaperFile->getFileName());
      $newFileName = $this->paperId.'-'.$fileId.'-'.$revision.'-'.$destType.'.'.$fileExtension;

      if (!$this->fileExists($destDir, 'dir')) {
         // Try to create destination directory
         $this->mkdirtree($destDir);
      }

      copy($sourceDir.$sourcePaperFile->getFileName(), $destDir.$newFileName);

      $paperFile->setFileName($newFileName);
      $paperFileDao->updatePaperFile($paperFile);

      return $fileId;
   }

   function &generateDummyFile(&$paper) {
      $paperFileDao =& DAORegistry::getDAO('PaperFileDAO');
      $paperFile = new PaperFile();
      $paperFile->setPaperId($paper->getId());
      $paperFile->setFileName('temp');
      $paperFile->setOriginalFileName('temp');
      $paperFile->setFileType('temp');
      $paperFile->setFileSize(0);
      $paperFile->setType('temp');
      $paperFile->setDateUploaded(Core::getCurrentDate());
      $paperFile->setDateModified(Core::getCurrentDate());
      $paperFile->setStage(0);
      $paperFile->setRevision(1);

      $paperFile->setFileId($paperFileDao->insertPaperFile($paperFile));

      return $paperFile;
   }

   function removePriorRevisions($fileId, $revision) {
      $paperFileDao =& DAORegistry::getDAO('PaperFileDAO');
      $revisions = $paperFileDao->getPaperFileRevisions($fileId);
      foreach ($revisions as $revisionFile) {
         if ($revisionFile->getRevision() != $revision) {
            $this->deleteFile($fileId, $revisionFile->getRevision());
         }
      }
   }

   function generateFilename(&$paperFile, $type, $originalName) {
      $extension = $this->parseFileExtension($originalName);         
      $newFileName = $paperFile->getPaperId().'-'.$paperFile->getFileId().'-'.$paperFile->getRevision().'-'.$type.'.'.$extension;
      $paperFile->setFileName($newFileName);
      return $newFileName;
   }

   function handleUpload($fileName, $type, $fileId = null, $overwrite = false) {
      if ($this->uploadError($fileName)) return false;

      $paperFileDao =& DAORegistry::getDAO('PaperFileDAO');

      $typePath = $this->typeToPath($type);
      $dir = $this->filesDir . $typePath . '/';

      if (!$fileId) {
         // Insert dummy file to generate file id FIXME?
         $dummyFile = true;
         $paperFile =& $this->generateDummyFile($this->paper);
      } else {
         $dummyFile = false;
         $paperFile = new PaperFile();
         $paperFile->setRevision($paperFileDao->getRevisionNumber($fileId)+1);
         $paperFile->setPaperId($this->paperId);
         $paperFile->setFileId($fileId);
         $paperFile->setDateUploaded(Core::getCurrentDate());
         $paperFile->setDateModified(Core::getCurrentDate());
      }

      $paperFile->setFileType($this->getUploadedFileType($fileName));
      $paperFile->setFileSize($_FILES[$fileName]['size']);
      $paperFile->setOriginalFileName(PaperFileManager::truncateFileName($_FILES[$fileName]['name'], 127));
      $paperFile->setType($typePath);
      $paperFile->setStage($this->paper->getCurrentStage());

      $newFileName = $this->generateFilename($paperFile, $type, $this->getUploadedFileName($fileName));

      if (!$this->uploadFile($fileName, $dir.$newFileName)) {
         // Delete the dummy file we inserted
         $paperFileDao->deletePaperFileById($paperFile->getFileId());

         return false;
      }

      if ($dummyFile) $paperFileDao->updatePaperFile($paperFile);
      else $paperFileDao->insertPaperFile($paperFile);

      if ($overwrite) $this->removePriorRevisions($paperFile->getFileId(), $paperFile->getRevision());

      return $paperFile->getFileId();
   }

   function handleWrite($fileName, &$contents, $mimeType, $type, $fileId = null, $overwrite = false) {
      $paperFileDao =& DAORegistry::getDAO('PaperFileDAO');

      $typePath = $this->typeToPath($type);
      $dir = $this->filesDir . $typePath . '/';

      if (!$fileId) {
         // Insert dummy file to generate file id FIXME?
         $dummyFile = true;
         $paperFile =& $this->generateDummyFile($this->paper);
      } else {
         $dummyFile = false;
         $paperFile = new PaperFile();
         $paperFile->setRevision($paperFileDao->getRevisionNumber($fileId)+1);
         $paperFile->setPaperId($this->paperId);
         $paperFile->setFileId($fileId);
         $paperFile->setDateUploaded(Core::getCurrentDate());
         $paperFile->setDateModified(Core::getCurrentDate());
      }

      $paperFile->setFileType($mimeType);
      $paperFile->setFileSize(strlen($contents));
      $paperFile->setOriginalFileName(PaperFileManager::truncateFileName($fileName, 127));
      $paperFile->setType($typePath);
      $paperFile->setStage($this->paper->getCurrentStage());

      $newFileName = $this->generateFilename($paperFile, $type, $fileName);

      if (!$this->writeFile($dir.$newFileName, $contents)) {
         // Delete the dummy file we inserted
         $paperFileDao->deletePaperFileById($paperFile->getFileId());

         return false;
      }

      if ($dummyFile) $paperFileDao->updatePaperFile($paperFile);
      else $paperFileDao->insertPaperFile($paperFile);

      if ($overwrite) $this->removePriorRevisions($paperFile->getFileId(), $paperFile->getRevision());

      return $paperFile->getFileId();
   }

   function handleCopy($url, $mimeType, $type, $fileId = null, $overwrite = false) {
      $paperFileDao =& DAORegistry::getDAO('PaperFileDAO');

      $typePath = $this->typeToPath($type);
      $dir = $this->filesDir . $typePath . '/';

      if (!$fileId) {
         // Insert dummy file to generate file id FIXME?
         $dummyFile = true;
         $paperFile =& $this->generateDummyFile($this->paper);
      } else {
         $dummyFile = false;
         $paperFile = new PaperFile();
         $paperFile->setRevision($paperFileDao->getRevisionNumber($fileId)+1);
         $paperFile->setPaperId($this->paperId);
         $paperFile->setFileId($fileId);
         $paperFile->setDateUploaded(Core::getCurrentDate());
         $paperFile->setDateModified(Core::getCurrentDate());
      }

      $paperFile->setFileType($mimeType);
      $paperFile->setOriginalFileName(PaperFileManager::truncateFileName(basename($url), 127));
      $paperFile->setType($typePath);
      $paperFile->setStage($this->paper->getCurrentStage());

      $newFileName = $this->generateFilename($paperFile, $type, $paperFile->getOriginalFileName());

      if (!$this->copyFile($url, $dir.$newFileName)) {
         // Delete the dummy file we inserted
         $paperFileDao->deletePaperFileById($paperFile->getFileId());

         return false;
      }

      $paperFile->setFileSize(filesize($dir.$newFileName));

      if ($dummyFile) $paperFileDao->updatePaperFile($paperFile);
      else $paperFileDao->insertPaperFile($paperFile);

      if ($overwrite) $this->removePriorRevisions($paperFile->getFileId(), $paperFile->getRevision());

      return $paperFile->getFileId();
   }
}

?>

---