controllers/modals/editorDecision/form/EditorDecisionForm.inc.php

<?php

import('lib.pkp.classes.form.Form');

// Define review round and review stage id constants.
import('classes.monograph.reviewRound.ReviewRound');

class EditorDecisionForm extends Form {
   var $_seriesEditorSubmission;

   var $_stageId;

   var $_reviewRound;

   var $_decision;


   function EditorDecisionForm(&$seriesEditorSubmission, $decision, $stageId, $template, $reviewRound = null) {
      parent::Form($template);
      $this->_seriesEditorSubmission = $seriesEditorSubmission;
      $this->_stageId = $stageId;
      $this->_reviewRound = $reviewRound;
      $this->_decision = $decision;

      // Validation checks for this form
      $this->addCheck(new FormValidatorPost($this));
   }

   //
   // Getters and Setters
   //
   function getDecision() {
      return $this->_decision;
   }

   function &getSeriesEditorSubmission() {
      return $this->_seriesEditorSubmission;
   }

   function getStageId() {
      return $this->_stageId;
   }

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

   //
   // Overridden template methods from Form
   //
   function readInputData() {
      $this->readUserVars(array('selectedFiles'));
      parent::initData();
   }


   function fetch(&$request) {
      $seriesEditorSubmission =& $this->getSeriesEditorSubmission();

      $reviewRound =& $this->getReviewRound();
      if (is_a($reviewRound, 'ReviewRound')) {
         $this->setData('reviewRoundId', $reviewRound->getId());
      }

      $this->setData('stageId', $this->getStageId());

      // Set the monograph.
      $templateMgr =& TemplateManager::getManager();
      $templateMgr->assign('monographId', $seriesEditorSubmission->getId());
      $templateMgr->assign_by_ref('monograph', $seriesEditorSubmission);

      // Set the decision related data.
      $stageDecisions = EditorDecisionActionsManager::getStageDecisions($this->getStageId());
      $templateMgr->assign('decisionData', $stageDecisions[$this->getDecision()]);

      return parent::fetch($request);
   }


   //
   // Private helper methods
   //
   function _initiateReviewRound(&$monograph, $stageId, &$request, $status = null) {

      // If we already have review round for this stage,
      // we create a new stage after the last one.
      $reviewRoundDao =& DAORegistry::getDAO('ReviewRoundDAO'); /* @var $reviewRoundDao ReviewRoundDAO */
      $lastReviewRound =& $reviewRoundDao->getLastReviewRoundByMonographId($monograph->getId(), $stageId);
      if ($lastReviewRound) {
         $newRound = $lastReviewRound->getRound() + 1;
      } else {
         // If we don't have any review round, we create the first one.
         $newRound = 1;
      }

      // Create a new review round.
      $reviewRound =& $reviewRoundDao->build($monograph->getId(), $stageId, $newRound, $status);

      // Check for a notification already in place for the current review round.
      $notificationDao =& DAORegistry::getDAO('NotificationDAO');
      $notificationFactory =& $notificationDao->getByAssoc(
         ASSOC_TYPE_REVIEW_ROUND,
         $reviewRound->getId(),
         null,
         NOTIFICATION_TYPE_REVIEW_ROUND_STATUS,
         $monograph->getPressId()
      );

      // Create round status notification if there is no notification already.
      if ($notificationFactory->wasEmpty()) {
         $notificationMgr = new NotificationManager();
         $notificationMgr->createNotification(
            $request,
            null,
            NOTIFICATION_TYPE_REVIEW_ROUND_STATUS,
            $monograph->getPressId(),
            ASSOC_TYPE_REVIEW_ROUND,
            $reviewRound->getId(),
            NOTIFICATION_LEVEL_NORMAL
         );
      }

      // Add the selected files to the new round.
      $submissionFileDao =& DAORegistry::getDAO('SubmissionFileDAO'); /* @var $submissionFileDao SubmissionFileDAO */

      // Bring in the MONOGRAPH_FILE_* constants.
      import('classes.monograph.MonographFile');
      // Bring in the Manager (we need it).
      import('classes.file.MonographFileManager');
      $monographFileManager = new MonographFileManager($monograph->getPressId(), $monograph->getId());
      foreach (array('selectedFiles', 'selectedAttachments') as $userVar) {
         $selectedFiles = $this->getData($userVar);
         if(is_array($selectedFiles)) {
            foreach ($selectedFiles as $selectedFile) {
               // Split the file into file id and file revision.
               list($fileId, $revision) = explode('-', $selectedFile);
               list($newFileId, $newRevision) = $monographFileManager->copyFileToFileStage($fileId, $revision, MONOGRAPH_FILE_REVIEW_FILE, null, true);
               $submissionFileDao->assignRevisionToReviewRound($newFileId, $newRevision, $reviewRound);
            }
         }
      }

      return $newRound;
   }
}

?>