PKPFileUploadWizardHandler.inc.php

<?php
 
// Import the base handler.
import('classes.handler.Handler');
 
// Import JSON class for use with all AJAX requests.
import('lib.pkp.classes.core.JSONMessage');
 
class PKPFileUploadWizardHandler extends Handler {
   var $_fileStage;
 
   var $_uploaderRoles;
 
   var $_revisionOnly;
 
   var $_reviewRound;
 
   var $_revisedFileId;
 
   var $_assocType;
 
   var $_assocId;
 
 
   function __construct() {
      parent::__construct();
      $this->addRoleAssignment(
         array(ROLE_ID_MANAGER, ROLE_ID_SUB_EDITOR, ROLE_ID_AUTHOR, ROLE_ID_REVIEWER, ROLE_ID_ASSISTANT),
         array(
            'startWizard', 'displayFileUploadForm',
            'uploadFile', 'confirmRevision',
            'editMetadata',
            'finishFileSubmission'
         )
      );
   }
 
 
   //
   // Implement template methods from PKPHandler
   //
   function initialize($request) {
      parent::initialize($request);
      // Configure the wizard with the authorized submission and file stage.
      // Validated in authorize.
      $this->_fileStage = (int)$request->getUserVar('fileStage');
 
      // Set the uploader roles (if given).
      $uploaderRoles = $request->getUserVar('uploaderRoles');
      if (!empty($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_APP_SUBMISSION,
         LOCALE_COMPONENT_PKP_SUBMISSION,
         LOCALE_COMPONENT_PKP_COMMON,
         LOCALE_COMPONENT_APP_COMMON
      );
   }
 
 
   //
   // Getters and Setters
   //
   function getSubmission() {
      return $this->getAuthorizedContextObject(ASSOC_TYPE_SUBMISSION);
   }
 
 
   function getStageId() {
      return $this->getAuthorizedContextObject(ASSOC_TYPE_WORKFLOW_STAGE);
   }
 
   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($request);
      $reviewRound = $this->getReviewRound();
      $templateMgr->assign(array(
         'submissionId' => $this->getSubmission()->getId(),
         'stageId' => $this->getStageId(),
         'uploaderRoles' => implode('-', (array) $this->getUploaderRoles()),
         'fileStage' => $this->getFileStage(),
         'isReviewer' => $request->getUserVar('isReviewer'),
         'revisionOnly' => $this->getRevisionOnly(),
         'reviewRoundId' => is_a($reviewRound, 'ReviewRound')?$reviewRound->getId():null,
         'revisedFileId' => $this->getRevisedFileId(),
         'assocType' => $this->getAssocType(),
         'assocId' => $this->getAssocId(),
         'dependentFilesOnly' => $request->getUserVar('dependentFilesOnly'),
      ));
      return $templateMgr->fetchJson('controllers/wizard/fileUpload/fileUploadWizard.tpl');
   }
 
   function displayFileUploadForm($args, $request) {
      // Instantiate, configure and initialize the form.
      import('lib.pkp.controllers.wizard.fileUpload.form.SubmissionFilesUploadForm');
      $submission = $this->getSubmission();
      $fileForm = new SubmissionFilesUploadForm(
         $request, $submission->getId(), $this->getStageId(), $this->getUploaderRoles(), $this->getFileStage(),
         $this->getRevisionOnly(), $this->getReviewRound(), $this->getRevisedFileId(),
         $this->getAssocType(), $this->getAssocId()
      );
      $fileForm->initData();
 
      // Render the form.
      return new JSONMessage(true, $fileForm->fetch($request));
   }
 
   function uploadFile($args, $request) {
      // Instantiate the file upload form.
      $submission = $this->getSubmission();
      import('lib.pkp.controllers.wizard.fileUpload.form.SubmissionFilesUploadForm');
      $uploadForm = new SubmissionFilesUploadForm(
         $request, $submission->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()) {
         return new JSONMessage(true, $uploadForm->fetch($request));
      }
 
      $uploadedFile = $uploadForm->execute(); /* @var $uploadedFile SubmissionFile */
      if (!is_a($uploadedFile, 'SubmissionFile')) {
         return new JSONMessage(false, __('common.uploadFailed'));
      }
 
      $this->_attachEntities($uploadedFile);
 
      // 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()) {
         $user = $request->getUser();
         $revisionSubmissionFilesSelection = $uploadForm->getRevisionSubmissionFilesSelection($user, $uploadedFile);
         $revisedFileId = $this->_checkForRevision($uploadedFile, $revisionSubmissionFilesSelection);
         if ($revisedFileId) {
            // Instantiate the revision confirmation form.
            import('lib.pkp.controllers.wizard.fileUpload.form.SubmissionFilesUploadConfirmationForm');
            $confirmationForm = new SubmissionFilesUploadConfirmationForm($request, $submission->getId(), $this->getStageId(), $this->getFileStage(), $reviewRound, $revisedFileId, $this->getAssocType(), $this->getAssocId(), $uploadedFile);
            $confirmationForm->initData();
 
            // Render the revision confirmation form.
            return new JSONMessage(true, $confirmationForm->fetch($request), '0', $uploadedFileInfo);
         }
      }
 
      // Advance to the next step (i.e. meta-data editing).
      return new JSONMessage(true, '', '0', $uploadedFileInfo);
   }
 
   protected function _attachEntities($submissionFile) {
      switch ($submissionFile->getFileStage()) {
         case SUBMISSION_FILE_ATTACHMENT:
            // If this attachment was created in the review stage, add it to
            // the review round.
            if ($reviewRound = $this->getReviewRound()) {
               $submissionFileDao = DAORegistry::getDAO('SubmissionFileDAO'); /* @var $submissionFileDao SubmissionFileDAO */
               $submissionFileDao->assignRevisionToReviewRound($submissionFile->getFileId(), $submissionFile->getRevision(), $reviewRound);
            }
            break;
         case SUBMISSION_FILE_REVIEW_FILE:
         case SUBMISSION_FILE_REVIEW_ATTACHMENT:
         case SUBMISSION_FILE_REVIEW_REVISION:
            // Add the uploaded review file to the review round.
            $reviewRound = $this->getReviewRound();
            $submissionFileDao = DAORegistry::getDAO('SubmissionFileDAO'); /* @var $submissionFileDao SubmissionFileDAO */
            $submissionFileDao->assignRevisionToReviewRound($submissionFile->getFileId(), $submissionFile->getRevision(), $reviewRound);
 
            if ($submissionFile->getFileStage() == SUBMISSION_FILE_REVIEW_REVISION) {
               // Get a list of author user IDs
               $authorUserIds = array();
               $stageAssignmentDao = DAORegistry::getDAO('StageAssignmentDAO'); /* @var $stageAssignmentDao StageAssignmentDAO */
               $submitterAssignments = $stageAssignmentDao->getBySubmissionAndRoleId($reviewRound->getSubmissionId(), ROLE_ID_AUTHOR);
               while ($assignment = $submitterAssignments->next()) {
                  $authorUserIds[] = $assignment->getUserId();
               }
 
               // Update the task notifications
               $notificationMgr = new NotificationManager();
               $notificationMgr->updateNotification(
                  Application::get()->getRequest(),
                  array(NOTIFICATION_TYPE_PENDING_INTERNAL_REVISIONS, NOTIFICATION_TYPE_PENDING_EXTERNAL_REVISIONS),
                  $authorUserIds,
                  ASSOC_TYPE_SUBMISSION,
                  $reviewRound->getSubmissionId()
               );
 
               // Update the ReviewRound status when revision is submitted
               import('lib.pkp.classes.submission.reviewRound.ReviewRoundDAO');
               $reviewRoundDao = DAORegistry::getDAO('ReviewRoundDAO'); /* @var $reviewRoundDao ReviewRoundDAO */
               $reviewRoundDao->updateStatus($reviewRound);
 
               // Notify editors about the revision upload
               $submission = $this->getSubmission();
               $request = Application::get()->getRequest();
               $router = $request->getRouter();
               $dispatcher = $router->getDispatcher();
               $context = $request->getContext();
               $uploader = $request->getUser();
               // If the file is uploaded by an author
               if (in_array($uploader->getId(), $authorUserIds)) {
 
                  // Fetch the latest notification email timestamp if any
                  import('lib.pkp.classes.log.SubmissionEmailLogEntry'); // Import email event constants
                  $submissionEmailLogDao = DAORegistry::getDAO('SubmissionEmailLogDAO'); /* @var $submissionEmailLogDao SubmissionEmailLogDAO */
                  $submissionEmails = $submissionEmailLogDao->getByEventType($submission->getId(), SUBMISSION_EMAIL_AUTHOR_NOTIFY_REVISED_VERSION);
                  $lastNotification = null;
                  $sentDates = array();
                  if ($submissionEmails){
                     while ($email = $submissionEmails->next()) {
                        if ($email->getDateSent()){
                           $sentDates[] = $email->getDateSent();
                        }
                     }
                     if (!empty($sentDates)){ 
                        $lastNotification = max(array_map('strtotime', $sentDates));
                     }
                  }
 
                  import('lib.pkp.classes.mail.SubmissionMailTemplate');
                  $mail = new SubmissionMailTemplate($submission, 'REVISED_VERSION_NOTIFY');
                  $mail->setEventType(SUBMISSION_EMAIL_AUTHOR_NOTIFY_REVISED_VERSION);
                  $mail->setReplyTo($context->getData('contactEmail'), $context->getData('contactName'));
                  // Get editors assigned to the submission, consider also the recommendOnly editors
                  $userDao = DAORegistry::getDAO('UserDAO'); /* @var $userDao UserDAO */
                  $editorsStageAssignments = $stageAssignmentDao->getEditorsAssignedToStage($submission->getId(), $this->getStageId());
                  foreach ($editorsStageAssignments as $editorsStageAssignment) {
                     $editor = $userDao->getById($editorsStageAssignment->getUserId());
                     // If no prior notification exists OR if editor has logged in after the last revision upload OR the last upload and notification was sent more than a day ago, send a new notification
                     if (is_null($lastNotification) || strtotime($editor->getDateLastLogin()) > $lastNotification || strtotime('-1 day') > $lastNotification){
                        $mail->addRecipient($editor->getEmail(), $editor->getFullName());
                     }
                  }
                  // Get uploader name
                  $submissionUrl = $dispatcher->url($request, ROUTE_PAGE, null, 'workflow', 'index', array($submission->getId(), $this->getStageId()));
                  $mail->assignParams(array(
                     'authorName' => $uploader->getFullName(),
                     'editorialContactSignature' => $context->getData('contactName'),
                     'submissionUrl' => $submissionUrl,
                  ));
 
                  if ($mail->getRecipients()){
                     if (!$mail->send($request)) {
                        import('classes.notification.NotificationManager');
                        $notificationMgr = new NotificationManager();
                        $notificationMgr->createTrivialNotification($request->getUser()->getId(), NOTIFICATION_TYPE_ERROR, array('contents' => __('email.compose.error')));
                     }
                  }
 
               }
            }
            break;
      }
   }
 
   function confirmRevision($args, $request) {
      // Instantiate the revision confirmation form.
      $submission = $this->getSubmission();
      import('lib.pkp.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, $submission->getId(), $this->getStageId(), $this->getFileStage(), $reviewRound
      );
      $confirmationForm->readInputData();
 
      // Validate the form and revise the file.
      if ($confirmationForm->validate()) {
         if (is_a($uploadedFile = $confirmationForm->execute(), 'SubmissionFile')) {
 
            $this->_attachEntities($uploadedFile);
 
            // Go to the meta-data editing step.
            return new JSONMessage(true, '', '0', $this->_getUploadedFileInfo($uploadedFile));
         } else {
 
            return new JSONMessage(false, __('common.uploadFailed'));
         }
      } else {
         return new JSONMessage(true, $confirmationForm->fetch($request));
      }
   }
 
   function editMetadata($args, $request) {
      $metadataForm = $this->_getMetadataForm($request);
      $metadataForm->initData();
      return new JSONMessage(true, $metadataForm->fetch($request));
   }
 
   function finishFileSubmission($args, $request) {
      $submission = $this->getSubmission();
 
      // Validation not req'd -- just generating a JSON update message.
      $fileId = (int)$request->getUserVar('fileId');
 
      $templateMgr = TemplateManager::getManager($request);
      $templateMgr->assign('submissionId', $submission->getId());
      $templateMgr->assign('fileId', $fileId);
      if (isset($args['fileStage'])) {
         $templateMgr->assign('fileStage', $args['fileStage']);
      }
 
      return $templateMgr->fetchJson('controllers/wizard/fileUpload/form/fileSubmissionComplete.tpl');
   }
 
 
   //
   // Private helper methods
   //
   function _getMetadataForm($request) {
      $submissionFile = $this->getAuthorizedContextObject(ASSOC_TYPE_SUBMISSION_FILE);
      return $submissionFile->getMetadataForm($this->getStageId(), $this->getReviewRound());
   }
 
   function &_checkForRevision(&$uploadedFile, &$submissionFiles) {
      // Get the file name.
      $uploadedFileName = $uploadedFile->getOriginalFileName();
 
      // Start with the minimal required similarity.
      $minPercentage = Config::getVar('files', 'filename_revision_match', 70);
 
      // Find out whether one of the files belonging to the current
      // file stage matches the given file name.
      $possibleRevisedFileId = null;
      $matchedPercentage = 0;
      foreach ((array) $submissionFiles as $submissionFile) { /* @var $submissionFile SubmissionFile */
         // Test whether the current submission file is similar
         // to the uploaded file. (Transliterate to ASCII -- the
         // similar_text function can't handle UTF-8.)
         similar_text(
            $a = Stringy\Stringy::create($uploadedFileName)->toAscii(),
            $b = Stringy\Stringy::create($submissionFile->getOriginalFileName())->toAscii(),
            $matchedPercentage
         );
         if($matchedPercentage > $minPercentage && !$this->_onlyNumbersDiffer($a, $b)) {
            // We found a file that might be a possible revision.
            $possibleRevisedFileId = $submissionFile->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) {
      return array(
         'uploadedFile' => array(
            'fileId' => $uploadedFile->getFileId(),
            'revision' => $uploadedFile->getRevision(),
            'name' => $uploadedFile->getLocalizedName(),
            'fileLabel' => $uploadedFile->getFileLabel(),
            'type' => $uploadedFile->getDocumentType(),
            'genreId' => $uploadedFile->getGenreId(),
         )
      );
   }
}