ReviewAssignmentDAO.inc.php

<?php
 
import('lib.pkp.classes.submission.reviewAssignment.ReviewAssignment');
 
class ReviewAssignmentDAO extends DAO {
   var $userDao;
 
   function __construct() {
      parent::__construct();
      $this->userDao = DAORegistry::getDAO('UserDAO');
   }
 
 
   function getByReviewRoundId($reviewRoundId) {
      $params = array((int)$reviewRoundId);
      $query = $this->_getSelectQuery() .
         ' WHERE r.review_round_id = ? ORDER BY review_id';
      return $this->_getReviewAssignmentsArray($query, $params);
   }
 
   function getOpenReviewsByReviewRoundId($reviewRoundId) {
      $params = array((int)$reviewRoundId, SUBMISSION_REVIEW_METHOD_OPEN);
      $query = $this->_getSelectQuery() .
         ' WHERE r.review_round_id = ? AND r.review_method = ? AND r.date_confirmed IS NOT NULL AND r.declined <> 1 ORDER BY review_id';
      return $this->_getReviewAssignmentsArray($query, $params);
   }
 
   function _getReviewAssignmentsArray($query, $queryParams) {
      $reviewAssignments = array();
 
      $result = $this->retrieve($query, $queryParams);
 
      while (!$result->EOF) {
         $reviewAssignments[$result->fields['review_id']] = $this->_fromRow($result->GetRowAssoc(false));
         $result->MoveNext();
      }
 
      $result->Close();
      return $reviewAssignments;
   }
 
   function getReviewRoundJoin() {
      return 'r.review_round_id = r2.review_round_id';
   }
 
 
   //
   // Public methods.
   //
   function getReviewAssignment($reviewRoundId, $reviewerId) {
      $result = $this->retrieve(
         $this->_getSelectQuery() .
         ' WHERE  r.review_round_id = ? AND
            r.reviewer_id = ?',
         array(
            (int) $reviewRoundId,
            (int) $reviewerId
         )
      );
 
      $returner = null;
      if ($result->RecordCount() != 0) {
         $returner = $this->_fromRow($result->GetRowAssoc(false));
      }
 
      $result->Close();
      return $returner;
   }
 
 
   function getById($reviewId) {
      $reviewRoundJoinString = $this->getReviewRoundJoin();
      if ($reviewRoundJoinString) {
         $result = $this->retrieve(
            'SELECT  r.*, r2.review_revision
            FROM  review_assignments r
               LEFT JOIN review_rounds r2 ON (' . $reviewRoundJoinString . ')
            WHERE r.review_id = ?',
            (int) $reviewId
         );
 
         $returner = null;
         if ($result->RecordCount() != 0) {
            $returner = $this->_fromRow($result->GetRowAssoc(false));
         }
 
         $result->Close();
         return $returner;
      } else {
         assert(false);
      }
   }
 
   function getIncompleteReviewAssignments() {
      $reviewAssignments = array();
      $reviewRoundJoinString = $this->getReviewRoundJoin();
      if ($reviewRoundJoinString) {
         $result = $this->retrieve(
            'SELECT  r.*, r2.review_revision
            FROM  review_assignments r
               LEFT JOIN review_rounds r2 ON (' . $reviewRoundJoinString . ')
            WHERE' . $this->getIncompleteReviewAssignmentsWhereString() .
            ' ORDER BY r.submission_id'
         );
 
         while (!$result->EOF) {
            $reviewAssignments[] = $this->_fromRow($result->GetRowAssoc(false));
            $result->MoveNext();
         }
 
         $result->Close();
      } else {
         assert(false);
      }
 
      return $reviewAssignments;
   }
 
   function getIncompleteReviewAssignmentsWhereString() {
      return ' r.date_notified IS NOT NULL AND
      r.date_completed IS NULL AND
      r.declined <> 1 AND
      r.cancelled <> 1';
   }
 
   function getBySubmissionId($submissionId, $reviewRoundId = null, $stageId = null) {
      $query = $this->_getSelectQuery() .
         ' WHERE  r.submission_id = ?';
 
      $orderBy = ' ORDER BY review_id';
 
      $queryParams[] = (int) $submissionId;
 
      if ($reviewRoundId != null) {
         $query .= ' AND r2.review_round_id = ?';
         $queryParams[] = (int) $reviewRoundId;
      } else {
         $orderBy .= ', r2.review_round_id';
      }
 
      if ($stageId != null) {
         $query .= ' AND r2.stage_id = ?';
         $queryParams[] = (int) $stageId;
      } else {
         $orderBy .= ', r2.stage_id';
      }
 
      $query .= $orderBy;
 
      return $this->_getReviewAssignmentsArray($query, $queryParams);
   }
 
   function getByUserId($userId) {
      $reviewAssignments = array();
      $reviewRoundJoinString = $this->getReviewRoundJoin();
 
      if ($reviewRoundJoinString) {
         $result = $this->retrieve(
            'SELECT  r.*, r2.review_revision
            FROM  review_assignments r
               LEFT JOIN review_rounds r2 ON (' . $reviewRoundJoinString . ')
            WHERE r.reviewer_id = ?
            ORDER BY round, review_id',
         (int) $userId
         );
 
         while (!$result->EOF) {
            $reviewAssignments[] = $this->_fromRow($result->GetRowAssoc(false));
            $result->MoveNext();
         }
 
         $result->Close();
      } else {
         assert(false);
      }
 
      return $reviewAssignments;
   }
 
   function reviewerExists($reviewRoundId, $reviewerId) {
      $result = $this->retrieve(
            'SELECT COUNT(*)
            FROM  review_assignments
            WHERE review_round_id = ? AND
            reviewer_id = ?',
            array((int) $reviewRoundId, (int) $reviewerId)
      );
      $returner = isset($result->fields[0]) && $result->fields[0] == 1 ? true : false;
 
      $result->Close();
      return $returner;
   }
 
   function getByReviewFormId($reviewFormId) {
      $reviewAssignments = array();
      $reviewRoundJoinString = $this->getReviewRoundJoin();
 
      if ($reviewRoundJoinString) {
         $result = $this->retrieve(
            'SELECT  r.*, r2.review_revision
            FROM  review_assignments r
               LEFT JOIN review_rounds r2 ON (' . $reviewRoundJoinString . ')
            WHERE r.review_form_id = ?
            ORDER BY round, review_id',
            (int) $reviewFormId
         );
 
         while (!$result->EOF) {
            $reviewAssignments[] = $this->_fromRow($result->GetRowAssoc(false));
            $result->MoveNext();
         }
 
         $result->Close();
      } else {
         assert(false);
      }
 
      return $reviewAssignments;
   }
 
   function getReviewIndexesForRound($submissionId, $reviewRoundId) {
      $result = $this->retrieve(
         'SELECT  review_id
         FROM  review_assignments
         WHERE submission_id = ? AND
            review_round_id = ?
         ORDER BY review_id',
         array((int) $submissionId, (int) $reviewRoundId)
      );
 
      $index = 0;
      $returner = array();
      while (!$result->EOF) {
         $row = $result->GetRowAssoc(false);
         $returner[$row['review_id']] = $index++;
         $result->MoveNext();
      }
 
      $result->Close();
      return $returner;
   }
 
   function insertObject($reviewAssignment) {
      $result = $this->update(
         sprintf('INSERT INTO review_assignments (
            submission_id,
            reviewer_id,
            stage_id,
            review_method,
            round,
            competing_interests,
            recommendation,
            declined,
            cancelled,
            date_assigned, date_notified, date_confirmed,
            date_completed, date_acknowledged, date_due, date_response_due,
            quality, date_rated,
            last_modified,
            date_reminded, reminder_was_automatic,
            review_form_id,
            review_round_id,
            unconsidered
            ) VALUES (
            ?, ?, ?, ?, ?, ?, ?, ?, ?, %s, %s, %s, %s, %s, %s, %s, ?, %s, %s, %s, ?, ?, ?, ?
            )',
            $this->datetimeToDB($reviewAssignment->getDateAssigned()),
            $this->datetimeToDB($reviewAssignment->getDateNotified()),
            $this->datetimeToDB($reviewAssignment->getDateConfirmed()),
            $this->datetimeToDB($reviewAssignment->getDateCompleted()),
            $this->datetimeToDB($reviewAssignment->getDateAcknowledged()),
            $this->datetimeToDB($reviewAssignment->getDateDue()),
            $this->datetimeToDB($reviewAssignment->getDateResponseDue()),
            $this->datetimeToDB($reviewAssignment->getDateRated()),
            $this->datetimeToDB($reviewAssignment->getLastModified()),
            $this->datetimeToDB($reviewAssignment->getDateReminded())
         ), array(
            (int) $reviewAssignment->getSubmissionId(),
            (int) $reviewAssignment->getReviewerId(),
            (int) $reviewAssignment->getStageId(),
            (int) $reviewAssignment->getReviewMethod(),
            max((int) $reviewAssignment->getRound(), 1),
            $reviewAssignment->getCompetingInterests(),
            $reviewAssignment->getRecommendation(),
            (int) $reviewAssignment->getDeclined(),
            (int) $reviewAssignment->getCancelled(),
            $reviewAssignment->getQuality(),
            (int) $reviewAssignment->getReminderWasAutomatic(),
            $reviewAssignment->getReviewFormId(),
            (int) $reviewAssignment->getReviewRoundId(),
            (int) $reviewAssignment->getUnconsidered(),
         )
      );
 
      $reviewAssignment->setId($this->getInsertId());
 
      // Update review stage status whenever a review assignment is changed
      $this->updateReviewRoundStatus($reviewAssignment);
   }
 
   function updateObject($reviewAssignment) {
      $result = $this->update(
         sprintf('UPDATE review_assignments
            SET   submission_id = ?,
               reviewer_id = ?,
               stage_id = ?,
               review_method = ?,
               round = ?,
               competing_interests = ?,
               recommendation = ?,
               declined = ?,
               cancelled = ?,
               date_assigned = %s,
               date_notified = %s,
               date_confirmed = %s,
               date_completed = %s,
               date_acknowledged = %s,
               date_due = %s,
               date_response_due = %s,
               quality = ?,
               date_rated = %s,
               last_modified = %s,
               date_reminded = %s,
               reminder_was_automatic = ?,
               review_form_id = ?,
               review_round_id = ?,
               unconsidered = ?
            WHERE review_id = ?',
            $this->datetimeToDB($reviewAssignment->getDateAssigned()), $this->datetimeToDB($reviewAssignment->getDateNotified()), $this->datetimeToDB($reviewAssignment->getDateConfirmed()), $this->datetimeToDB($reviewAssignment->getDateCompleted()), $this->datetimeToDB($reviewAssignment->getDateAcknowledged()), $this->datetimeToDB($reviewAssignment->getDateDue()), $this->datetimeToDB($reviewAssignment->getDateResponseDue()), $this->datetimeToDB($reviewAssignment->getDateRated()), $this->datetimeToDB($reviewAssignment->getLastModified()), $this->datetimeToDB($reviewAssignment->getDateReminded())),
         array(
            (int) $reviewAssignment->getSubmissionId(),
            (int) $reviewAssignment->getReviewerId(),
            (int) $reviewAssignment->getStageId(),
            (int) $reviewAssignment->getReviewMethod(),
            (int) $reviewAssignment->getRound(),
            $reviewAssignment->getCompetingInterests(),
            $reviewAssignment->getRecommendation(),
            (int) $reviewAssignment->getDeclined(),
            (int) $reviewAssignment->getCancelled(),
            $reviewAssignment->getQuality(),
            $reviewAssignment->getReminderWasAutomatic(),
            $reviewAssignment->getReviewFormId(),
            (int) $reviewAssignment->getReviewRoundId(),
            (int) $reviewAssignment->getUnconsidered(),
            (int) $reviewAssignment->getId()
         )
      );
 
      // Update review stage status whenever a review assignment is changed
      $this->updateReviewRoundStatus($reviewAssignment);
   }
 
   public function updateReviewRoundStatus($reviewAssignment) {
      import('lib.pkp.classes.submission.reviewRound/ReviewRoundDAO');
      $reviewRoundDao = DAORegistry::getDAO('ReviewRoundDAO'); /* @var $reviewRoundDao ReviewRoundDAO */
      $reviewRound = $reviewRoundDao->getReviewRound(
         $reviewAssignment->getSubmissionId(),
         $reviewAssignment->getStageId(),
         $reviewAssignment->getRound()
      );
 
      // Review round may not exist if submission is being deleted
      if ($reviewRound) {
         return $reviewRoundDao->updateStatus($reviewRound);
      }
 
      return false;
   }
 
   function _fromRow($row) {
      $reviewAssignment = $this->newDataObject();
      $user = $this->userDao->getById($row['reviewer_id']);
 
      $reviewAssignment->setId((int) $row['review_id']);
      $reviewAssignment->setSubmissionId((int) $row['submission_id']);
      $reviewAssignment->setReviewerId((int) $row['reviewer_id']);
      $reviewAssignment->setReviewerFullName($user->getFullName());
      $reviewAssignment->setCompetingInterests($row['competing_interests']);
      $reviewAssignment->setRecommendation($row['recommendation']);
      $reviewAssignment->setDateAssigned($this->datetimeFromDB($row['date_assigned']));
      $reviewAssignment->setDateNotified($this->datetimeFromDB($row['date_notified']));
      $reviewAssignment->setDateConfirmed($this->datetimeFromDB($row['date_confirmed']));
      $reviewAssignment->setDateCompleted($this->datetimeFromDB($row['date_completed']));
      $reviewAssignment->setDateAcknowledged($this->datetimeFromDB($row['date_acknowledged']));
      $reviewAssignment->setDateDue($this->datetimeFromDB($row['date_due']));
      $reviewAssignment->setDateResponseDue($this->datetimeFromDB($row['date_response_due']));
      $reviewAssignment->setLastModified($this->datetimeFromDB($row['last_modified']));
      $reviewAssignment->setDeclined((int) $row['declined']);
      $reviewAssignment->setCancelled((int) $row['cancelled']);
      $reviewAssignment->setQuality($row['quality']);
      $reviewAssignment->setDateRated($this->datetimeFromDB($row['date_rated']));
      $reviewAssignment->setDateReminded($this->datetimeFromDB($row['date_reminded']));
      $reviewAssignment->setReminderWasAutomatic((int) $row['reminder_was_automatic']);
      $reviewAssignment->setRound((int) $row['round']);
      $reviewAssignment->setReviewFormId($row['review_form_id']);
      $reviewAssignment->setReviewRoundId((int) $row['review_round_id']);
      $reviewAssignment->setReviewMethod((int) $row['review_method']);
      $reviewAssignment->setStageId((int) $row['stage_id']);
      $reviewAssignment->setUnconsidered((int) $row['unconsidered']);
 
      return $reviewAssignment;
   }
 
   function newDataObject() {
      return new ReviewAssignment();
   }
 
   function deleteById($reviewId) {
      $reviewFormResponseDao = DAORegistry::getDAO('ReviewFormResponseDAO'); /* @var $reviewFormResponseDao ReviewFormResponseDAO */
      $reviewFormResponseDao->deleteByReviewId($reviewId);
 
      $reviewFilesDao = DAORegistry::getDAO('ReviewFilesDAO'); /* @var $reviewFilesDao ReviewFilesDAO */
      $reviewFilesDao->revokeByReviewId($reviewId);
 
      $notificationDao = DAORegistry::getDAO('NotificationDAO'); /* @var $notificationDao NotificationDAO */
      $notificationDao->deleteByAssoc(ASSOC_TYPE_REVIEW_ASSIGNMENT, $reviewId);
 
      // Retrieve the review assignment before it's deleted, so it can be
      // be used to fire an update on the review round status.
      import('lib.pkp.classes.submission.reviewRound/ReviewRoundDAO');
      $reviewAssignment = $this->getById($reviewId);
 
      $result = $this->update(
         'DELETE FROM review_assignments WHERE review_id = ?',
         (int) $reviewId
      );
 
      $this->updateReviewRoundStatus($reviewAssignment);
 
      return $result;
   }
 
   function deleteBySubmissionId($submissionId) {
      $returner = false;
      $result = $this->retrieve(
         'SELECT review_id FROM review_assignments WHERE submission_id = ?',
         array((int) $submissionId)
      );
 
      while (!$result->EOF) {
         $row = $result->GetRowAssoc(false);
         $this->deleteById($row['review_id']);
         $result->MoveNext();
         $returner = true;
      }
      $result->Close();
      return $returner;
   }
 
   function getInsertId() {
      return $this->_getInsertId('review_assignments', 'review_id');
   }
 
   function getLastReviewRoundReviewAssignmentByReviewer($submissionId, $reviewerId) {
      $params = array(
            (int) $submissionId,
            (int) $reviewerId
      );
 
      $result = $this->retrieveLimit(
            $this->_getSelectQuery() .
            ' WHERE  r.submission_id = ? AND
            r.reviewer_id = ?
            ORDER BY r2.stage_id DESC, r2.round DESC',
            $params,
            1
      );
 
      $returner = null;
      if ($result->RecordCount() != 0) {
         $returner = $this->_fromRow($result->GetRowAssoc(false));
      }
 
      $result->Close();
      return $returner;
   }
 
   function getReviewMethodsTranslationKeys() {
      AppLocale::requireComponents(LOCALE_COMPONENT_PKP_EDITOR);
      return array(
         SUBMISSION_REVIEW_METHOD_DOUBLEBLIND => 'editor.submissionReview.doubleBlind',
         SUBMISSION_REVIEW_METHOD_BLIND => 'editor.submissionReview.blind',
         SUBMISSION_REVIEW_METHOD_OPEN => 'editor.submissionReview.open',
      );
   }
 
   function _getSelectQuery() {
      return 'SELECT r.*, r2.review_revision FROM review_assignments r
         LEFT JOIN review_rounds r2 ON (r.review_round_id = r2.review_round_id)';
   }
}