controllers/wizard/fileUpload/FileUploadWizardHandler.inc.php

<?php
// Import the base handler.
import('classes.file.FileManagementHandler');

// Import JSON class for use with all AJAX requests.
import('lib.pkp.classes.core.JSONMessage');

// The percentage of characters that the name of a file
// has to share with an existing file for it to be
// considered as a revision of that file.
define('SUBMISSION_MIN_SIMILARITY_OF_REVISION', 70);

class FileUploadWizardHandler extends FileManagementHandler {
   var $_fileStage;

   var $_uploaderRoles;

   var $_revisionOnly;

   var $_reviewRound;

   var $_revisedFileId;

   var $_assocType;

   var $_assocId;


   function FileUploadWizardHandler() {
      parent::Handler();
      $this->addRoleAssignment(
         array(ROLE_ID_PRESS_MANAGER, ROLE_ID_SERIES_EDITOR, ROLE_ID_AUTHOR, ROLE_ID_REVIEWER, ROLE_ID_PRESS_ASSISTANT),
         array(
            'startWizard', 'displayFileUploadForm',
            'uploadFile', 'confirmRevision',
            'editMetadata', 'saveMetadata',
            'finishFileSubmission'
         )
      );
   }


   //
   // Implement template methods from PKPHandler
   //
   function initialize(&$request, $args) {
      parent::initialize($request, $args);
      // Configure the wizard with the authorized monograph and file stage.
      // Validated in authorize.
      $this->_fileStage = (int)$request->getUserVar('fileStage');

      // Set the uploader roles (if given).
      $uploaderRoles = $request->getUserVar('uploaderRoles');
      if (!is_null($uploaderRoles)) {
         $this->_uploaderRoles = array();
         $uploaderRoles = explode('-', $uploaderRoles);
         foreach($uploaderRoles as $uploaderRole) {
            if (!is_numeric($uploaderRole)) fatalError('Invalid uploader role!');
            $this->_uploaderRoles[] = (int)$uploaderRole;
         }
      }

      // Do we allow revisions only?
      $this->_revisionOnly = (boolean)$request->getUserVar('revisionOnly');
      $reviewRound =& $this->getReviewRound();
      $this->_assocType = $request->getUserVar('assocType') ? (int)$request->getUserVar('assocType') : null;
      $this->_assocId = $request->getUserVar('assocId') ? (int)$request->getUserVar('assocId') : null;

      // The revised file will be non-null if we revise a single existing file.
      if ($this->getRevisionOnly() && $request->getUserVar('revisedFileId')) {
         // Validated in authorize.
         $this->_revisedFileId = (int)$request->getUserVar('revisedFileId');
      }

      // Load translations.
      AppLocale::requireComponents(
         LOCALE_COMPONENT_OMP_SUBMISSION,
         LOCALE_COMPONENT_PKP_SUBMISSION,
         LOCALE_COMPONENT_PKP_COMMON,
         LOCALE_COMPONENT_APPLICATION_COMMON
      );
   }

   function authorize($request, $args, $roleAssignments) {
      // This is validated in parent's authorization policy.
      $stageId = (int)$request->getUserVar('stageId');

      // Authorize review round id when this handler is used in review stages.
      if ($stageId == WORKFLOW_STAGE_ID_INTERNAL_REVIEW || $stageId == WORKFLOW_STAGE_ID_EXTERNAL_REVIEW) {
         import('classes.security.authorization.internal.ReviewRoundRequiredPolicy');
         $this->addPolicy(new ReviewRoundRequiredPolicy($request, $args));
      }

      // We validate file stage outside a policy because
      // we don't need to validate in another places.
      $fileStage = $request->getUserVar('fileStage');
      if ($fileStage) {
         $submissionFileDao =& DAORegistry::getDAO('SubmissionFileDAO');
         $fileStages = $submissionFileDao->getAllFileStages();
         if (!in_array($fileStage, $fileStages)) {
            return false;
         }
      }

      // Validate file ids. We have two cases where we might have a file id.
      // CASE 1: user is uploading a revision to a file, the revised file id
      // will need validation.
      $revisedFileId = (int)$request->getUserVar('revisedFileId');
      // CASE 2: user already have uploaded a file (and it's editing the metadata),
      // we will need to validate the uploaded file id.
      $fileId = (int)$request->getUserVar('fileId');
      // Get the right one to validate.
      $fileIdToValidate = null;
      if ($revisedFileId && !$fileId) {
         $fileIdToValidate = $revisedFileId;
      } else if ($fileId && !$revisedFileId) {
         $fileIdToValidate = $fileId;
      } else if ($revisedFileId && $fileId) {
         // Those two cases will not happen at the same time.
         return false;
      }
      if ($fileIdToValidate) {
         import('classes.security.authorization.OmpMonographFileAccessPolicy');
         $this->addPolicy(new OmpMonographFileAccessPolicy($request, $args, $roleAssignments, MONOGRAPH_FILE_ACCESS_READ, $fileIdToValidate));
      }

      return parent::authorize($request, $args, $roleAssignments);
   }


   //
   // Getters and Setters
   //
   function getFileStage() {
      return $this->_fileStage;
   }

   function getUploaderRoles() {
      return $this->_uploaderRoles;
   }

   function getRevisionOnly() {
      return $this->_revisionOnly;
   }

   function &getReviewRound() {
      return $this->getAuthorizedContextObject(ASSOC_TYPE_REVIEW_ROUND);
   }

   function getRevisedFileId() {
      return $this->_revisedFileId;
   }

   function getAssocType() {
      return $this->_assocType;
   }

   function getAssocId() {
      return $this->_assocId;
   }

   //
   // Public handler methods
   //
   function startWizard($args, &$request) {
      $templateMgr =& TemplateManager::getManager();

      // Assign the monograph.
      $monograph =& $this->getMonograph();
      $templateMgr->assign('monographId', $monograph->getId());

      // Assign the workflow stage.
      $templateMgr->assign('stageId', $this->getStageId());

      // Assign the roles allowed to upload in the given context.
      $templateMgr->assign('uploaderRoles', implode('-', $this->getUploaderRoles()));

      // Assign the file stage.
      $templateMgr->assign('fileStage', $this->getFileStage());

      // Preserve the isReviewer flag
      $templateMgr->assign('isReviewer', $request->getUserVar('isReviewer'));

      // Configure the "revision only" feature.
      $templateMgr->assign('revisionOnly', $this->getRevisionOnly());
      $reviewRound =& $this->getReviewRound();
      if (is_a($reviewRound, 'ReviewRound')) {
         $templateMgr->assign('reviewRoundId', $reviewRound->getId());
      }
      $templateMgr->assign('revisedFileId', $this->getRevisedFileId());
      $templateMgr->assign('assocType', $this->getAssocType());
      $templateMgr->assign('assocId', $this->getAssocId());

      // Render the file upload wizard.
      return $templateMgr->fetchJson('controllers/wizard/fileUpload/fileUploadWizard.tpl');
   }

   function displayFileUploadForm($args, &$request) {
      // Instantiate, configure and initialize the form.
      import('controllers.wizard.fileUpload.form.SubmissionFilesUploadForm');
      $monograph =& $this->getMonograph();
      $fileForm = new SubmissionFilesUploadForm(
         $request, $monograph->getId(), $this->getStageId(), $this->getUploaderRoles(), $this->getFileStage(),
         $this->getRevisionOnly(), $this->getReviewRound(), $this->getRevisedFileId(),
         $this->getAssocType(), $this->getAssocId()
      );
      $fileForm->initData($args, $request);

      // Render the form.
      $json = new JSONMessage(true, $fileForm->fetch($request));
      return $json->getString();
   }

   function uploadFile($args, &$request, $fileModifyCallback = null) {
      // Instantiate the file upload form.
      $monograph =& $this->getMonograph();
      import('controllers.wizard.fileUpload.form.SubmissionFilesUploadForm');
      $uploadForm = new SubmissionFilesUploadForm(
         $request, $monograph->getId(), $this->getStageId(), null, $this->getFileStage(),
         $this->getRevisionOnly(), $this->getReviewRound(), null, $this->getAssocType(), $this->getAssocId()
      );
      $uploadForm->readInputData();

      // Validate the form and upload the file.
      if ($uploadForm->validate($request)) {
         if (is_a($uploadedFile =& $uploadForm->execute($request), 'MonographFile')) { /* @var $uploadedFile MonographFile */
            // Retrieve file info to be used in a JSON response.
            $uploadedFileInfo = $this->_getUploadedFileInfo($uploadedFile);
            $reviewRound =& $this->getReviewRound();

            // If no revised file id was given then try out whether
            // the user maybe accidentally didn't identify this file as a revision.
            if (!$uploadForm->getRevisedFileId()) {
               $revisedFileId = $this->_checkForRevision($uploadedFile, $uploadForm->getMonographFiles());
               if ($revisedFileId) {
                  // Instantiate the revision confirmation form.
                  import('controllers.wizard.fileUpload.form.SubmissionFilesUploadConfirmationForm');
                  $confirmationForm = new SubmissionFilesUploadConfirmationForm($request, $monograph->getId(), $this->getStageId(), $this->getFileStage(), $reviewRound, $revisedFileId, $this->getAssocType(), $this->getAssocId(), $uploadedFile);
                  $confirmationForm->initData($args, $request);

                  // Render the revision confirmation form.
                  $json = new JSONMessage(true, $confirmationForm->fetch($request), '0', $uploadedFileInfo);
                  return $json->getString();
               }
            }

            // Remove pending revisions task notification, if any.
            if ($uploadedFile->getFileStage() == MONOGRAPH_FILE_REVIEW_REVISION) {
               $stageId = $this->getAuthorizedContextObject(ASSOC_TYPE_WORKFLOW_STAGE);
               $notificationMgr = new NotificationManager(); /* @var $notificationMgr NotificationManager */
               $user =& $request->getUser();
               $notificationMgr->deletePendingRevisionsNotification($request, $monograph, $stageId, $user->getId());
               $notificationMgr->insertAllRevisionsInNotification($request, $reviewRound);
            }

            // Advance to the next step (i.e. meta-data editing).
            $json = new JSONMessage(true, '', '0', $uploadedFileInfo);
         } else {
            $json = new JSONMessage(false, __('common.uploadFailed'));
         }
      } else {
         $json = new JSONMessage(false, array_pop($uploadForm->getErrorsArray()));
      }
      return $json->getString();
   }

   function confirmRevision($args, &$request) {
      // Instantiate the revision confirmation form.
      $monograph =& $this->getMonograph();
      import('controllers.wizard.fileUpload.form.SubmissionFilesUploadConfirmationForm');
      // FIXME?: need assocType and assocId? Not sure if they would be used, so not adding now.
      $reviewRound =& $this->getReviewRound();
      $confirmationForm = new SubmissionFilesUploadConfirmationForm(
         $request, $monograph->getId(), $this->getStageId(), $this->getFileStage(), $reviewRound
      );
      $confirmationForm->readInputData();

      // Validate the form and revise the file.
      if ($confirmationForm->validate($request)) {
         if (is_a($uploadedFile =& $confirmationForm->execute($request), 'MonographFile')) {
            // Go to the meta-data editing step.
            $json = new JSONMessage(true, '', '0', $this->_getUploadedFileInfo($uploadedFile));
         } else {
            $json = new JSONMessage(false, __('common.uploadFailed'));
         }
      } else {
         $json = new JSONMessage(false, array_pop($confirmationForm->getErrorsArray()));
      }
      return $json->getString();
   }

   function editMetadata($args, &$request) {
      $metadataForm =& $this->_getMetadataForm($request);
      $metadataForm->initData($args, $request);
      $json = new JSONMessage(true, $metadataForm->fetch($request));
      return $json->getString();
   }

   function saveMetadata($args, &$request) {
      $metadataForm =& $this->_getMetadataForm($request);
      $metadataForm->readInputData();
      if ($metadataForm->validate()) {
         $metadataForm->execute($args, $request);
         $submissionFile =& $metadataForm->getSubmissionFile();
         return DAO::getDataChangedEvent();
      } else {
         $json = new JSONMessage(false, $metadataForm->fetch($request));
      }
      return $json->getString();
   }

   function finishFileSubmission($args, &$request) {
      $monograph =& $this->getMonograph();

      // Validation not req'd -- just generating a JSON update message.
      $fileId = (int)$request->getUserVar('fileId');

      $templateMgr =& TemplateManager::getManager();
      $templateMgr->assign('monographId', $monograph->getId());
      $templateMgr->assign('fileId', $fileId);

      return $templateMgr->fetchJson('controllers/wizard/fileUpload/form/fileSubmissionComplete.tpl');
   }


   //
   // Private helper methods
   //
   function &_getMetadataForm(&$request) {
      // Retrieve the authorized monograph.
      $monograph =& $this->getMonograph();

      // Retrieve the monograph file.
      $submissionFile =& $this->getAuthorizedContextObject(ASSOC_TYPE_MONOGRAPH_FILE);

      // Import the meta-data form based on the file implementation.
      if (is_a($submissionFile, 'ArtworkFile')) {
         import('controllers.wizard.fileUpload.form.SubmissionFilesArtworkMetadataForm');
         $metadataForm = new SubmissionFilesArtworkMetadataForm($submissionFile, $this->getStageId(), $this->getReviewRound());
      } else {
         import('controllers.wizard.fileUpload.form.SubmissionFilesMetadataForm');
         $metadataForm = new SubmissionFilesMetadataForm($submissionFile, $this->getStageId(), $this->getReviewRound());
      }

      return $metadataForm;
   }

   function &_checkForRevision(&$uploadedFile, &$monographFiles) {
      // Get the file name.
      $uploadedFileName = $uploadedFile->getOriginalFileName();

      // Start with the minimal required similarity.
      $minPercentage = SUBMISSION_MIN_SIMILARITY_OF_REVISION;

      // Find out whether one of the files belonging to the current
      // file stage matches the given file name.
      $possibleRevisedFileId = null;
      $matchedPercentage = 0;
      foreach ($monographFiles as $monographFile) { /* @var $monographFile MonographFile */
         // Do not consider the uploaded file itself.
         if ($uploadedFile->getFileId() == $monographFile->getFileId()) continue;

         // Do not consider files from different publication formats.
         if (($uploadedFile->getAssocType() == ASSOC_TYPE_PUBLICATION_FORMAT &&
            $monographFile->getAssocType() == ASSOC_TYPE_PUBLICATION_FORMAT) &&
            $uploadedFile->getAssocId() != $monographFile->getAssocId()) continue;

         // Test whether the current monograph file is similar
         // to the uploaded file. (Transliterate to ASCII -- the
         // similar_text function can't handle UTF-8.)

         import('lib.pkp.classes.core.Transcoder');
         $transcoder = new Transcoder('UTF-8', 'ASCII', true);

         similar_text(
            $a = $transcoder->trans($uploadedFileName),
            $b = $transcoder->trans($monographFile->getOriginalFileName()),
            $matchedPercentage
         );
         if($matchedPercentage > $minPercentage && !$this->_onlyNumbersDiffer($a, $b)) {
            // We found a file that might be a possible revision.
            $possibleRevisedFileId = $monographFile->getFileId();

            // Reset the min percentage to this comparison's precentage
            // so that only better matches will be considered from now on.
            $minPercentage = $matchedPercentage;
         }
      }

      // Return the id of the file that we found similar.
      return $possibleRevisedFileId;
   }

   function _onlyNumbersDiffer($a, $b) {
      if ($a == $b) return false;

      $pattern = '/([^0-9]*)([0-9]*)([^0-9]*)/';
      $aMatchCount = preg_match_all($pattern, $a, $aMatches, PREG_SET_ORDER);
      $bMatchCount = preg_match_all($pattern, $b, $bMatches, PREG_SET_ORDER);
      if ($aMatchCount != $bMatchCount || $aMatchCount == 0) return false;

      // Check each match. If the 1st and 3rd (text) parts all match
      // then only numbers differ in the two supplied strings.
      for ($i=0; $i<count($aMatches); $i++) {
         if ($aMatches[$i][1] != $bMatches[$i][1]) return false;
         if ($aMatches[$i][3] != $bMatches[$i][3]) return false;
      }

      // No counterexamples were found. Only numbers differ.
      return true;
   }

   function &_getUploadedFileInfo(&$uploadedFile) {
      $uploadedFileInfo = array(
         'uploadedFile' => array(
            'fileId' => $uploadedFile->getFileId(),
            'revision' => $uploadedFile->getRevision()
         )
      );
      return $uploadedFileInfo;
   }
}

?>