PHP ReviewAssignment::setRound方法代码示例

 /**
  * Assigns a reviewer to a submission.
  * @param $seriesEditorSubmission object
  * @param $reviewerId int
  */
 function addReviewer($seriesEditorSubmission, $reviewerId, $reviewType, $round = null, $reviewDueDate = null, $responseDueDate = null)
 {
     $seriesEditorSubmissionDao =& DAORegistry::getDAO('SeriesEditorSubmissionDAO');
     $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
     $userDao =& DAORegistry::getDAO('UserDAO');
     $user =& Request::getUser();
     $reviewer =& $userDao->getUser($reviewerId);
     // Check to see if the requested reviewer is not already
     // assigned to review this monograph.
     if ($round == null) {
         $round = $seriesEditorSubmission->getCurrentRound();
     }
     $assigned = $seriesEditorSubmissionDao->reviewerExists($seriesEditorSubmission->getId(), $reviewerId, $reviewType, $round);
     // Only add the reviewer if he has not already
     // been assigned to review this monograph.
     if (!$assigned && isset($reviewer) && !HookRegistry::call('SeriesEditorAction::addReviewer', array(&$seriesEditorSubmission, $reviewerId))) {
         $reviewAssignment = new ReviewAssignment();
         $reviewAssignment->setSubmissionId($seriesEditorSubmission->getId());
         $reviewAssignment->setReviewerId($reviewerId);
         $reviewAssignment->setDateAssigned(Core::getCurrentDate());
         $reviewAssignment->setReviewType($reviewType);
         $reviewAssignment->setRound($round);
         // Assign review form automatically if needed
         $pressId = $seriesEditorSubmission->getPressId();
         $seriesDao =& DAORegistry::getDAO('SeriesDAO');
         $reviewFormDao =& DAORegistry::getDAO('ReviewFormDAO');
         $submissionId = $seriesEditorSubmission->getId();
         $series =& $seriesDao->getById($submissionId, $pressId);
         $seriesEditorSubmission->addReviewAssignment($reviewAssignment, $reviewType, $round);
         $seriesEditorSubmissionDao->updateSeriesEditorSubmission($seriesEditorSubmission);
         $reviewAssignment = $reviewAssignmentDao->getReviewAssignment($seriesEditorSubmission->getId(), $reviewerId, $round, $reviewType);
         $press =& Request::getPress();
         $settingsDao =& DAORegistry::getDAO('PressSettingsDAO');
         $settings =& $settingsDao->getPressSettings($press->getId());
         if (isset($reviewDueDate)) {
             SeriesEditorAction::setDueDate($seriesEditorSubmission->getId(), $reviewAssignment->getId(), $reviewDueDate);
         }
         if (isset($responseDueDate)) {
             SeriesEditorAction::setResponseDueDate($seriesEditorSubmission->getId(), $reviewAssignment->getId(), $responseDueDate);
         }
         // Add log
         import('classes.monograph.log.MonographLog');
         import('classes.monograph.log.MonographEventLogEntry');
         MonographLog::logEvent($seriesEditorSubmission->getId(), MONOGRAPH_LOG_REVIEW_ASSIGN, MONOGRAPH_LOG_TYPE_REVIEW, $reviewAssignment->getId(), 'log.review.reviewerAssigned', array('reviewerName' => $reviewer->getFullName(), 'monographId' => $seriesEditorSubmission->getId(), 'reviewType' => $reviewType, 'round' => $round));
     }
 }

 /**
  * Import reviews.
  */
 function importReviews()
 {
     if ($this->hasOption('verbose')) {
         printf("Importing reviews\n");
     }
     $userDao =& DAORegistry::getDAO('UserDAO');
     $roleDao =& DAORegistry::getDAO('RoleDAO');
     $editAssignmentDao =& DAORegistry::getDAO('EditAssignmentDAO');
     $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
     $paperCommentDao =& DAORegistry::getDAO('PaperCommentDAO');
     $unassignedTrackId = null;
     $result =& $this->importDao->retrieve('SELECT * FROM reviews ORDER by timestamp');
     while (!$result->EOF) {
         $row =& $result->fields;
         $schedConf =& $this->schedConfMap[$row['cf']];
         $paper =& $this->paperMap[$row['paper']];
         $reviewer =& $this->reviewerMap[$row['reviewer']];
         if (!$schedConf || !$paper || !$reviewer) {
             // Database inconsistency! Skip this entry.
             if (!$schedConf) {
                 $errors[] = "Unknown conference referenced in reviews: {$row['cf']}";
             } else {
                 unset($schedConf);
             }
             if (!$paper) {
                 $errors[] = "Unknown paper referenced in reviews: {$row['paper']}";
             } else {
                 unset($paper);
             }
             if (!$reviewer) {
                 $errors[] = "Unknown reviewer referenced in reviews: {$row['reviewer']}";
             } else {
                 unset($reviewer);
             }
             $result->MoveNext();
             continue;
         }
         $schedConfId = $schedConf->getId();
         $paperId = $paper->getId();
         $reviewerId = $reviewer->getId();
         $reviewAssignment = new ReviewAssignment();
         $reviewAssignment->setReviewerId($reviewerId);
         $reviewAssignment->setSubmissionId($paperId);
         $reviewAssignment->setRound(REVIEW_ROUND_ABSTRACT);
         // Won't always be accurate
         $reviewAssignment->setDateAssigned($row['timestamp']);
         $reviewAssignment->setDateNotified($row['timestamp']);
         $reviewAssignment->setDateConfirmed($row['timestamp']);
         $reviewAssignment->setDeclined(0);
         switch (trim(strtolower(array_shift(split("[\n\\.:]", $row['recommendation']))))) {
             case 'accept':
                 $reviewAssignment->setRecommendation(SUBMISSION_REVIEWER_RECOMMENDATION_ACCEPT);
                 $reviewAssignment->setDateCompleted($row['timestamp']);
                 break;
             case 'revise':
             case 'pending revisions':
             case 'accept with revisions':
                 $reviewAssignment->setRecommendation(SUBMISSION_REVIEWER_RECOMMENDATION_PENDING_REVISIONS);
                 $reviewAssignment->setDateCompleted($row['timestamp']);
                 break;
             case 'decline':
             case 'reject':
                 $reviewAssignment->setRecommendation(SUBMISSION_REVIEWER_RECOMMENDATION_DECLINE);
                 $reviewAssignment->setDateCompleted($row['timestamp']);
                 break;
             default:
                 // WARNING: We're not setting a recommendation here at all!
                 break;
         }
         $reviewId = $reviewAssignmentDao->insertReviewAssignment($reviewAssignment);
         $paperComment = new PaperComment();
         $paperComment->setCommentType(COMMENT_TYPE_PEER_REVIEW);
         $paperComment->setRoleId(ROLE_ID_REVIEWER);
         $paperComment->setPaperId($paperId);
         $paperComment->setAssocId($reviewId);
         $paperComment->setAuthorId($reviewerId);
         $paperComment->setCommentTitle('');
         $paperComment->setComments(Core::cleanVar($row['comments'] . "\n" . $row['recommendation']));
         $paperComment->setDatePosted($row['timestamp']);
         $paperComment->setViewable(0);
         $paperCommentDao->insertPaperComment($paperComment);
         unset($schedConf);
         unset($paper);
         unset($reviewer);
         unset($reviewAssignment);
         unset($paperComment);
         $result->MoveNext();
     }
     $result->Close();
 }

//.........这里部分代码省略.........
            foreach ($emailLogsXML as $emailLogXML) {
                $emailLog = new ArticleEmailLogEntry();
                $emailLog->setAssocType(ASSOC_TYPE_ARTICLE);
                $emailLog->setAssocId($article->getId());
                $emailLog->setSenderId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_USER, (int) $emailLogXML->senderId));
                $emailLog->setDateSent((string) $emailLogXML->dateSent);
                $emailLog->setIPAddress((string) $emailLogXML->IPAddress);
                $emailLog->setEventType((int) $emailLogXML->eventType);
                $emailLog->setFrom((string) $emailLogXML->from);
                $emailLog->setRecipients((string) $emailLogXML->recipients);
                $emailLog->setCcs((string) $emailLogXML->ccs);
                $emailLog->setBccs((string) $emailLogXML->bccs);
                $emailLog->setSubject((string) $emailLogXML->subject);
                $emailLog->setBody((string) $emailLogXML->body);
                $articleEmailLogDAO->insertObject($emailLog);
                $this->idTranslationTable->register(INTERNAL_TRANSFER_OBJECT_ARTICLE_EMAIL_LOG, (int) $emailLogXML->oldId, $emailLog->getId());
            }
            $articleFileDAO =& DAORegistry::getDAO('ArticleFileDAO');
            foreach ($articleXML->articleFile as $articleFileXML) {
                try {
                    $articleFile = new ArticleFile();
                    $articleFile->setArticleId($article->getId());
                    $articleFile->setSourceFileId((int) $articleFileXML->sourceFileId);
                    $articleFile->setSourceRevision((int) $articleFileXML->sourceRevision);
                    $articleFile->setRevision((int) $articleFileXML->revision);
                    $articleFile->setFileName((string) $articleFileXML->fileName);
                    $articleFile->setFileType((string) $articleFileXML->fileType);
                    $articleFile->setFileSize((string) $articleFileXML->fileSize);
                    $articleFile->setOriginalFileName((string) $articleFileXML->originalFileName);
                    $articleFile->setFileStage((int) $articleFileXML->fileStage);
                    $articleFile->setAssocId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_EMAIL_LOG, (int) $articleFileXML->assocId));
                    $articleFile->setDateUploaded((string) $articleFileXML->dateUploaded);
                    $articleFile->setDateModified((string) $articleFileXML->dateModified);
                    $articleFile->setRound((int) $articleFileXML->round);
                    $articleFile->setViewable((int) $articleFileXML->viewable);
                    $articleFileDAO->insertArticleFile($articleFile);
                    $oldArticleFileId = (int) $articleFileXML->oldId;
                    $oldFileName = $articleFile->getFileName();
                    $stagePath = $articleFileManager->fileStageToPath($articleFile->getFileStage());
                    $fileInTransferPackage = $this->journalFolderPath . "/articles/{$oldArticleId}/{$stagePath}/{$oldFileName}";
                    $newFileName = $articleFileManager->generateFilename($articleFile, $articleFile->getFileStage(), $articleFile->getOriginalFileName());
                    $newFilePath = "/articles/" . $article->getId() . "/{$stagePath}/{$newFileName}";
                    $journalFileManager->copyFile($fileInTransferPackage, $journalFileManager->filesDir . $newFilePath);
                    unlink($fileInTransferPackage);
                    $articleFileDAO->updateArticleFile($articleFile);
                    $this->idTranslationTable->register(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, $oldArticleFileId, $articleFile->getFileId());
                } catch (Exception $e) {
                }
            }
            $articleFiles = $articleFileDAO->getArticleFilesByArticle($article->getId());
            foreach ($articleFiles as $articleFile) {
                try {
                    $articleFile->setSourceFileId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, $articleFile->getSourceFileId()));
                    $articleFileDAO->updateArticleFile($articleFile);
                } catch (Exception $e) {
                }
            }
            $suppFileDAO =& DAORegistry::getDAO('SuppFileDAO');
            foreach ($articleXML->suppFile as $suppFileXML) {
                $suppFile =& new SuppFile();
                $suppFile->setArticleId($article->getId());
                $suppFile->setRemoteURL((string) $suppFileXML->remoteURL);
                $suppFile->setFileId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, (int) $suppFileXML->fileId));
                $suppFile->setType((string) $suppFileXML->type);
                $suppFile->setDateCreated((string) $suppFileXML->dateCreated);
                $suppFile->setLanguage((string) $suppFileXML->language);

 /**
  * Assigns a reviewer to a submission.
  * @param $request PKPRequest
  * @param $submission object
  * @param $reviewerId int
  * @param $reviewRound ReviewRound
  * @param $reviewDueDate datetime optional
  * @param $responseDueDate datetime optional
  */
 function addReviewer($request, $submission, $reviewerId, &$reviewRound, $reviewDueDate = null, $responseDueDate = null, $reviewMethod = null)
 {
     $reviewAssignmentDao = DAORegistry::getDAO('ReviewAssignmentDAO');
     $userDao = DAORegistry::getDAO('UserDAO');
     $reviewer = $userDao->getById($reviewerId);
     // Check to see if the requested reviewer is not already
     // assigned to review this submission.
     $assigned = $reviewAssignmentDao->reviewerExists($reviewRound->getId(), $reviewerId);
     // Only add the reviewer if he has not already
     // been assigned to review this submission.
     $stageId = $reviewRound->getStageId();
     $round = $reviewRound->getRound();
     if (!$assigned && isset($reviewer) && !HookRegistry::call('EditorAction::addReviewer', array(&$submission, $reviewerId))) {
         $reviewAssignment = new ReviewAssignment();
         $reviewAssignment->setSubmissionId($submission->getId());
         $reviewAssignment->setReviewerId($reviewerId);
         $reviewAssignment->setDateAssigned(Core::getCurrentDate());
         $reviewAssignment->setStageId($stageId);
         $reviewAssignment->setRound($round);
         $reviewAssignment->setReviewRoundId($reviewRound->getId());
         if (isset($reviewMethod)) {
             $reviewAssignment->setReviewMethod($reviewMethod);
         }
         $reviewAssignmentDao->insertObject($reviewAssignment);
         // Stamp modification date
         $submission->stampStatusModified();
         $submissionDao = Application::getSubmissionDAO();
         $submissionDao->updateObject($submission);
         $this->setDueDates($request, $submission, $reviewAssignment, $reviewDueDate, $responseDueDate);
         // Add notification
         $notificationMgr = new NotificationManager();
         $notificationMgr->createNotification($request, $reviewerId, NOTIFICATION_TYPE_REVIEW_ASSIGNMENT, $submission->getContextId(), ASSOC_TYPE_REVIEW_ASSIGNMENT, $reviewAssignment->getId(), NOTIFICATION_LEVEL_TASK);
         // Insert a trivial notification to indicate the reviewer was added successfully.
         $currentUser = $request->getUser();
         $notificationMgr = new NotificationManager();
         $notificationMgr->createTrivialNotification($currentUser->getId(), NOTIFICATION_TYPE_SUCCESS, array('contents' => __('notification.addedReviewer')));
         // Update the review round status.
         $reviewRoundDao = DAORegistry::getDAO('ReviewRoundDAO');
         /* @var $reviewRoundDao ReviewRoundDAO */
         $reviewAssignments = $reviewAssignmentDao->getBySubmissionId($submission->getId(), $reviewRound->getId(), $stageId);
         $reviewRoundDao->updateStatus($reviewRound, $reviewAssignments);
         $notificationMgr->updateNotification($request, array(NOTIFICATION_TYPE_ALL_REVIEWS_IN), null, ASSOC_TYPE_REVIEW_ROUND, $reviewRound->getId());
         // Add log
         import('lib.pkp.classes.log.SubmissionLog');
         import('lib.pkp.classes.log.PKPSubmissionEventLogEntry');
         SubmissionLog::logEvent($request, $submission, SUBMISSION_LOG_REVIEW_ASSIGN, 'log.review.reviewerAssigned', array('reviewerName' => $reviewer->getFullName(), 'submissionId' => $submission->getId(), 'stageId' => $stageId, 'round' => $round));
     }
 }

 /**
  * Assigns a reviewer to a submission.
  * @param $sectionEditorSubmission object
  * @param $reviewerId int
  */
 function addReviewer($sectionEditorSubmission, $reviewerId, $round = null)
 {
     $sectionEditorSubmissionDao =& DAORegistry::getDAO('SectionEditorSubmissionDAO');
     $reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
     $userDao =& DAORegistry::getDAO('UserDAO');
     $user =& Request::getUser();
     $reviewer =& $userDao->getUser($reviewerId);
     // Check to see if the requested reviewer is not already
     // assigned to review this article.
     if ($round == null) {
         $round = $sectionEditorSubmission->getCurrentRound();
     }
     $assigned = $sectionEditorSubmissionDao->reviewerExists($sectionEditorSubmission->getArticleId(), $reviewerId, $round);
     // Only add the reviewer if he has not already
     // been assigned to review this article.
     if (!$assigned && isset($reviewer) && !HookRegistry::call('SectionEditorAction::addReviewer', array(&$sectionEditorSubmission, $reviewerId))) {
         $reviewAssignment = new ReviewAssignment();
         $reviewAssignment->setReviewerId($reviewerId);
         $reviewAssignment->setDateAssigned(Core::getCurrentDate());
         $reviewAssignment->setRound($round);
         $reviewAssignment->setDateDue(SectionEditorAction::getReviewDueDate());
         // Assign review form automatically if needed
         $journalId = $sectionEditorSubmission->getJournalId();
         $sectionDao =& DAORegistry::getDAO('SectionDAO');
         $reviewFormDao =& DAORegistry::getDAO('ReviewFormDAO');
         $sectionId = $sectionEditorSubmission->getSectionId();
         $section =& $sectionDao->getSection($sectionId, $journalId);
         if ($section && ($reviewFormId = (int) $section->getReviewFormId())) {
             if ($reviewFormDao->reviewFormExists($reviewFormId, ASSOC_TYPE_JOURNAL, $journalId)) {
                 $reviewAssignment->setReviewFormId($reviewFormId);
             }
         }
         $sectionEditorSubmission->addReviewAssignment($reviewAssignment);
         $sectionEditorSubmissionDao->updateSectionEditorSubmission($sectionEditorSubmission);
         $reviewAssignment = $reviewAssignmentDao->getReviewAssignment($sectionEditorSubmission->getArticleId(), $reviewerId, $round);
         // Add log
         import('classes.article.log.ArticleLog');
         import('classes.article.log.ArticleEventLogEntry');
         ArticleLog::logEvent($sectionEditorSubmission->getArticleId(), ARTICLE_LOG_REVIEW_ASSIGN, ARTICLE_LOG_TYPE_REVIEW, $reviewAssignment->getId(), 'log.review.reviewerAssigned', array('reviewerName' => $reviewer->getFullName(), 'articleId' => $sectionEditorSubmission->getArticleId(), 'round' => $round));
     }
 }

 /**
  * Assigns a reviewer to a submission.
  * @param $trackDirectorSubmission object
  * @param $reviewerId int
  * @param $round int
  */
 function addReviewer($trackDirectorSubmission, $reviewerId, $round)
 {
     $trackDirectorSubmissionDao = DAORegistry::getDAO('TrackDirectorSubmissionDAO');
     $reviewAssignmentDao = DAORegistry::getDAO('ReviewAssignmentDAO');
     $userDao = DAORegistry::getDAO('UserDAO');
     $user =& Request::getUser();
     $reviewer =& $userDao->getById($reviewerId);
     // Check to see if the requested reviewer is not already
     // assigned to review this paper.
     if ($round == null) {
         $round = $trackDirectorSubmission->getCurrentRound();
     }
     $assigned = $trackDirectorSubmissionDao->reviewerExists($trackDirectorSubmission->getId(), $reviewerId, $round);
     // Only add the reviewer if he has not already
     // been assigned to review this paper.
     if (!$assigned && isset($reviewer) && !HookRegistry::call('TrackDirectorAction::addReviewer', array(&$trackDirectorSubmission, $reviewerId))) {
         $reviewAssignment = new ReviewAssignment();
         $reviewAssignment->setReviewerId($reviewerId);
         $reviewAssignment->setDateAssigned(Core::getCurrentDate());
         $reviewAssignment->setRound($round);
         // Assign review form automatically if needed
         $schedConfId = $trackDirectorSubmission->getSchedConfId();
         $schedConfDao = DAORegistry::getDAO('SchedConfDAO');
         $schedConf = $schedConfDao->getById($schedConfId);
         $conferenceId = $schedConf->getConferenceId();
         $trackDao = DAORegistry::getDAO('TrackDAO');
         $reviewFormDao = DAORegistry::getDAO('ReviewFormDAO');
         $trackId = $trackDirectorSubmission->getTrackId();
         $track =& $trackDao->getTrack($trackId, $conferenceId);
         if ($track && ($reviewFormId = (int) $track->getReviewFormId())) {
             if ($reviewFormDao->reviewFormExists($reviewFormId, ASSOC_TYPE_CONFERENCE, $conferenceId)) {
                 $reviewAssignment->setReviewFormId($reviewFormId);
             }
         }
         $trackDirectorSubmission->addReviewAssignment($reviewAssignment);
         $trackDirectorSubmissionDao->updateTrackDirectorSubmission($trackDirectorSubmission);
         $reviewAssignment = $reviewAssignmentDao->getReviewAssignment($trackDirectorSubmission->getId(), $reviewerId, $round);
         $schedConf =& Request::getSchedConf();
         if ($schedConf->getSetting('reviewDeadlineType') != null) {
             $dueDateSet = true;
             if ($schedConf->getSetting('reviewDeadlineType') == REVIEW_DEADLINE_TYPE_ABSOLUTE) {
                 $reviewDeadlineDate = $schedConf->getSetting('numWeeksPerReviewAbsolute');
                 $reviewDueDate = strftime(Config::getVar('general', 'date_format_short'), $reviewDeadlineDate);
                 TrackDirectorAction::setDueDate($trackDirectorSubmission->getId(), $reviewAssignment->getId(), $reviewDueDate, null, false);
             } elseif ($schedConf->getSetting('reviewDeadlineType') == REVIEW_DEADLINE_TYPE_RELATIVE) {
                 TrackDirectorAction::setDueDate($trackDirectorSubmission->getId(), $reviewAssignment->getId(), null, $schedConf->getSetting('numWeeksPerReviewRelative'), false);
             } else {
                 $dueDateSet = false;
             }
             if ($dueDateSet) {
                 $reviewAssignment = $reviewAssignmentDao->getReviewAssignment($trackDirectorSubmission->getId(), $reviewerId, $stage);
                 $trackDirectorSubmission->updateReviewAssignment($reviewAssignment);
                 $trackDirectorSubmissionDao->updateTrackDirectorSubmission($trackDirectorSubmission);
             }
         }
         // Add log
         import('classes.paper.log.PaperLog');
         import('classes.paper.log.PaperEventLogEntry');
         PaperLog::logEvent($trackDirectorSubmission->getId(), PAPER_LOG_REVIEW_ASSIGN, LOG_TYPE_REVIEW, $reviewAssignment->getId(), 'log.review.reviewerAssigned', array('reviewerName' => $reviewer->getFullName(), 'paperId' => $trackDirectorSubmission->getId(), 'stage' => $round));
     }
 }

 /**
  * Internal function to return a review assignment object from a row.
  * @param $row array
  * @return ReviewAssignment
  */
 function &_returnReviewAssignmentFromRow(&$row)
 {
     $reviewAssignment = new ReviewAssignment();
     $reviewAssignment->setId($row['review_id']);
     $reviewAssignment->setArticleId($row['article_id']);
     $reviewAssignment->setReviewerId($row['reviewer_id']);
     $reviewAssignment->setReviewerFullName($row['first_name'] . ' ' . $row['last_name']);
     $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->setLastModified($this->datetimeFromDB($row['last_modified']));
     $reviewAssignment->setDeclined($row['declined']);
     $reviewAssignment->setReplaced($row['replaced']);
     $reviewAssignment->setCancelled($row['cancelled']);
     $reviewAssignment->setReviewerFileId($row['reviewer_file_id']);
     $reviewAssignment->setQuality($row['quality']);
     $reviewAssignment->setDateRated($this->datetimeFromDB($row['date_rated']));
     $reviewAssignment->setDateReminded($this->datetimeFromDB($row['date_reminded']));
     $reviewAssignment->setReminderWasAutomatic($row['reminder_was_automatic']);
     $reviewAssignment->setRound($row['round']);
     $reviewAssignment->setReviewFileId($row['review_file_id']);
     $reviewAssignment->setReviewRevision($row['review_revision']);
     $reviewAssignment->setReviewFormId($row['review_form_id']);
     // Files
     $reviewAssignment->setReviewFile($this->articleFileDao->getArticleFile($row['review_file_id'], $row['review_revision']));
     $reviewAssignment->setReviewerFile($this->articleFileDao->getArticleFile($row['reviewer_file_id']));
     $reviewAssignment->setReviewerFileRevisions($this->articleFileDao->getArticleFileRevisions($row['reviewer_file_id']));
     $reviewAssignment->setSuppFiles($this->suppFileDao->getSuppFilesByArticle($row['article_id']));
     // Comments
     $reviewAssignment->setMostRecentPeerReviewComment($this->articleCommentDao->getMostRecentArticleComment($row['article_id'], COMMENT_TYPE_PEER_REVIEW, $row['review_id']));
     HookRegistry::call('ReviewAssignmentDAO::_returnReviewAssignmentFromRow', array(&$reviewAssignment, &$row));
     return $reviewAssignment;
 }