ReviewAssignment.inc.php

<?php
 
define('SUBMISSION_REVIEWER_RECOMMENDATION_ACCEPT', 1);
define('SUBMISSION_REVIEWER_RECOMMENDATION_PENDING_REVISIONS', 2);
define('SUBMISSION_REVIEWER_RECOMMENDATION_RESUBMIT_HERE', 3);
define('SUBMISSION_REVIEWER_RECOMMENDATION_RESUBMIT_ELSEWHERE', 4);
define('SUBMISSION_REVIEWER_RECOMMENDATION_DECLINE', 5);
define('SUBMISSION_REVIEWER_RECOMMENDATION_SEE_COMMENTS', 6);
 
define('SUBMISSION_REVIEWER_RATING_VERY_GOOD', 5);
define('SUBMISSION_REVIEWER_RATING_GOOD', 4);
define('SUBMISSION_REVIEWER_RATING_AVERAGE', 3);
define('SUBMISSION_REVIEWER_RATING_POOR', 2);
define('SUBMISSION_REVIEWER_RATING_VERY_POOR', 1);
 
define('SUBMISSION_REVIEW_METHOD_BLIND', 1);
define('SUBMISSION_REVIEW_METHOD_DOUBLEBLIND', 2);
define('SUBMISSION_REVIEW_METHOD_OPEN', 3);
 
// A review is "unconsidered" when it is confirmed by an editor and then that
// confirmation is later revoked.
define('REVIEW_ASSIGNMENT_NOT_UNCONSIDERED', 0); // Has never been unconsidered
define('REVIEW_ASSIGNMENT_UNCONSIDERED', 1); // Has been unconsindered and is awaiting re-confirmation by an editor
define('REVIEW_ASSIGNMENT_UNCONSIDERED_READ', 2); // Has been reconfirmed by an editor
 
define('REVIEW_ASSIGNMENT_STATUS_AWAITING_RESPONSE', 0); // request has been sent but reviewer has not responded
define('REVIEW_ASSIGNMENT_STATUS_DECLINED', 1); // reviewer declined review request
define('REVIEW_ASSIGNMENT_STATUS_RESPONSE_OVERDUE', 4); // review not responded within due date
define('REVIEW_ASSIGNMENT_STATUS_ACCEPTED', 5); // reviewer has agreed to the review
define('REVIEW_ASSIGNMENT_STATUS_REVIEW_OVERDUE', 6); // review not submitted within due date
define('REVIEW_ASSIGNMENT_STATUS_RECEIVED', 7); // review has been submitted
define('REVIEW_ASSIGNMENT_STATUS_COMPLETE', 8); // review has been confirmed by an editor
define('REVIEW_ASSIGNMENT_STATUS_THANKED', 9); // reviewer has been thanked
define('REVIEW_ASSIGNMENT_STATUS_CANCELLED', 10); // reviewer cancelled review request
 
class ReviewAssignment extends DataObject {
 
   //
   // Get/set methods
   //
 
   function getSubmissionId() {
      return $this->getData('submissionId');
   }
 
   function setSubmissionId($submissionId) {
      $this->setData('submissionId', $submissionId);
   }
 
   function getReviewerId() {
      return $this->getData('reviewerId');
   }
 
   function setReviewerId($reviewerId) {
      $this->setData('reviewerId', $reviewerId);
   }
 
   function getReviewerFullName() {
      return $this->getData('reviewerFullName');
   }
 
   function setReviewerFullName($reviewerFullName) {
      $this->setData('reviewerFullName', $reviewerFullName);
   }
 
   function getComments() {
      return $this->getData('comments');
   }
 
   function setComments($comments) {
      $this->setData('comments', $comments);
   }
 
   function getCompetingInterests() {
      return $this->getData('competingInterests');
   }
 
   function setCompetingInterests($competingInterests) {
      $this->setData('competingInterests', $competingInterests);
   }
 
   function getStageId() {
      return $this->getData('stageId');
   }
 
   function setStageId($stageId) {
      $this->setData('stageId', $stageId);
   }
 
   function getReviewMethod() {
      return $this->getData('reviewMethod');
   }
 
   function setReviewMethod($method) {
      $this->setData('reviewMethod', $method);
   }
 
   function getReviewRoundId() {
      return $this->getData('reviewRoundId');
   }
 
   function setReviewRoundId($reviewRoundId) {
      $this->setData('reviewRoundId', $reviewRoundId);
   }
 
   function getRecommendation() {
      return $this->getData('recommendation');
   }
 
   function setRecommendation($recommendation) {
      $this->setData('recommendation', $recommendation);
   }
 
   function getUnconsidered() {
      return $this->getData('unconsidered');
   }
 
   function setUnconsidered($unconsidered) {
      $this->setData('unconsidered', $unconsidered);
   }
 
   function getDateRated() {
      return $this->getData('dateRated');
   }
 
   function setDateRated($dateRated) {
      $this->setData('dateRated', $dateRated);
   }
 
   function getLastModified() {
      return $this->getData('lastModified');
   }
 
   function setLastModified($dateModified) {
      $this->setData('lastModified', $dateModified);
   }
 
   function stampModified() {
      return $this->setLastModified(Core::getCurrentDate());
   }
 
   function getDateAssigned() {
      return $this->getData('dateAssigned');
   }
 
   function setDateAssigned($dateAssigned) {
      $this->setData('dateAssigned', $dateAssigned);
   }
 
   function getDateNotified() {
      return $this->getData('dateNotified');
   }
 
   function setDateNotified($dateNotified) {
      $this->setData('dateNotified', $dateNotified);
   }
 
   function getDateConfirmed() {
      return $this->getData('dateConfirmed');
   }
 
   function setDateConfirmed($dateConfirmed) {
      $this->setData('dateConfirmed', $dateConfirmed);
   }
 
   function getDateCompleted() {
      return $this->getData('dateCompleted');
   }
 
   function setDateCompleted($dateCompleted) {
      $this->setData('dateCompleted', $dateCompleted);
   }
 
   function getDateAcknowledged() {
      return $this->getData('dateAcknowledged');
   }
 
   function setDateAcknowledged($dateAcknowledged) {
      $this->setData('dateAcknowledged', $dateAcknowledged);
   }
 
   function getDateReminded() {
      return $this->getData('dateReminded');
   }
 
   function setDateReminded($dateReminded) {
      $this->setData('dateReminded', $dateReminded);
   }
 
   function getDateDue() {
      return $this->getData('dateDue');
   }
 
   function setDateDue($dateDue) {
      $this->setData('dateDue', $dateDue);
   }
 
   function getDateResponseDue() {
      return $this->getData('dateResponseDue');
   }
 
   function setDateResponseDue($dateResponseDue) {
      $this->setData('dateResponseDue', $dateResponseDue);
   }
 
   function getDeclined() {
      return $this->getData('declined');
   }
 
   function setDeclined($declined) {
      $this->setData('declined', $declined);
   }
 
   function getCancelled() {
      return $this->getData('cancelled');
   }
 
   function setCancelled($cancelled) {
      $this->setData('cancelled', $cancelled);
   }
 
   function getReminderWasAutomatic() {
      return $this->getData('reminderWasAutomatic')==1?1:0;
   }
 
   function setReminderWasAutomatic($wasAutomatic) {
      $this->setData('reminderWasAutomatic', $wasAutomatic);
   }
 
   function getQuality() {
      return $this->getData('quality');
   }
 
   function setQuality($quality) {
      $this->setData('quality', $quality);
   }
 
   function getRound() {
      return $this->getData('round');
   }
 
   function setRound($round) {
      $this->setData('round', $round);
   }
 
   function getReviewFormId() {
      return $this->getData('reviewFormId');
   }
 
   function setReviewFormId($reviewFormId) {
      $this->setData('reviewFormId', $reviewFormId);
   }
 
   function getStatus() {
      if ($this->getDeclined()) return REVIEW_ASSIGNMENT_STATUS_DECLINED;
      if ($this->getCancelled()) return REVIEW_ASSIGNMENT_STATUS_CANCELLED;
 
      if (!$this->getDateCompleted()) {
         $dueTimes = array_map(function($dateTime) {
               // If no due time, set it to the end of the day
               if (substr($dateTime, 11) === '00:00:00') {
                  $dateTime = substr($dateTime, 0, 11) . '23:59:59';
               }
               return strtotime($dateTime);
            }, array($this->getDateResponseDue(), $this->getDateDue()));
         $responseDueTime = $dueTimes[0];
         $reviewDueTime = $dueTimes[1];
         if (!$this->getDateConfirmed()){ // no response
            if($responseDueTime < time()) { // response overdue
               return REVIEW_ASSIGNMENT_STATUS_RESPONSE_OVERDUE;
            } elseif ($reviewDueTime < strtotime('tomorrow')) { // review overdue but not response
               return REVIEW_ASSIGNMENT_STATUS_REVIEW_OVERDUE;
            } else { // response not due yet
               return REVIEW_ASSIGNMENT_STATUS_AWAITING_RESPONSE;
            }
         } else { // response given
            if ($reviewDueTime < strtotime('tomorrow')) { // review due
               return REVIEW_ASSIGNMENT_STATUS_REVIEW_OVERDUE;
            } else {
               return REVIEW_ASSIGNMENT_STATUS_ACCEPTED;
            }
         }
      } elseif ($this->getDateAcknowledged()) { // reviewer thanked...
         if ($this->getUnconsidered() == REVIEW_ASSIGNMENT_UNCONSIDERED) { // ...but review later unconsidered
            return REVIEW_ASSIGNMENT_STATUS_RECEIVED;
         }
         return REVIEW_ASSIGNMENT_STATUS_THANKED;
      } elseif ($this->getDateCompleted()) { // review submitted...
         if ($this->getUnconsidered() != REVIEW_ASSIGNMENT_UNCONSIDERED && $this->isRead()) { // ...and confirmed by an editor
            return REVIEW_ASSIGNMENT_STATUS_COMPLETE;
         }
         return REVIEW_ASSIGNMENT_STATUS_RECEIVED;
      }
 
      return REVIEW_ASSIGNMENT_STATUS_AWAITING_RESPONSE;
   }
 
   function isRead() {
      $submissionDao = DAORegistry::getDAO('SubmissionDAO'); /* @var $submissionDao SubmissionDAO */
      $userGroupDao = DAORegistry::getDAO('UserGroupDAO'); /* @var $userGroupDao UserGroupDAO */
      $userStageAssignmentDao = DAORegistry::getDAO('UserStageAssignmentDAO'); /* @var $userStageAssignmentDao UserStageAssignmentDAO */
      $viewsDao = DAORegistry::getDAO('ViewsDAO'); /* @var $viewsDao ViewsDAO */
 
      $submission = $submissionDao->getById($this->getSubmissionId());
 
      // Get the user groups for this stage
      $userGroups = $userGroupDao->getUserGroupsByStage(
         $submission->getContextId(),
         $this->getStageId()
      );
      while ($userGroup = $userGroups->next()) {
         $roleId = $userGroup->getRoleId();
         if ($roleId != ROLE_ID_MANAGER && $roleId != ROLE_ID_SUB_EDITOR) {
            continue;
         }
 
         // Get the users assigned to this stage and user group
         $stageUsers = $userStageAssignmentDao->getUsersBySubmissionAndStageId(
            $this->getSubmissionId(),
            $this->getStageId(),
            $userGroup->getId()
         );
 
         // Check if any of these users have viewed it
         while ($user = $stageUsers->next()) {
            if ($viewsDao->getLastViewDate(
               ASSOC_TYPE_REVIEW_RESPONSE,
               $this->getId(),
               $user->getId()
            )) {
               return true;
            }
         }
      }
 
      return false;
   }
 
   public function getStatusKey($status = null) {
 
      if (is_null($status)) {
         $status = $this->getStatus();
      }
 
      switch ($status) {
         case REVIEW_ASSIGNMENT_STATUS_AWAITING_RESPONSE:
            return 'submission.review.status.awaitingResponse';
         case REVIEW_ASSIGNMENT_STATUS_DECLINED:
            return 'submission.review.status.declined';
         case REVIEW_ASSIGNMENT_STATUS_RESPONSE_OVERDUE:
            return 'submission.review.status.responseOverdue';
         case REVIEW_ASSIGNMENT_STATUS_REVIEW_OVERDUE:
            return 'submission.review.status.reviewOverdue';
         case REVIEW_ASSIGNMENT_STATUS_ACCEPTED:
            return 'submission.review.status.accepted';
         case REVIEW_ASSIGNMENT_STATUS_RECEIVED:
            return 'submission.review.status.received';
         case REVIEW_ASSIGNMENT_STATUS_COMPLETE:
            return 'submission.review.status.complete';
         case REVIEW_ASSIGNMENT_STATUS_THANKED:
            return 'submission.review.status.thanked';
      }
 
      assert(false, 'No status key could be found for ' . get_class($this) . ' on ' . __LINE__);
 
      return '';
   }
 
   public function getReviewMethodKey($method = null) {
 
      if (is_null($method)) {
         $method = $this->getReviewMethod();
      }
 
      switch ($method) {
         case SUBMISSION_REVIEW_METHOD_OPEN:
            return 'editor.submissionReview.open';
         case SUBMISSION_REVIEW_METHOD_BLIND:
            return 'editor.submissionReview.blind';
         case SUBMISSION_REVIEW_METHOD_DOUBLEBLIND:
            return 'editor.submissionReview.doubleBlind';
      }
 
      assert(false, 'No review method key could be found for ' . get_class($this) . ' on ' . __LINE__);
 
      return '';
   }
 
   //
   // Files
   //
 
   function getWeeksDue() {
      $dateDue = $this->getDateDue();
      if ($dateDue === null) return null;
      return round((strtotime($dateDue) - time()) / (86400 * 7.0));
   }
 
   static function getReviewerRecommendationOptions() {
 
      static $reviewerRecommendationOptions = array(
            '' => 'common.chooseOne',
            SUBMISSION_REVIEWER_RECOMMENDATION_ACCEPT => 'reviewer.article.decision.accept',
            SUBMISSION_REVIEWER_RECOMMENDATION_PENDING_REVISIONS => 'reviewer.article.decision.pendingRevisions',
            SUBMISSION_REVIEWER_RECOMMENDATION_RESUBMIT_HERE => 'reviewer.article.decision.resubmitHere',
            SUBMISSION_REVIEWER_RECOMMENDATION_RESUBMIT_ELSEWHERE => 'reviewer.article.decision.resubmitElsewhere',
            SUBMISSION_REVIEWER_RECOMMENDATION_DECLINE => 'reviewer.article.decision.decline',
            SUBMISSION_REVIEWER_RECOMMENDATION_SEE_COMMENTS => 'reviewer.article.decision.seeComments'
      );
      return $reviewerRecommendationOptions;
   }
 
   function getLocalizedRecommendation() {
 
      $options = self::getReviewerRecommendationOptions();
      if (array_key_exists($this->getRecommendation(), $options)) {
         return __($options[$this->getRecommendation()]);
      } else {
         return '';
      }
   }
}