SubmissionFileDAO.inc.php

<?php
 
import('lib.pkp.classes.db.DAO');
import('lib.pkp.classes.submission.Genre'); // GENRE_CATEGORY_... constants
import('lib.pkp.classes.plugins.PKPPubIdPluginDAO');
import('lib.pkp.classes.submission.SubmissionFile');
 
class SubmissionFileDAO extends DAO implements PKPPubIdPluginDAO {
   var $_delegates = array();
 
 
   //
   // Public methods
   //
   function getRevision($fileId, $revision, $fileStage = null, $submissionId = null) {
      if (!($fileId && $revision)) return null;
      $revisions = $this->_getInternally($submissionId, $fileStage, $fileId, $revision, null, null, null, null, null, false, null);
      return $this->_checkAndReturnRevision($revisions);
   }
 
   function getFileIdsBySetting($settingName, $settingValue, $submissionId = null, $contextId = null) {
      $params = array($settingName);
 
      $sql = 'SELECT DISTINCT f.file_id
         FROM  submission_files f
            INNER JOIN submissions s ON s.submission_id = f.submission_id';
      if (is_null($settingValue)) {
         $sql .= ' LEFT JOIN submission_file_settings fs ON f.file_id = fs.file_id AND fs.setting_name = ?
            WHERE (fs.setting_value IS NULL OR fs.setting_value = \'\')';
      } else {
         $params[] = (string) $settingValue;
         $sql .= ' INNER JOIN submission_file_settings fs ON f.file_id = fs.file_id
            WHERE fs.setting_name = ? AND fs.setting_value = ?';
      }
 
      if ($submissionId) {
         $params[] = (int) $submissionId;
         $sql .= ' AND f.submission_id = ?';
      }
 
      if ($contextId) {
         $params[] = (int) $contextId;
         $sql .= ' AND s.context_id = ?';
      }
 
      $sql .= ' ORDER BY f.file_id';
      $result = $this->retrieve($sql, $params);
 
      $fileIds = array();
      while (!$result->EOF) {
         $row = $result->getRowAssoc(false);
         $fileIds[] = $row['file_id'];
         $result->MoveNext();
      }
 
      $result->Close();
      return $fileIds;
   }
 
   function getByPubId($pubIdType, $pubId, $submissionId = null, $contextId = null) {
      $file = null;
      if (!empty($pubId)) {
         $fileIds = $this->getFileIdsBySetting('pub-id::'.$pubIdType, $pubId, $submissionId, $contextId);
         if (!empty($fileIds)) {
            assert(count($fileIds) == 1);
            $fileId = $fileIds[0];
            $file = $this->getLatestRevision($fileId, SUBMISSION_FILE_PROOF, $submissionId);
         }
      }
      return $file;
   }
 
   function getByBestId($fileId, $submissionId) {
      $file = null;
      if ($fileId != '') $file = $this->getByPubId('publisher-id', $fileId, $submissionId, null);
      if (!isset($file)) {
         list($fileId, $revision) = array_map(function($a) {
            return (int) $a;
         }, preg_split('/-/', $fileId));
         $file = $this->getRevision($fileId, $revision, null, $submissionId);
      }
      if ($file && $file->getFileStage() == SUBMISSION_FILE_PROOF) return $file;
      if ($file && $file->getFileStage() == SUBMISSION_FILE_DEPENDENT) return $file;
      return null;
   }
 
   function getLatestRevision($fileId, $fileStage = null, $submissionId = null) {
      if (!$fileId) return null;
 
      $revisions = $this->_getInternally($submissionId, $fileStage, $fileId, null, null, null, null, null, null, true, null, null);
      return $this->_checkAndReturnRevision($revisions);
   }
 
   function getLatestRevisions($submissionId, $fileStage = null, $rangeInfo = null) {
      if (!$submissionId) return null;
      return $this->_getInternally($submissionId, $fileStage, null, null, null, null, null, null, null, true, $rangeInfo);
   }
 
   function getAllRevisions($fileId, $fileStage = null, $submissionId = null, $rangeInfo = null) {
      if (!$fileId) return null;
      return $this->_getInternally($submissionId, $fileStage, $fileId, null, null, null, null, null, null, false, $rangeInfo);
   }
 
   function getBySubmissionId($submissionId, $rangeInfo = null) {
      if (!$submissionId) return null;
      return $this->_getInternally($submissionId, null, null, null, null, null, null, null, null, false, $rangeInfo);
   }
 
   function getLatestRevisionsByAssocId($assocType, $assocId, $submissionId = null, $fileStage = null, $rangeInfo = null) {
      if (!($assocType && $assocId)) return null;
      return $this->_getInternally($submissionId, $fileStage, null, null, $assocType, $assocId, null, null, null, true, $rangeInfo);
   }
 
   function getAllRevisionsByAssocId($assocType, $assocId, $fileStage = null, $rangeInfo = null) {
      if (!($assocType && $assocId)) return null;
      return $this->_getInternally(null, $fileStage, null, null, $assocType, $assocId, null, null, null, false, $rangeInfo);
   }
 
   function getRevisionsByReviewRound($reviewRound, $fileStage = null,
         $uploaderUserId = null) {
      if (!is_a($reviewRound, 'ReviewRound')) return null;
      return $this->_getInternally($reviewRound->getSubmissionId(),
         $fileStage, null, null, null, null, null,
         $uploaderUserId, $reviewRound->getId()
      );
   }
 
   function getLatestRevisionsByReviewRound($reviewRound, $fileStage = null) {
      if (!$reviewRound) return array();
      return $this->_getInternally($reviewRound->getSubmissionId(),
         $fileStage, null, null, null, null, $reviewRound->getStageId(),
         null, $reviewRound->getId(), true
      );
   }
 
   function getLatestRevisionNumber($fileId) {
      assert(!is_null($fileId));
 
      // Retrieve the latest revision from the database.
      $result = $this->retrieve(
         'SELECT MAX(revision) AS max_revision FROM submission_files WHERE file_id = ?',
         (int) $fileId
      );
      if($result->RecordCount() != 1) return null;
 
      $row = $result->FetchRow();
      $result->Close();
 
      $latestRevision = (int)$row['max_revision'];
      assert($latestRevision > 0);
      return $latestRevision;
   }
 
   function insertObject($submissionFile, $sourceFile, $isUpload = false) {
      // Make sure that the implementation of the updated file
      // is compatible with its genre (upcast but no downcast).
      $submissionFile = $this->_castToGenre($submissionFile);
 
      // Find the required target implementation and delegate.
      $targetImplementation = strtolower_codesafe(
         $this->_getFileImplementationForGenreId(
         $submissionFile->getGenreId())
      );
      $targetDaoDelegate = $this->_getDaoDelegate($targetImplementation);
      $insertedFile = $targetDaoDelegate->insertObject($submissionFile, $sourceFile, $isUpload);
 
      // If the updated file does not have the correct target type then we'll have
      // to retrieve it again from the database to cast it to the right type (downcast).
      if ($insertedFile && strtolower_codesafe(get_class($insertedFile)) != $targetImplementation) {
         $insertedFile = $this->_castToDatabase($insertedFile);
      }
      return $insertedFile;
   }
 
   function updateObject($updatedFile, $previousFileId = null, $previousRevision = null) {
      // Make sure that the implementation of the updated file
      // is compatible with its genre.
      $updatedFile = $this->_castToGenre($updatedFile);
 
      // Complete the identifying data of the previous file if not given.
      $previousFileId = (int)($previousFileId ? $previousFileId : $updatedFile->getFileId());
      $previousRevision = (int)($previousRevision ? $previousRevision : $updatedFile->getRevision());
 
      // Retrieve the previous file.
      $previousFile = $this->getRevision($previousFileId, $previousRevision);
      assert(is_a($previousFile, 'SubmissionFile'));
 
      // Canonicalized the implementation of the previous file.
      $previousImplementation = strtolower_codesafe(get_class($previousFile));
 
      // Find the required target implementation and delegate.
      $targetImplementation = strtolower_codesafe(
         $this->_getFileImplementationForGenreId(
         $updatedFile->getGenreId())
      );
      $targetDaoDelegate = $this->_getDaoDelegate($targetImplementation);
 
      // If the implementation in the database differs from the target
      // implementation then we'll have to delete + insert the object
      // to make sure that the database contains consistent data.
      if ($previousImplementation != $targetImplementation) {
         // We'll have to copy the previous file to its target
         // destination so that it is not lost when we delete the
         // previous file.
         // When the implementation (i.e. genre) changes then the
         // file locations will also change so we should not get
         // a file name clash.
         $previousFilePath = $previousFile->getFilePath();
         $targetFilePath = $updatedFile->getFilePath();
 
         assert($previousFilePath != $targetFilePath && !file_exists($targetFilePath));
         import('lib.pkp.classes.file.FileManager');
         $fileManager = new FileManager();
         $fileManager->copyFile($previousFilePath, $targetFilePath);
 
         // We use the delegates directly to make sure
         // that we address the right implementation in the database
         // on delete and insert.
         $sourceDaoDelegate = $this->_getDaoDelegate($previousImplementation);
         $sourceDaoDelegate->deleteObject($previousFile);
         $targetDaoDelegate->insertObject($updatedFile, $targetFilePath);
      } else {
         // If the implementation in the database does not change then we
         // can do an efficient update.
         if (!$targetDaoDelegate->updateObject($updatedFile, $previousFile)) {
            return null;
         }
      }
 
      // If the updated file does not have the correct target type then we'll have
      // to retrieve it again from the database to cast it to the right type.
      if (strtolower_codesafe(get_class($updatedFile)) != $targetImplementation) {
         $updatedFile = $this->_castToDatabase($updatedFile);
      }
 
      return $updatedFile;
   }
 
   function setAsLatestRevision($revisedFileId, $newFileId, $submissionId, $fileStage) {
      $revisedFileId = (int)$revisedFileId;
      $newFileId = (int)$newFileId;
      $submissionId = (int)$submissionId;
      $fileStage = (int)$fileStage;
 
      // Check whether the two files are already revisions of each other.
      if ($revisedFileId == $newFileId) return null;
 
      // Retrieve the latest revisions of the two submission files.
      $revisedFile = $this->getLatestRevision($revisedFileId, $fileStage, $submissionId);
      $newFile = $this->getLatestRevision($newFileId, $fileStage, $submissionId);
      if (!($revisedFile && $newFile)) return null;
 
      // Save identifying data of the changed file required for update.
      $previousFileId = $newFile->getFileId();
      $previousRevision = $newFile->getRevision();
 
      // Copy data over from the revised file to the new file.
      $newFile->setFileId($revisedFileId);
      $newFile->setRevision($revisedFile->getRevision()+1);
      $newFile->setGenreId($revisedFile->getGenreId());
      $newFile->setAssocType($revisedFile->getAssocType());
      $newFile->setAssocId($revisedFile->getAssocId());
 
      // Update the file in the database.
      return $this->updateObject($newFile, $previousFileId, $previousRevision);
   }
 
   function assignRevisionToReviewRound($fileId, $revision, $reviewRound) {
      if (!is_numeric($fileId) || !is_numeric($revision)) fatalError('Invalid file!');
 
      // Avoid duplication errors -- clear out any existing entries
      $this->deleteReviewRoundAssignment($reviewRound->getSubmissionId(), $reviewRound->getStageId(), $fileId, $revision);
 
      return $this->update(
         'INSERT INTO review_round_files
            (submission_id, review_round_id, stage_id, file_id, revision)
         VALUES (?, ?, ?, ?, ?)',
         array(
            (int)$reviewRound->getSubmissionId(),
            (int)$reviewRound->getId(),
            (int)$reviewRound->getStageId(),
            (int)$fileId,
            (int)$revision
         )
      );
   }
 
   function deleteRevision($submissionFile) {
      return $this->deleteRevisionById($submissionFile->getFileId(), $submissionFile->getRevision(), $submissionFile->getFileStage(), $submissionFile->getSubmissionId());
   }
 
   function deleteRevisionById($fileId, $revision, $fileStage = null, $submissionId = null) {
      return $this->_deleteInternally($submissionId, $fileStage, $fileId, $revision);
   }
 
   function deleteLatestRevisionById($fileId, $fileStage= null, $submissionId = null) {
      return $this->_deleteInternally($submissionId, $fileStage, $fileId, null, null, null, null, null, true);
   }
 
   function deleteAllRevisionsById($fileId, $fileStage = null, $submissionId = null) {
      return $this->_deleteInternally($submissionId, $fileStage, $fileId);
   }
 
   function deleteAllRevisionsBySubmissionId($submissionId, $fileStage = null) {
      return $this->_deleteInternally($submissionId, $fileStage);
   }
 
   function deleteAllRevisionsByAssocId($assocType, $assocId, $fileStage = null) {
      return $this->_deleteInternally(null, $fileStage, null, null, $assocType, $assocId);
   }
 
   function deleteAllRevisionsByReviewRound($reviewRoundId) {
      // Remove currently assigned review files.
      return $this->update('DELETE FROM review_round_files WHERE review_round_id = ?', (int)$reviewRoundId);
   }
 
   function deleteReviewRoundAssignment($submissionId, $stageId, $fileId, $revision) {
      // Remove currently assigned review files.
      $this->update(
         'DELETE FROM review_round_files
         WHERE submission_id = ? AND stage_id = ? AND file_id = ? AND revision = ?',
         array(
            (int) $submissionId,
            (int) $stageId,
            (int) $fileId,
            (int) $revision
         )
      );
   }
 
   function transferOwnership($oldUserId, $newUserId) {
      $submissionFiles = $this->_getInternally(null, null, null, null, null, null, null, $oldUserId);
      foreach ($submissionFiles as $file) {
         $daoDelegate = $this->_getDaoDelegateForObject($file);
         $file->setUploaderUserId($newUserId);
         $daoDelegate->updateObject($file, $file); // nothing else changes
      }
   }
 
   function newDataObjectByGenreId($genreId) {
      // Identify the delegate.
      $daoDelegate = $this->_getDaoDelegateForGenreId($genreId);
 
      // Instantiate and return the object.
      return $daoDelegate->newDataObject();
   }
 
 
   //
   // Abstract template methods to be implemented by subclasses.
   //
   function getDelegateClassNames() {
      return array(
         'submissionfile' => 'lib.pkp.classes.submission.SubmissionFileDAODelegate',
         'submissionartworkfile' => 'lib.pkp.classes.submission.SubmissionArtworkFileDAODelegate',
         'supplementaryfile' => 'lib.pkp.classes.submission.SupplementaryFileDAODelegate',
      );
   }
 
   function getGenreCategoryMapping() {
      return array(
         GENRE_CATEGORY_DOCUMENT => 'submissionfile',
         GENRE_CATEGORY_ARTWORK => 'submissionartworkfile',
         GENRE_CATEGORY_SUPPLEMENTARY => 'supplementaryfile',
      );
   }
 
   function baseQueryForFileSelection() {
      // Build the basic query that joins the class tables.
      // The DISTINCT is required to de-dupe the review_round_files join in
      // SubmissionFileDAO.
      return 'SELECT DISTINCT
            sf.file_id AS submission_file_id, sf.revision AS submission_revision,
            af.file_id AS artwork_file_id, af.revision AS artwork_revision,
            suf.file_id AS supplementary_file_id, suf.revision AS supplementary_revision,
            p.locale AS submission_locale,
            sf.*, af.*, suf.*
         FROM  submission_files sf
            LEFT JOIN submission_artwork_files af ON sf.file_id = af.file_id AND sf.revision = af.revision
            LEFT JOIN submission_supplementary_files suf ON sf.file_id = suf.file_id AND sf.revision = suf.revision
            LEFT JOIN submissions as s ON s.submission_id = sf.submission_id
            LEFT JOIN publications p ON s.current_publication_id = p.publication_id ';
   }
 
 
   //
   // Protected helper methods
   //
   function fromRow($row, $fileImplementation = null) {
      switch(true) {
         case isset($row['artwork_file_id']) && is_numeric($row['artwork_file_id']):
            $daoDelegate = $this->_getDaoDelegate('SubmissionArtworkFile');
            break;
         case isset($row['supplementary_file_id']) && is_numeric($row['supplementary_file_id']):
            $daoDelegate = $this->_getDaoDelegate('SupplementaryFile');
            break;
         default:
            $daoDelegate = $this->_getDaoDelegate('SubmissionFile');
      }
 
      // Let the DAO delegate instantiate the file implementation.
      return $daoDelegate->fromRow($row);
   }
 
 
   function getAllFileStages() {
      // Bring in the file stages definition.
      import('lib.pkp.classes.submission.SubmissionFile');
      return array(
         SUBMISSION_FILE_SUBMISSION,
         SUBMISSION_FILE_NOTE,
         SUBMISSION_FILE_REVIEW_FILE,
         SUBMISSION_FILE_REVIEW_ATTACHMENT,
         SUBMISSION_FILE_FINAL,
         SUBMISSION_FILE_FAIR_COPY,
         SUBMISSION_FILE_EDITOR,
         SUBMISSION_FILE_COPYEDIT,
         SUBMISSION_FILE_PROOF,
         SUBMISSION_FILE_PRODUCTION_READY,
         SUBMISSION_FILE_ATTACHMENT,
         SUBMISSION_FILE_REVIEW_REVISION,
         SUBMISSION_FILE_DEPENDENT,
         SUBMISSION_FILE_QUERY,
      );
   }
 
   function pubIdExists($pubIdType, $pubId, $excludePubObjectId, $contextId) {
      $submissionFileDAODelegate = $this->_getDaoDelegate('submissionfile');
      return $submissionFileDAODelegate->pubIdExists($pubIdType, $pubId, $excludePubObjectId, $contextId);
   }
 
   function changePubId($pubObjectId, $pubIdType, $pubId) {
      $submissionFileDAODelegate = $this->_getDaoDelegate('submissionfile');
      $submissionFileDAODelegate->changePubId($pubObjectId, $pubIdType, $pubId);
   }
 
   function deletePubId($pubObjectId, $pubIdType) {
      $submissionFileDAODelegate = $this->_getDaoDelegate('submissionfile');
      $submissionFileDAODelegate->deletePubId($pubObjectId, $pubIdType);
   }
 
   function deleteAllPubIds($contextId, $pubIdType) {
      $submissionFileDAODelegate = $this->_getDaoDelegate('submissionfile');
      $submissionFileDAODelegate->deleteAllPubIds($contextId, $pubIdType);
   }
 
   public function getWorkflowStageId($submissionFile) {
      switch ($submissionFile->getFileStage()) {
         case SUBMISSION_FILE_SUBMISSION:
            return WORKFLOW_STAGE_ID_SUBMISSION;
         case SUBMISSION_FILE_REVIEW_FILE:
         case SUBMISSION_FILE_REVIEW_ATTACHMENT:
         case SUBMISSION_FILE_REVIEW_REVISION:
            $reviewRoundDao = DAORegistry::getDAO('ReviewRoundDAO'); /* @var $reviewRoundDao ReviewRoundDAO */
            $reviewRound = $reviewRoundDao->getBySubmissionFileId($submissionFile->getFileId());
            return $reviewRound->getStageId();
         case SUBMISSION_FILE_FINAL:
         case SUBMISSION_FILE_COPYEDIT:
            return WORKFLOW_STAGE_ID_EDITING;
         case SUBMISSION_FILE_PROOF:
         case SUBMISSION_FILE_PRODUCTION_READY:
         case SUBMISSION_FILE_DEPENDENT:
            return WORKFLOW_STAGE_ID_PRODUCTION;
         case SUBMISSION_FILE_QUERY:
            $noteDao = DAORegistry::getDAO('NoteDAO'); /* @var $noteDao NoteDAO */
            $note = $noteDao->getById($submissionFile->getAssocId());
            $queryDao = DAORegistry::getDAO('QueryDAO'); /* @var $queryDao QueryDAO */
            $query = $queryDao->getById($note->getAssocId());
            return $query?$query->getStageId():null;
      }
   }
 
   //
   // Private helper methods
   //
   private function _getFileImplementationForGenreId($genreId) {
      static $genreCache = array();
 
      if (!isset($genreCache[$genreId])) {
         if (is_null($genreId)) {
            // If no genreId is given fall back to the document category
            $genreCategory = GENRE_CATEGORY_DOCUMENT;
 
         } else {
            // We have to instantiate the genre to find out about
            // its category.
            $genreDao = DAORegistry::getDAO('GenreDAO'); /* @var $genreDao GenreDAO */
            $genre = $genreDao->getById($genreId);
            $genreCategory = $genre->getCategory();
         }
 
         // Identify the file implementation.
         $genreMapping = $this->getGenreCategoryMapping();
         assert(isset($genreMapping[$genreCategory]));
         $genreCache[$genreId] = $genreMapping[$genreCategory];
      }
 
      return $genreCache[$genreId];
   }
 
   private function _getDaoDelegateForGenreId($genreId) {
      // Find the required file implementation.
      $fileImplementation = $this->_getFileImplementationForGenreId($genreId);
 
      // Return the DAO delegate.
      return $this->_getDaoDelegate($fileImplementation);
   }
 
   private function _getDaoDelegateForObject($object) {
      return $this->_getDaoDelegate(get_class($object));
   }
 
   private function _getDaoDelegate($fileImplementation) {
      // Normalize the file implementation name.
      $fileImplementation = strtolower_codesafe($fileImplementation);
 
      // Did we already instantiate the requested delegate?
      if (!isset($this->_delegates[$fileImplementation])) {
         // Instantiate the requested delegate.
         $delegateClasses = $this->getDelegateClassNames();
         assert(isset($delegateClasses[$fileImplementation]));
         $delegateClass = $delegateClasses[$fileImplementation];
         $this->_delegates[$fileImplementation] = instantiate($delegateClass, 'SubmissionFileDAODelegate');
      }
 
      // Return the delegate.
      return $this->_delegates[$fileImplementation];
   }
 
   private function _getInternally($submissionId = null, $fileStage = null, $fileId = null, $revision = null,
         $assocType = null, $assocId = null, $stageId = null, $uploaderUserId = null,
         $reviewRoundId = null, $latestOnly = false, $rangeInfo = null) {
      // Retrieve the base query.
      $sql = $this->baseQueryForFileSelection();
 
      // Add the revision round file join if a revision round
      // filter was requested.
      if ($reviewRoundId) {
         $sql .= 'INNER JOIN review_round_files rrf
               ON sf.submission_id = rrf.submission_id
               AND sf.file_id = rrf.file_id
               AND sf.revision '.($latestOnly ? '>=' : '=').' rrf.revision ';
      }
 
      // Filter the query.
      list($filterClause, $params) = $this->_buildFileSelectionFilter(
            $submissionId, $fileStage, $fileId, $revision,
            $assocType, $assocId, $stageId, $uploaderUserId, $reviewRoundId);
 
      // Did the user request all or only the latest revision?
      if ($latestOnly) {
         // Filter the latest revision of each file.
         // NB: We have to do this in the SQL for paging to work
         // correctly. We use a partial cartesian join here to
         // maintain MySQL 3.23 backwards compatibility. This
         // should be ok as we usually only have few revisions per
         // file.
         $sql .= 'LEFT JOIN submission_files sf2 ON sf.file_id = sf2.file_id AND sf.revision < sf2.revision
            WHERE sf2.revision IS NULL AND '.$filterClause;
      } else {
         $sql .= 'WHERE '.$filterClause;
      }
 
      // Order the query.
      $sql .= ' ORDER BY sf.submission_id ASC, sf.file_stage ASC, sf.file_id ASC, sf.revision DESC';
 
      // Execute the query.
      if ($rangeInfo) {
         $result = $this->retrieveRange($sql, $params, $rangeInfo);
      } else {
         $result = $this->retrieve($sql, $params);
      }
 
      // Build the result array.
      $submissionFiles = array();
      while (!$result->EOF) {
         // Retrieve the next result row.
         $row = $result->GetRowAssoc(false);
 
         // Construct a combined id from file id and revision
         // that uniquely identifies the file.
         $idAndRevision = $row['submission_file_id'].'-'.$row['submission_revision'];
 
         // Check for duplicates.
         assert(!isset($submissionFiles[$idAndRevision]));
 
         // Instantiate the file and add it to the
         // result array with a unique key.
         // N.B. The subclass implementation of fromRow receives just the $row
         // but calls SubmissionFileDAO::fromRow($row, $fileImplementation) as defined here.
         $submissionFiles[$idAndRevision] = $this->fromRow($row);
 
         // Move the query cursor to the next record.
         $result->MoveNext();
      }
      $result->Close();
 
      return $submissionFiles;
   }
 
   private function _deleteInternally($submissionId = null, $fileStage = null, $fileId = null, $revision = null,
         $assocType = null, $assocId = null, $stageId = null, $uploaderUserId = null,
         $latestOnly = false) {
 
      // Identify all matched files.
      $deletedFiles = $this->_getInternally($submissionId, $fileStage, $fileId, $revision,
            $assocType, $assocId, $stageId, $uploaderUserId, null, $latestOnly, null);
      if (empty($deletedFiles)) return 0;
 
      foreach($deletedFiles as $deletedFile) { /* @var $deletedFile SubmissionFile */
         // Delete file in the database.
         // NB: We cannot safely bulk-delete because MySQL 3.23
         // does not support multi-column IN-clauses. Same is true
         // for multi-table access or subselects in the DELETE
         // statement. And having a long (... AND ...) OR (...)
         // clause could hit length limitations.
         $daoDelegate = $this->_getDaoDelegateForObject($deletedFile);
         if (!$daoDelegate->deleteObject($deletedFile)) return false;
      }
 
      // Return the number of deleted files.
      return count($deletedFiles);
   }
 
   private function _buildFileSelectionFilter($submissionId, $fileStage,
         $fileId, $revision, $assocType, $assocId, $stageId, $uploaderUserId, $reviewRoundId) {
 
      // Make sure that at least one entity filter has been set.
      assert($submissionId>0 || (int)$uploaderUserId || (int)$fileId || (int)$assocId);
 
      // Both, assoc type and id, must be set (or unset) together.
      assert(((int)$assocType && (int)$assocId) || !((int)$assocType || (int)$assocId));
 
      // Collect the filtered columns and ids in
      // an array for consistent handling.
      $filters = array(
         'sf.submission_id' => $submissionId,
         'sf.file_stage' => $fileStage,
         'sf.file_id' => $fileId,
         'sf.revision' => $revision,
         'sf.assoc_type' => $assocType,
         'sf.assoc_id' => $assocId,
         'sf.uploader_user_id' => $uploaderUserId,
         'rrf.stage_id' => $stageId,
         'rrf.review_round_id' => $reviewRoundId,
      );
 
      // Build and return a SQL where clause and a parameter
      // array.
      $filterClause = '';
      $params = array();
      $conjunction = '';
      foreach($filters as $filteredColumn => $filteredId) {
         if ($filteredId) {
            $filterClause .= $conjunction.' '.$filteredColumn.' = ?';
            $conjunction = ' AND';
            $params[] = (int)$filteredId;
         }
      }
      return array($filterClause, $params);
   }
 
   private function _castToGenre($submissionFile) {
      // Find the required target implementation.
      $targetImplementation = strtolower_codesafe(
         $this->_getFileImplementationForGenreId(
         $submissionFile->getGenreId())
      );
 
      // If the current implementation of the updated object
      // is the same as the target implementation, skip cast.
      if (is_a($submissionFile, $targetImplementation)) return $submissionFile;
 
      // The updated file has to be upcast by manually
      // instantiating the target object and copying data
      // to the target.
      $targetDaoDelegate = $this->_getDaoDelegate($targetImplementation);
      $targetFile = $targetDaoDelegate->newDataObject();
      $targetFile = $submissionFile->upcastTo($targetFile);
      return $targetFile;
   }
 
   private function _castToDatabase($submissionFile) {
      return $this->getRevision(
         $submissionFile->getFileId(),
         $submissionFile->getRevision()
      );
   }
 
   private function _checkAndReturnRevision($revisions) {
      assert(count($revisions) <= 1);
      if (empty($revisions)) return null;
 
      $revision = array_pop($revisions);
      assert(is_a($revision, 'SubmissionFile'));
      return $revision;
   }
 
   function copyFile($context, $submissionFile, $fileStage){
      import('lib.pkp.classes.file.SubmissionFileManager');
      $submissionFileManager = new SubmissionFileManager($context->getId(), $submissionFile->getSubmissionId());
      $fileId = $submissionFile->getFileId();
      $revision = $submissionFile->getRevision();
      list($newFileId, $newRevision) = $submissionFileManager->copyFileToFileStage($fileId, $revision, $fileStage, null, $submissionFile->getViewable());
      return $newFileId;
   }
}