EditorDecisionHandler.inc.php

<?php
 
import('lib.pkp.classes.controllers.modals.editorDecision.PKPEditorDecisionHandler');
 
// Access decision actions constants.
import('classes.workflow.EditorDecisionActionsManager');
 
class EditorDecisionHandler extends PKPEditorDecisionHandler {
   function __construct() {
      parent::__construct();
 
      $this->addRoleAssignment(
         array(ROLE_ID_SUB_EDITOR, ROLE_ID_MANAGER),
         array_merge(array(
            'internalReview', 'saveInternalReview',
            'externalReview', 'saveExternalReview',
            'sendReviews', 'saveSendReviews',
            'promote', 'savePromote',
         ), $this->_getReviewRoundOps())
      );
   }
 
 
   //
   // Implement template methods from PKPHandler
   //
   function authorize($request, &$args, $roleAssignments) {
      $stageId = (int) $request->getUserVar('stageId');
      import('lib.pkp.classes.security.authorization.EditorDecisionAccessPolicy');
      $this->addPolicy(new EditorDecisionAccessPolicy($request, $args, $roleAssignments, 'submissionId', $stageId));
 
      return parent::authorize($request, $args, $roleAssignments);
   }
 
 
   //
   // Public handler actions
   //
   function saveNewReviewRound($args, $request) {
      // FIXME: this can probably all be managed somewhere.
      $stageId = $this->getAuthorizedContextObject(ASSOC_TYPE_WORKFLOW_STAGE);
      if ($stageId == WORKFLOW_STAGE_ID_INTERNAL_REVIEW) {
         $redirectOp = WORKFLOW_STAGE_PATH_INTERNAL_REVIEW;
      } elseif ($stageId == WORKFLOW_STAGE_ID_EXTERNAL_REVIEW) {
         $redirectOp = WORKFLOW_STAGE_PATH_EXTERNAL_REVIEW;
      } else {
         $redirectOp = null; // Suppress warn
         assert(false);
      }
 
      return $this->_saveEditorDecision($args, $request, 'NewReviewRoundForm', $redirectOp, SUBMISSION_EDITOR_DECISION_NEW_ROUND);
   }
 
   function internalReview($args, $request) {
      return $this->_initiateEditorDecision($args, $request, 'InitiateInternalReviewForm');
   }
 
   function saveInternalReview($args, $request) {
      assert($this->getAuthorizedContextObject(ASSOC_TYPE_WORKFLOW_STAGE) == WORKFLOW_STAGE_ID_SUBMISSION);
      return $this->_saveEditorDecision(
         $args, $request, 'InitiateInternalReviewForm',
         WORKFLOW_STAGE_PATH_INTERNAL_REVIEW,
         SUBMISSION_EDITOR_DECISION_INTERNAL_REVIEW
      );
   }
 
 
   //
   // Protected helper methods
   //
   protected function _saveGeneralPromote($args, $request) {
      // Redirect to the next workflow page after
      // promoting the submission.
      $decision = (int)$request->getUserVar('decision');
 
      $redirectOp = null;
 
      if ($decision == SUBMISSION_EDITOR_DECISION_ACCEPT) {
         $redirectOp = WORKFLOW_STAGE_PATH_EDITING;
      } elseif ($decision == SUBMISSION_EDITOR_DECISION_EXTERNAL_REVIEW) {
         $redirectOp = WORKFLOW_STAGE_PATH_EXTERNAL_REVIEW;
      } elseif ($decision == SUBMISSION_EDITOR_DECISION_SEND_TO_PRODUCTION) {
         $redirectOp = WORKFLOW_STAGE_PATH_PRODUCTION;
      }
 
      // Make sure user has access to the workflow stage.
      import('lib.pkp.classes.workflow.WorkflowStageDAO');
      $redirectWorkflowStage = WorkflowStageDAO::getIdFromPath($redirectOp);
      $userAccessibleWorkflowStages = $this->getAuthorizedContextObject(ASSOC_TYPE_ACCESSIBLE_WORKFLOW_STAGES);
      if (!array_key_exists($redirectWorkflowStage, $userAccessibleWorkflowStages)) {
         $redirectOp = null;
      }
 
      return $this->_saveEditorDecision($args, $request, 'PromoteForm', $redirectOp);
   }
 
   protected function _getNotificationTypeByEditorDecision($decision) {
      switch ($decision) {
         case SUBMISSION_EDITOR_DECISION_INTERNAL_REVIEW:
            return NOTIFICATION_TYPE_EDITOR_DECISION_INTERNAL_REVIEW;
         case SUBMISSION_EDITOR_DECISION_ACCEPT:
            return NOTIFICATION_TYPE_EDITOR_DECISION_ACCEPT;
         case SUBMISSION_EDITOR_DECISION_EXTERNAL_REVIEW:
            return NOTIFICATION_TYPE_EDITOR_DECISION_EXTERNAL_REVIEW;
         case SUBMISSION_EDITOR_DECISION_PENDING_REVISIONS:
            return NOTIFICATION_TYPE_EDITOR_DECISION_PENDING_REVISIONS;
         case SUBMISSION_EDITOR_DECISION_RESUBMIT:
            return NOTIFICATION_TYPE_EDITOR_DECISION_RESUBMIT;
         case SUBMISSION_EDITOR_DECISION_NEW_ROUND:
            return NOTIFICATION_TYPE_EDITOR_DECISION_NEW_ROUND;
         case SUBMISSION_EDITOR_DECISION_DECLINE:
         case SUBMISSION_EDITOR_DECISION_INITIAL_DECLINE:
            return NOTIFICATION_TYPE_EDITOR_DECISION_DECLINE;
         case SUBMISSION_EDITOR_DECISION_SEND_TO_PRODUCTION:
            return NOTIFICATION_TYPE_EDITOR_DECISION_SEND_TO_PRODUCTION;
      }
      throw new Exception('Unknown editor decision.');
   }
 
   protected function _getReviewStages() {
      return array(WORKFLOW_STAGE_ID_INTERNAL_REVIEW, WORKFLOW_STAGE_ID_EXTERNAL_REVIEW);
   }
 
   protected function _getReviewNotificationTypes() {
      return array(NOTIFICATION_TYPE_PENDING_INTERNAL_REVISIONS, NOTIFICATION_TYPE_PENDING_EXTERNAL_REVISIONS);
   }
 
   protected function _resolveEditorDecisionForm($formName) {
      switch($formName) {
         case 'InitiateInternalReviewForm':
         case 'InitiateExternalReviewForm':
            return "controllers.modals.editorDecision.form.$formName";
         default:
            return parent::_resolveEditorDecisionForm($formName);
      }
   }
}