/**
* Display reviewer index page.
*/
function index($args)
{
ReviewerHandler::validate();
ReviewerHandler::setupTemplate();
$journal =& Request::getJournal();
$user =& Request::getUser();
$reviewerSubmissionDao =& DAORegistry::getDAO('ReviewerSubmissionDAO');
$rangeInfo = Handler::getRangeInfo('submissions');
$page = isset($args[0]) ? $args[0] : '';
switch ($page) {
case 'completed':
$active = false;
break;
default:
$page = 'active';
$active = true;
}
$submissions = $reviewerSubmissionDao->getReviewerSubmissionsByReviewerId($user->getUserId(), $journal->getJournalId(), $active, $rangeInfo);
$templateMgr =& TemplateManager::getManager();
$templateMgr->assign('reviewerRecommendationOptions', ReviewAssignment::getReviewerRecommendationOptions());
$templateMgr->assign('pageToDisplay', $page);
$templateMgr->assign_by_ref('submissions', $submissions);
import('submission.reviewAssignment.ReviewAssignment');
$templateMgr->assign_by_ref('reviewerRecommendationOptions', ReviewAssignment::getReviewerRecommendationOptions());
import('issue.IssueAction');
$issueAction =& new IssueAction();
$templateMgr->register_function('print_issue_id', array($issueAction, 'smartyPrintIssueId'));
$templateMgr->assign('helpTopicId', 'editorial.reviewersRole.submissions');
$templateMgr->display('reviewer/index.tpl');
}
/**
* Display reviewer index page.
*/
function index($args)
{
$this->validate();
$this->setupTemplate();
$schedConf =& Request::getSchedConf();
$user =& Request::getUser();
$reviewerSubmissionDao =& DAORegistry::getDAO('ReviewerSubmissionDAO');
$rangeInfo = Handler::getRangeInfo('submissions');
$page = isset($args[0]) ? $args[0] : '';
switch ($page) {
case 'completed':
$active = false;
break;
default:
$page = 'active';
$active = true;
}
$submissions = $reviewerSubmissionDao->getReviewerSubmissionsByReviewerId($user->getId(), $schedConf->getId(), $active, $rangeInfo);
$templateMgr =& TemplateManager::getManager();
$templateMgr->assign('reviewerRecommendationOptions', ReviewAssignment::getReviewerRecommendationOptions());
$templateMgr->assign('pageToDisplay', $page);
$templateMgr->assign_by_ref('submissions', $submissions);
$templateMgr->assign_by_ref('schedConf', $schedConf);
import('submission.reviewAssignment.ReviewAssignment');
$templateMgr->assign_by_ref('reviewerRecommendationOptions', ReviewAssignment::getReviewerRecommendationOptions());
$templateMgr->assign('helpTopicId', 'editorial.reviewersRole.submissions');
$templateMgr->display('reviewer/index.tpl');
}
/**
* Display the submission review page.
* @param $args array
*/
function submission($args, $request)
{
$journal =& $request->getJournal();
$reviewId = $args[0];
$this->validate($request, $reviewId);
$user =& $this->user;
$submission =& $this->submission;
$reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
$reviewAssignment = $reviewAssignmentDao->getById($reviewId);
$reviewFormResponseDao =& DAORegistry::getDAO('ReviewFormResponseDAO');
if ($submission->getDateConfirmed() == null) {
$confirmedStatus = 0;
} else {
$confirmedStatus = 1;
}
$this->setupTemplate(true, $reviewAssignment->getSubmissionId(), $reviewId);
$templateMgr =& TemplateManager::getManager();
$templateMgr->assign_by_ref('user', $user);
$templateMgr->assign_by_ref('submission', $submission);
$templateMgr->assign_by_ref('reviewAssignment', $reviewAssignment);
$templateMgr->assign('confirmedStatus', $confirmedStatus);
$templateMgr->assign('declined', $submission->getDeclined());
$templateMgr->assign('reviewFormResponseExists', $reviewFormResponseDao->reviewFormResponseExists($reviewId));
$templateMgr->assign_by_ref('reviewFile', $reviewAssignment->getReviewFile());
$templateMgr->assign_by_ref('reviewerFile', $submission->getReviewerFile());
$templateMgr->assign_by_ref('suppFiles', $submission->getSuppFiles());
$templateMgr->assign_by_ref('journal', $journal);
$templateMgr->assign_by_ref('reviewGuidelines', $journal->getLocalizedSetting('reviewGuidelines'));
import('classes.submission.reviewAssignment.ReviewAssignment');
$templateMgr->assign_by_ref('reviewerRecommendationOptions', ReviewAssignment::getReviewerRecommendationOptions());
$templateMgr->assign('helpTopicId', 'editorial.reviewersRole.review');
$templateMgr->display('reviewer/submission.tpl');
}
/**
* Display the submission review page.
* @param $args array
*/
function submission($args)
{
$journal =& Request::getJournal();
$reviewId = $args[0];
list($journal, $submission, $user) = SubmissionReviewHandler::validate($reviewId);
$reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
$reviewAssignment = $reviewAssignmentDao->getReviewAssignmentById($reviewId);
if ($submission->getDateConfirmed() == null) {
$confirmedStatus = 0;
} else {
$confirmedStatus = 1;
}
ReviewerHandler::setupTemplate(true, $reviewAssignment->getArticleId(), $reviewId);
$templateMgr =& TemplateManager::getManager();
$templateMgr->assign_by_ref('user', $user);
$templateMgr->assign_by_ref('submission', $submission);
$templateMgr->assign_by_ref('reviewAssignment', $reviewAssignment);
$templateMgr->assign('confirmedStatus', $confirmedStatus);
$templateMgr->assign('declined', $submission->getDeclined());
$templateMgr->assign_by_ref('reviewFile', $reviewAssignment->getReviewFile());
$templateMgr->assign_by_ref('reviewerFile', $submission->getReviewerFile());
$templateMgr->assign_by_ref('suppFiles', $submission->getSuppFiles());
$templateMgr->assign_by_ref('journal', $journal);
$templateMgr->assign_by_ref('reviewGuidelines', $journal->getLocalizedSetting('reviewGuidelines'));
import('submission.reviewAssignment.ReviewAssignment');
$templateMgr->assign_by_ref('reviewerRecommendationOptions', ReviewAssignment::getReviewerRecommendationOptions());
$templateMgr->assign('helpTopicId', 'editorial.reviewersRole.review');
$templateMgr->display('reviewer/submission.tpl');
}
/**
* Display the form.
*/
function display()
{
$press =& Request::getPress();
$user =& Request::getUser();
$submission = $this->reviewerSubmission;
$reviewFormResponseDao =& DAORegistry::getDAO('ReviewFormResponseDAO');
$reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
$reviewAssignment = $reviewAssignmentDao->getById($submission->getReviewId());
if ($submission->getDateConfirmed() == null) {
$confirmedStatus = 0;
} else {
$confirmedStatus = 1;
}
$templateMgr =& TemplateManager::getManager();
$reviewerRequestParams = array('reviewer' => $reviewAssignment->getReviewerFullName(), 'personalNote' => 'EDITOR NOTE', 'editor' => $press->getSetting('contactName'));
$templateMgr->assign('reviewerRequest', Locale::translate('reviewer.step1.requestBoilerplate', $reviewerRequestParams));
$templateMgr->assign_by_ref('submission', $submission);
$templateMgr->assign_by_ref('reviewAssignment', $reviewAssignment);
$templateMgr->assign_by_ref('press', $press);
$templateMgr->assign_by_ref('reviewGuidelines', $press->getLocalizedSetting('reviewGuidelines'));
$templateMgr->assign('step', 1);
$templateMgr->assign('completedSteps', $submission->getStatus());
$templateMgr->assign('blindReview', true);
// FIXME: Need to be able to get/set if a review is blind or not
// FIXME: Need press setting that denotes competing interests are required
$templateMgr->assign('competingInterestsText', $submission->getCompetingInterests());
import('classes.submission.reviewAssignment.ReviewAssignment');
$templateMgr->assign_by_ref('reviewerRecommendationOptions', ReviewAssignment::getReviewerRecommendationOptions());
$templateMgr->assign('helpTopicId', 'editorial.reviewersRole.review');
parent::display();
}
/**
* @see Form::fetch()
*/
function fetch($request)
{
$templateMgr = TemplateManager::getManager($request);
$reviewAssignment = $this->getReviewAssignment();
$reviewRoundId = $reviewAssignment->getReviewRoundId();
// Assign the objects and data to the template.
$context = $this->request->getContext();
$templateMgr->assign('reviewAssignment', $reviewAssignment);
$templateMgr->assign('reviewRoundId', $reviewRoundId);
// Include the review recommendation options on the form.
$templateMgr->assign_by_ref('reviewerRecommendationOptions', ReviewAssignment::getReviewerRecommendationOptions());
if ($reviewAssignment->getReviewFormId()) {
// Get the review form components
$reviewFormElementDao = DAORegistry::getDAO('ReviewFormElementDAO');
$reviewFormElements = $reviewFormElementDao->getByReviewFormId($reviewAssignment->getReviewFormId());
$reviewFormResponseDao = DAORegistry::getDAO('ReviewFormResponseDAO');
$reviewFormResponses = $reviewFormResponseDao->getReviewReviewFormResponseValues($reviewAssignment->getId());
$reviewFormDao = DAORegistry::getDAO('ReviewFormDAO');
$reviewformid = $reviewAssignment->getReviewFormId();
$reviewForm = $reviewFormDao->getById($reviewAssignment->getReviewFormId(), Application::getContextAssocType(), $context->getId());
$templateMgr->assign('reviewForm', $reviewForm);
$templateMgr->assign('reviewFormElements', $reviewFormElements);
$templateMgr->assign('reviewFormResponses', $reviewFormResponses);
$templateMgr->assign('disabled', isset($reviewAssignment) && $reviewAssignment->getDateCompleted() != null);
}
//
// Assign the link actions
//
if ($context->getLocalizedSetting('reviewGuidelines')) {
import('lib.pkp.controllers.confirmationModal.linkAction.ViewReviewGuidelinesLinkAction');
$viewReviewGuidelinesAction = new ViewReviewGuidelinesLinkAction($request, $reviewAssignment->getStageId());
$templateMgr->assign('viewGuidelinesAction', $viewReviewGuidelinesAction);
}
return parent::fetch($request);
}
/**
* Save review assignment
* @param $request PKPRequest
*/
function execute()
{
// Get the list of available files for this review.
$submissionFileDao = DAORegistry::getDAO('SubmissionFileDAO');
import('lib.pkp.classes.submission.SubmissionFile');
// File constants
$submissionFiles = $submissionFileDao->getLatestRevisionsByReviewRound($this->_reviewRound, SUBMISSION_FILE_REVIEW_FILE);
$selectedFiles = (array) $this->getData('selectedFiles');
// Revoke all, then grant selected.
$reviewFilesDao = DAORegistry::getDAO('ReviewFilesDAO');
$reviewFilesDao->revokeByReviewId($this->_reviewAssignment->getId());
foreach ($submissionFiles as $submissionFile) {
if (in_array($submissionFile->getFileId(), $selectedFiles)) {
$reviewFilesDao->grant($this->_reviewAssignment->getId(), $submissionFile->getFileId());
}
}
}
/**
* Display reviewer index page.
*/
function index($args)
{
$this->validate();
$this->setupTemplate();
$journal =& Request::getJournal();
//%CBP% redirect or set var as appropriate
$CBPPlatformDao =& DAORegistry::getDAO('CBPPlatformDAO');
$workshop = $CBPPlatformDao->getWorkshop($journal->getJournalId());
if ($workshop != "structured") {
$workshop = 1;
}
if ($workshop == 1) {
Request::redirect(Request::getRequestedJournalPath(), 'user');
}
$user =& Request::getUser();
$reviewerSubmissionDao =& DAORegistry::getDAO('ReviewerSubmissionDAO');
$rangeInfo = Handler::getRangeInfo('submissions');
$page = isset($args[0]) ? $args[0] : '';
switch ($page) {
case 'completed':
$active = false;
break;
default:
$page = 'active';
$active = true;
}
$sort = Request::getUserVar('sort');
$sort = isset($sort) ? $sort : 'title';
$sortDirection = Request::getUserVar('sortDirection');
if ($sort == 'decision') {
$submissions = $reviewerSubmissionDao->getReviewerSubmissionsByReviewerId($user->getId(), $journal->getId(), $active, $rangeInfo);
// Sort all submissions by status, which is too complex to do in the DB
$submissionsArray = $submissions->toArray();
$compare = create_function('$s1, $s2', 'return strcmp($s1->getMostRecentDecision(), $s2->getMostRecentDecision());');
usort($submissionsArray, $compare);
if ($sortDirection == SORT_DIRECTION_DESC) {
$submissionsArray = array_reverse($submissionsArray);
}
// Convert submission array back to an ItemIterator class
import('lib.pkp.classes.core.ArrayItemIterator');
$submissions =& ArrayItemIterator::fromRangeInfo($submissionsArray, $rangeInfo);
} else {
$submissions = $reviewerSubmissionDao->getReviewerSubmissionsByReviewerId($user->getId(), $journal->getId(), $active, $rangeInfo, $sort, $sortDirection);
}
$templateMgr =& TemplateManager::getManager();
$templateMgr->assign('reviewerRecommendationOptions', ReviewAssignment::getReviewerRecommendationOptions());
$templateMgr->assign('pageToDisplay', $page);
$templateMgr->assign_by_ref('submissions', $submissions);
import('classes.submission.reviewAssignment.ReviewAssignment');
$templateMgr->assign_by_ref('reviewerRecommendationOptions', ReviewAssignment::getReviewerRecommendationOptions());
import('classes.issue.IssueAction');
$issueAction = new IssueAction();
$templateMgr->register_function('print_issue_id', array($issueAction, 'smartyPrintIssueId'));
$templateMgr->assign('helpTopicId', 'editorial.reviewersRole.submissions');
$templateMgr->assign('sort', $sort);
$templateMgr->assign('sortDirection', $sortDirection);
$templateMgr->display('reviewer/index.tpl');
}
function display(&$args)
{
$request =& $this->getRequest();
$conference =& $request->getConference();
$schedConf =& $request->getSchedConf();
AppLocale::requireComponents(LOCALE_COMPONENT_APP_COMMON, LOCALE_COMPONENT_PKP_USER, LOCALE_COMPONENT_PKP_SUBMISSION, LOCALE_COMPONENT_APP_MANAGER);
header('content-type: text/comma-separated-values; charset=utf-8');
header('content-disposition: attachment; filename=reviews-' . date('Ymd') . '.csv');
$reviewReportDao = DAORegistry::getDAO('ReviewReportDAO');
list($commentsIterator, $reviewsIterator) = $reviewReportDao->getReviewReport($schedConf->getId());
$comments = array();
while ($row =& $commentsIterator->next()) {
if (isset($comments[$row['paper_id']][$row['author_id']])) {
$comments[$row['paper_id']][$row['author_id']] .= "; " . $row['comments'];
} else {
$comments[$row['paper_id']][$row['author_id']] = $row['comments'];
}
}
$yesnoMessages = array(0 => __('common.no'), 1 => __('common.yes'));
import('classes.schedConf.SchedConf');
$reviewTypes = array(REVIEW_MODE_ABSTRACTS_ALONE => __('manager.schedConfSetup.submissions.abstractsAlone'), REVIEW_MODE_BOTH_SEQUENTIAL => __('manager.schedConfSetup.submissions.bothSequential'), REVIEW_MODE_PRESENTATIONS_ALONE => __('manager.schedConfSetup.submissions.presentationsAlone'), REVIEW_MODE_BOTH_SIMULTANEOUS => __('manager.schedConfSetup.submissions.bothTogether'));
import('classes.submission.reviewAssignment.ReviewAssignment');
$recommendations = ReviewAssignment::getReviewerRecommendationOptions();
$columns = array('reviewRound' => __('submissions.reviewType'), 'paper' => __('paper.papers'), 'paperid' => __('paper.submissionId'), 'reviewerid' => __('plugins.reports.reviews.reviewerId'), 'reviewer' => __('plugins.reports.reviews.reviewer'), 'firstname' => __('user.firstName'), 'middlename' => __('user.middleName'), 'lastname' => __('user.lastName'), 'dateassigned' => __('plugins.reports.reviews.dateAssigned'), 'datenotified' => __('plugins.reports.reviews.dateNotified'), 'dateconfirmed' => __('plugins.reports.reviews.dateConfirmed'), 'datecompleted' => __('plugins.reports.reviews.dateCompleted'), 'datereminded' => __('plugins.reports.reviews.dateReminded'), 'declined' => __('submissions.declined'), 'cancelled' => __('common.cancelled'), 'recommendation' => __('reviewer.paper.recommendation'), 'comments' => __('comments.commentsOnPaper'));
$yesNoArray = array('declined', 'cancelled');
$fp = fopen('php://output', 'wt');
fputcsv($fp, array_values($columns));
while ($row =& $reviewsIterator->next()) {
foreach ($columns as $index => $junk) {
if (in_array($index, array('declined', 'cancelled'))) {
$yesNoIndex = $row[$index];
if (is_string($yesNoIndex)) {
// Accomodate Postgres boolean casting
$yesNoIndex = $yesNoIndex == "f" ? 0 : 1;
}
$columns[$index] = $yesnoMessages[$yesNoIndex];
} elseif ($index == 'reviewRound') {
$columns[$index] = $reviewTypes[$row[$index]];
} elseif ($index == "recommendation") {
$columns[$index] = !isset($row[$index]) ? __('common.none') : __($recommendations[$row[$index]]);
} elseif ($index == "comments") {
if (isset($comments[$row['paperid']][$row['reviewerid']])) {
$columns[$index] = html_entity_decode(strip_tags($comments[$row['paperid']][$row['reviewerid']]), ENT_QUOTES, 'UTF-8');
} else {
$columns[$index] = "";
}
} else {
$columns[$index] = $row[$index];
}
}
fputcsv($fp, $columns);
unset($row);
}
fclose($fp);
}
function display(&$args)
{
$journal =& Request::getJournal();
header('content-type: text/comma-separated-values');
header('content-disposition: attachment; filename=report.csv');
Locale::requireComponents(array(LOCALE_COMPONENT_PKP_SUBMISSION));
$reviewReportDao =& DAORegistry::getDAO('ReviewReportDAO');
list($commentsIterator, $reviewsIterator) = $reviewReportDao->getReviewReport($journal->getId());
$comments = array();
while ($row =& $commentsIterator->next()) {
if (isset($comments[$row['article_id']][$row['author_id']])) {
$comments[$row['article_id']][$row['author_id']] .= "; " . $row['comments'];
} else {
$comments[$row['article_id']][$row['author_id']] = $row['comments'];
}
}
$yesnoMessages = array(0 => Locale::translate('common.no'), 1 => Locale::translate('common.yes'));
import('submission.reviewAssignment.ReviewAssignment');
$recommendations = ReviewAssignment::getReviewerRecommendationOptions();
$columns = array('round' => Locale::translate('plugins.reports.reviews.round'), 'article' => Locale::translate('article.articles'), 'articleid' => Locale::translate('article.submissionId'), 'reviewerid' => Locale::translate('plugins.reports.reviews.reviewerId'), 'reviewer' => Locale::translate('plugins.reports.reviews.reviewer'), 'firstname' => Locale::translate('user.firstName'), 'middlename' => Locale::translate('user.middleName'), 'lastname' => Locale::translate('user.lastName'), 'dateassigned' => Locale::translate('plugins.reports.reviews.dateAssigned'), 'datenotified' => Locale::translate('plugins.reports.reviews.dateNotified'), 'dateconfirmed' => Locale::translate('plugins.reports.reviews.dateConfirmed'), 'datecompleted' => Locale::translate('plugins.reports.reviews.dateCompleted'), 'datereminded' => Locale::translate('plugins.reports.reviews.dateReminded'), 'declined' => Locale::translate('submissions.declined'), 'cancelled' => Locale::translate('common.cancelled'), 'recommendation' => Locale::translate('reviewer.article.recommendation'), 'comments' => Locale::translate('comments.commentsOnArticle'));
$yesNoArray = array('declined', 'cancelled');
$fp = fopen('php://output', 'wt');
String::fputcsv($fp, array_values($columns));
while ($row =& $reviewsIterator->next()) {
foreach ($columns as $index => $junk) {
if (in_array($index, $yesNoArray)) {
$columns[$index] = $yesnoMessages[$row[$index]];
} elseif ($index == "recommendation") {
$columns[$index] = !isset($row[$index]) ? Locale::translate('common.none') : Locale::translate($recommendations[$row[$index]]);
} elseif ($index == "comments") {
if (isset($comments[$row['articleid']][$row['reviewerid']])) {
$columns[$index] = $comments[$row['articleid']][$row['reviewerid']];
} else {
$columns[$index] = "";
}
} else {
$columns[$index] = $row[$index];
}
}
String::fputcsv($fp, $columns);
unset($row);
}
fclose($fp);
}
function submission($args, $request)
{
$reviewId = (int) array_shift($args);
$this->validate($request, $reviewId);
$reviewerSubmission =& $this->submission;
$user =& $this->user;
$schedConf =& $request->getSchedConf();
$reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
$reviewAssignment = $reviewAssignmentDao->getById($reviewId);
$reviewFormResponseDao =& DAORegistry::getDAO('ReviewFormResponseDAO');
if ($reviewAssignment->getDateConfirmed() == null) {
$confirmedStatus = 0;
} else {
$confirmedStatus = 1;
}
$this->setupTemplate($request, true, $reviewerSubmission->getId(), $reviewId);
$templateMgr =& TemplateManager::getManager();
$templateMgr->assign_by_ref('user', $user);
$templateMgr->assign_by_ref('submission', $reviewerSubmission);
$templateMgr->assign_by_ref('reviewAssignment', $reviewAssignment);
$templateMgr->assign('confirmedStatus', $confirmedStatus);
$templateMgr->assign('declined', $reviewerSubmission->getDeclined());
$templateMgr->assign('reviewFormResponseExists', $reviewFormResponseDao->reviewFormResponseExists($reviewId));
$templateMgr->assign_by_ref('reviewFile', $reviewAssignment->getReviewFile());
$templateMgr->assign_by_ref('reviewerFile', $reviewerSubmission->getReviewerFile());
$templateMgr->assign_by_ref('suppFiles', $reviewerSubmission->getSuppFiles());
$templateMgr->assign_by_ref('schedConf', $schedConf);
$templateMgr->assign_by_ref('reviewGuidelines', $schedConf->getLocalizedSetting('reviewGuidelines'));
// The reviewer instructions differ depending on what is reviewed, and when.
if ($reviewAssignment->getRound() == REVIEW_ROUND_ABSTRACT && $reviewerSubmission->getReviewMode() != REVIEW_MODE_BOTH_SIMULTANEOUS) {
$templateMgr->assign('reviewerInstruction3', 'reviewer.paper.downloadSubmissionAbstractOnly');
} else {
$templateMgr->assign('reviewerInstruction3', 'reviewer.paper.downloadSubmissionSubmission');
}
import('classes.submission.reviewAssignment.ReviewAssignment');
$templateMgr->assign_by_ref('reviewerRecommendationOptions', ReviewAssignment::getReviewerRecommendationOptions());
$controlledVocabDao =& DAORegistry::getDAO('ControlledVocabDAO');
$templateMgr->assign('sessionTypes', $controlledVocabDao->enumerateBySymbolic('sessionTypes', ASSOC_TYPE_SCHED_CONF, $schedConf->getId()));
$templateMgr->assign('helpTopicId', 'editorial.reviewersRole.review');
$templateMgr->display('reviewer/submission.tpl');
}
/**
* 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));
}
}
/**
* @see Form::fetch()
*/
function fetch($request)
{
$templateMgr = TemplateManager::getManager($request);
$reviewAssignment = $this->getReviewAssignment();
// Assign the objects and data to the template.
$context = $this->request->getContext();
$templateMgr->assign(array('reviewAssignment' => $reviewAssignment, 'reviewRoundId' => $reviewAssignment->getReviewRoundId(), 'reviewerRecommendationOptions' => ReviewAssignment::getReviewerRecommendationOptions()));
if ($reviewAssignment->getReviewFormId()) {
// Get the review form components
$reviewFormElementDao = DAORegistry::getDAO('ReviewFormElementDAO');
$reviewFormResponseDao = DAORegistry::getDAO('ReviewFormResponseDAO');
$reviewFormDao = DAORegistry::getDAO('ReviewFormDAO');
$templateMgr->assign(array('reviewForm' => $reviewFormDao->getById($reviewAssignment->getReviewFormId(), Application::getContextAssocType(), $context->getId()), 'reviewFormElements' => $reviewFormElementDao->getByReviewFormId($reviewAssignment->getReviewFormId()), 'reviewFormResponses' => $reviewFormResponseDao->getReviewReviewFormResponseValues($reviewAssignment->getId()), 'disabled' => isset($reviewAssignment) && $reviewAssignment->getDateCompleted() != null));
}
//
// Assign the link actions
//
import('lib.pkp.controllers.confirmationModal.linkAction.ViewReviewGuidelinesLinkAction');
$viewReviewGuidelinesAction = new ViewReviewGuidelinesLinkAction($request, $reviewAssignment->getStageId());
if ($viewReviewGuidelinesAction->getGuidelines()) {
$templateMgr->assign('viewGuidelinesAction', $viewReviewGuidelinesAction);
}
return parent::fetch($request);
}
/**
* Display reviewer index page.
*/
function index($args)
{
$this->validate();
$this->setupTemplate();
$schedConf =& Request::getSchedConf();
$user =& Request::getUser();
$reviewerSubmissionDao =& DAORegistry::getDAO('ReviewerSubmissionDAO');
$rangeInfo = Handler::getRangeInfo('submissions');
$page = isset($args[0]) ? $args[0] : '';
switch ($page) {
case 'completed':
AppLocale::requireComponents(array(LOCALE_COMPONENT_OCS_DIRECTOR));
$active = false;
break;
default:
$page = 'active';
$active = true;
}
$submissions = $reviewerSubmissionDao->getReviewerSubmissionsByReviewerId($user->getId(), $schedConf->getId(), $active, $rangeInfo);
$templateMgr =& TemplateManager::getManager();
$templateMgr->assign('reviewerRecommendationOptions', ReviewAssignment::getReviewerRecommendationOptions());
$templateMgr->assign('pageToDisplay', $page);
$templateMgr->assign_by_ref('submissions', $submissions);
$templateMgr->assign_by_ref('schedConf', $schedConf);
import('submission.reviewAssignment.ReviewAssignment');
$templateMgr->assign_by_ref('reviewerRecommendationOptions', ReviewAssignment::getReviewerRecommendationOptions());
$templateMgr->assign('helpTopicId', 'editorial.reviewersRole.submissions');
$sessionTypesArray = array();
$paperTypeDao = DAORegistry::getDAO('PaperTypeDAO');
$sessionTypes = $paperTypeDao->getPaperTypes($schedConf->getId());
while ($sessionType = $sessionTypes->next()) {
$sessionTypesArray[$sessionType->getId()] = $sessionType;
}
$templateMgr->assign('sessionTypes', $sessionTypesArray);
$templateMgr->display('reviewer/index.tpl');
}
/**
* Return the object representing the next row.
* @return object
*/
function &next()
{
$row =& parent::next();
if ($row == null) {
return $row;
}
$ret = array('articleId' => $row['article_id']);
$ret['dateSubmitted'] = $this->journalStatisticsDao->dateFromDB($row['date_submitted']);
$article =& $this->articleDao->getArticle($row['article_id']);
$ret['title'] = $article->getArticleTitle();
$section =& $this->getSection($row['section_id']);
$ret['section'] = $section->getSectionTitle();
// Author Names & Affiliations
$maxAuthors = $this->getMaxAuthors();
$ret['authors'] = $maxAuthors == 0 ? array() : array_fill(0, $maxAuthors, '');
$ret['affiliations'] = $maxAuthors == 0 ? array() : array_fill(0, $maxAuthors, '');
$ret['countries'] = $maxAuthors == 0 ? array() : array_fill(0, $maxAuthors, '');
$authors =& $this->authorDao->getAuthorsByArticle($row['article_id']);
$authorIndex = 0;
foreach ($authors as $author) {
$ret['authors'][$authorIndex] = $author->getFullName();
$ret['affiliations'][$authorIndex] = $author->getAffiliation();
$country = $author->getCountry();
if (!empty($country)) {
$ret['countries'][$authorIndex] = $this->countryDao->getCountry($country);
}
$authorIndex++;
}
if ($this->type === REPORT_TYPE_EDITOR) {
$user = null;
if ($row['editor_id']) {
$user =& $this->userDao->getUser($row['editor_id']);
}
$ret['editor'] = $user ? $user->getFullName() : '';
} else {
$editAssignments =& $this->editAssignmentDao->getEditAssignmentsByArticleId($row['article_id']);
$maxEditors = $this->getMaxEditors();
$ret['editors'] = $maxEditors == 0 ? array() : array_fill(0, $maxEditors, '');
$editorIndex = 0;
while ($editAssignment =& $editAssignments->next()) {
$ret['editors'][$editorIndex++] = $editAssignment->getEditorFullName();
}
}
// Reviewer Names
$ratingOptions =& ReviewAssignment::getReviewerRatingOptions();
if ($this->type === REPORT_TYPE_REVIEWER) {
$user = null;
if ($row['reviewer_id']) {
$user =& $this->userDao->getUser($row['reviewer_id']);
}
$ret['reviewer'] = $user ? $user->getFullName() : '';
if ($row['quality']) {
$ret['score'] = Locale::translate($ratingOptions[$row['quality']]);
} else {
$ret['score'] = '';
}
$ret['affiliation'] = $user ? $user->getAffiliation() : '';
} else {
$maxReviewers = $this->getMaxReviewers();
$ret['reviewers'] = $maxReviewers == 0 ? array() : array_fill(0, $maxReviewers, '');
$ret['scores'] = $maxReviewers == 0 ? array() : array_fill(0, $maxReviewers, '');
$ret['recommendations'] = $maxReviewers == 0 ? array() : array_fill(0, $maxReviewers, '');
$reviewAssignments =& $this->reviewAssignmentDao->getReviewAssignmentsByArticleId($row['article_id']);
$reviewerIndex = 0;
foreach ($reviewAssignments as $reviewAssignment) {
$reviewerId = $reviewAssignment->getReviewerId();
$ret['reviewers'][$reviewerIndex] = $reviewAssignment->getReviewerFullName();
$rating = $reviewAssignment->getQuality();
if ($rating != '') {
$ret['scores'][$reviewerIndex] = Locale::translate($ratingOptions[$rating]);
}
$recommendation = $reviewAssignment->getRecommendation();
if ($recommendation !== '' && $recommendation !== null) {
$recommendationOptions =& $reviewAssignment->getReviewerRecommendationOptions();
$ret['recommendations'][$reviewerIndex] = Locale::translate($recommendationOptions[$recommendation]);
}
$reviewerIndex++;
}
}
// Fetch the last editorial decision for this article.
$editorDecisions = $this->authorSubmissionDao->getEditorDecisions($row['article_id']);
$lastDecision = array_pop($editorDecisions);
if ($lastDecision) {
import('submission.sectionEditor.SectionEditorSubmission');
$decisionOptions =& SectionEditorSubmission::getEditorDecisionOptions();
$ret['decision'] = Locale::translate($decisionOptions[$lastDecision['decision']]);
$ret['dateDecided'] = $lastDecision['dateDecided'];
$decisionTime = strtotime($lastDecision['dateDecided']);
$submitTime = strtotime($ret['dateSubmitted']);
if ($decisionTime === false || $decisionTime === -1 || $submitTime === false || $submitTime === -1) {
$ret['daysToDecision'] = '';
} else {
$ret['daysToDecision'] = round(($decisionTime - $submitTime) / 3600 / 24);
}
} else {
$ret['decision'] = '';
$ret['daysToDecision'] = '';
$ret['dateDecided'] = '';
}
$ret['daysToPublication'] = '';
if ($row['pub_id']) {
$submitTime = strtotime($ret['dateSubmitted']);
$publishTime = strtotime($this->journalStatisticsDao->dateFromDB($row['date_published']));
if ($publishTime > $submitTime) {
// Imported documents can be published before
// they were submitted -- in this case, ignore
// this metric (as opposed to displaying
// negative numbers).
$ret['daysToPublication'] = round(($publishTime - $submitTime) / 3600 / 24);
}
}
$ret['status'] = $row['status'];
return $ret;
}
/**
* Records the reviewer's submission recommendation.
* @param $reviewId int
* @param $recommendation int
* @param $send boolean
*/
function recordRecommendation(&$reviewerSubmission, $recommendation, $send)
{
$reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
$userDao =& DAORegistry::getDAO('UserDAO');
// Check validity of selected recommendation
$reviewerRecommendationOptions =& ReviewAssignment::getReviewerRecommendationOptions();
if (!isset($reviewerRecommendationOptions[$recommendation])) {
return true;
}
$reviewAssignment =& $reviewAssignmentDao->getReviewAssignmentById($reviewerSubmission->getReviewId());
$reviewer =& $userDao->getUser($reviewAssignment->getReviewerId());
if (!isset($reviewer)) {
return true;
}
// Only record the reviewers recommendation if
// no recommendation has previously been submitted.
if ($reviewAssignment->getRecommendation() === null || $reviewAssignment->getRecommendation === '') {
import('mail.PaperMailTemplate');
$email = new PaperMailTemplate($reviewerSubmission, 'REVIEW_COMPLETE');
// Must explicitly set sender because we may be here on an access
// key, in which case the user is not technically logged in
$email->setFrom($reviewer->getEmail(), $reviewer->getFullName());
if (!$email->isEnabled() || $send && !$email->hasErrors()) {
HookRegistry::call('ReviewerAction::recordRecommendation', array(&$reviewerSubmission, &$email, $recommendation));
if ($email->isEnabled()) {
$email->setAssoc(PAPER_EMAIL_REVIEW_COMPLETE, PAPER_EMAIL_TYPE_REVIEW, $reviewerSubmission->getReviewId());
$email->send();
}
$reviewAssignment->setRecommendation($recommendation);
$reviewAssignment->setDateCompleted(Core::getCurrentDate());
$reviewAssignment->stampModified();
$reviewAssignmentDao->updateReviewAssignment($reviewAssignment);
// Add log
import('paper.log.PaperLog');
import('paper.log.PaperEventLogEntry');
$entry = new PaperEventLogEntry();
$entry->setPaperId($reviewAssignment->getPaperId());
$entry->setUserId($reviewer->getId());
$entry->setDateLogged(Core::getCurrentDate());
$entry->setEventType(PAPER_LOG_REVIEW_RECOMMENDATION);
$entry->setLogMessage('log.review.reviewRecommendationSet', array('reviewerName' => $reviewer->getFullName(), 'paperId' => $reviewAssignment->getPaperId(), 'stage' => $reviewAssignment->getStage()));
$entry->setAssocType(LOG_TYPE_REVIEW);
$entry->setAssocId($reviewAssignment->getId());
PaperLog::logEventEntry($reviewAssignment->getPaperId(), $entry);
} else {
if (!Request::getUserVar('continued')) {
$assignedDirectors = $email->toAssignedDirectors($reviewerSubmission->getPaperId());
$reviewingTrackDirectors = $email->toAssignedTrackDirectors($reviewerSubmission->getPaperId());
if (empty($assignedDirectors) && empty($reviewingTrackDirectors)) {
$schedConf =& Request::getSchedConf();
$email->addRecipient($schedConf->getSetting('contactEmail'), $schedConf->getSetting('contactName'));
$editorialContactName = $schedConf->getSetting('contactName');
} else {
if (!empty($reviewingTrackDirectors)) {
$editorialContact = array_shift($reviewingTrackDirectors);
} else {
$editorialContact = array_shift($assignedDirectors);
}
$editorialContactName = $editorialContact->getDirectorFullName();
}
$reviewerRecommendationOptions =& ReviewAssignment::getReviewerRecommendationOptions();
$email->assignParams(array('editorialContactName' => $editorialContactName, 'reviewerName' => $reviewer->getFullName(), 'paperTitle' => strip_tags($reviewerSubmission->getLocalizedTitle()), 'recommendation' => Locale::translate($reviewerRecommendationOptions[$recommendation])));
}
$email->displayEditForm(Request::url(null, null, 'reviewer', 'recordRecommendation'), array('reviewId' => $reviewerSubmission->getReviewId(), 'recommendation' => $recommendation));
return false;
}
}
return true;
}
/**
* 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();
}
/**
* Records the reviewer's submission recommendation.
* @param $reviewId int
* @param $recommendation int
* @param $send boolean
*/
function recordRecommendation(&$reviewAssignment, $recommendation, $send)
{
$reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
$reviewerSubmissionDao =& DAORegistry::getDAO('ReviewerSubmissionDAO');
$userDao =& DAORegistry::getDAO('UserDAO');
$reviewId = $reviewAssignment->getReviewId();
$reviewerSubmission =& $reviewerSubmissionDao->getReviewerSubmission($reviewId);
// Check validity of selected recommendation
$reviewerRecommendationOptions =& ReviewAssignment::getReviewerRecommendationOptions();
if (!isset($reviewerRecommendationOptions[$recommendation])) {
return true;
}
$reviewer =& $userDao->getUser($reviewAssignment->getReviewerId());
if (!isset($reviewer)) {
return true;
}
// Only record the reviewers recommendation if
// no recommendation has previously been submitted.
if ($reviewAssignment->getRecommendation() === null || $reviewAssignment->getRecommendation === '') {
import('classes.mail.ArticleMailTemplate');
$email = new ArticleMailTemplate($reviewerSubmission, null, 'REVIEW_COMPLETE');
// Must explicitly set sender because we may be here on an access
// key, in which case the user is not technically logged in
$email->setFrom($reviewer->getEmail(), $reviewer->getFullName());
if (!$email->isEnabled() || $send && !$email->hasErrors()) {
HookRegistry::call('ReviewerAction::recordRecommendation', array(&$reviewerSubmission, &$email, $recommendation));
if ($email->isEnabled()) {
$email->setAssoc(ARTICLE_EMAIL_REVIEW_COMPLETE, ARTICLE_EMAIL_TYPE_REVIEW, $reviewId);
$email->send();
}
$reviewAssignment->setRecommendation($recommendation);
$reviewAssignment->setDateCompleted(Core::getCurrentDate());
$reviewAssignment->stampModified();
$reviewAssignmentDao->updateReviewAssignment($reviewAssignment);
// Add log
import('classes.article.log.ArticleLog');
import('classes.article.log.ArticleEventLogEntry');
$entry = new ArticleEventLogEntry();
$entry->setArticleId($reviewerSubmission->getArticleId());
$entry->setUserId($reviewer->getId());
$entry->setDateLogged(Core::getCurrentDate());
$entry->setEventType(ARTICLE_LOG_REVIEW_RECOMMENDATION);
$entry->setLogLevel('N');
$entry->setLogMessage('log.review.reviewRecommendationSet', array('reviewerName' => $reviewer->getFullName(), 'articleId' => $reviewerSubmission->getProposalId()));
$entry->setAssocType(ARTICLE_LOG_TYPE_REVIEW);
$entry->setAssocId($reviewAssignment->getId());
ArticleLog::logEventEntry($reviewerSubmission->getArticleId(), $entry);
} else {
if (!Request::getUserVar('continued')) {
$assignedEditors = $email->ccAssignedEditors($reviewerSubmission->getArticleId());
$reviewingSectionEditors = $email->toAssignedReviewingSectionEditors($reviewerSubmission->getArticleId());
if (empty($assignedEditors) && empty($reviewingSectionEditors)) {
$journal =& Request::getJournal();
$email->addRecipient($journal->getSetting('contactEmail'), $journal->getSetting('contactName'));
$editorialContactName = $journal->getSetting('contactName');
} else {
if (!empty($reviewingSectionEditors)) {
$editorialContact = array_shift($reviewingSectionEditors);
} else {
$editorialContact = array_shift($assignedEditors);
}
// Modified by EL on February 17th 2013
// No edit assigment anymore
$editorialContactName = $editorialContact->getFullName();
}
$reviewerRecommendationOptions =& ReviewAssignment::getReviewerRecommendationOptions();
$email->assignParams(array('editorialContactName' => $editorialContactName, 'reviewerName' => $reviewer->getFullName(), 'articleTitle' => strip_tags($reviewerSubmission->getScientificTitle()), 'recommendation' => Locale::translate($reviewerRecommendationOptions[$recommendation])));
}
$email->displayEditForm(Request::url(null, 'reviewer', 'recordRecommendation'), array('reviewId' => $reviewId, 'recommendation' => $recommendation));
return false;
}
}
return true;
}
function enterReviewerRecommendation($args, $request)
{
$paperId = (int) $request->getUserVar('paperId');
$reviewId = (int) $request->getUserVar('reviewId');
$recommendation = (int) $request->getUserVar('recommendation');
$this->validate($request, $paperId, TRACK_DIRECTOR_ACCESS_REVIEW);
$conference =& $request->getConference();
$schedConf =& $request->getSchedConf();
$submission =& $this->submission;
if ($recommendation != null) {
TrackDirectorAction::setReviewerRecommendation($paperId, $reviewId, $recommendation, SUBMISSION_REVIEWER_RECOMMENDATION_ACCEPT);
$request->redirect(null, null, null, 'submissionReview', $paperId);
} else {
$this->setupTemplate($request, true, $paperId, 'review');
$templateMgr =& TemplateManager::getManager();
$templateMgr->assign('paperId', $paperId);
$templateMgr->assign('reviewId', $reviewId);
import('classes.submission.reviewAssignment.ReviewAssignment');
$templateMgr->assign_by_ref('reviewerRecommendationOptions', ReviewAssignment::getReviewerRecommendationOptions());
$templateMgr->display('trackDirector/reviewerRecommendation.tpl');
}
}
/**
* Enter a reviewer recommendation on behalf of a reviewer
* @param $args array
* @param $request PKPRequest
*/
function enterReviewerRecommendation($args, &$request)
{
$articleId = $request->getUserVar('articleId');
$this->validate($articleId, SECTION_EDITOR_ACCESS_REVIEW);
$submission =& $this->submission;
$reviewId = $request->getUserVar('reviewId');
$recommendation = $request->getUserVar('recommendation');
if ($recommendation != null) {
SectionEditorAction::setReviewerRecommendation($this->submission, $reviewId, $recommendation, SUBMISSION_REVIEWER_RECOMMENDATION_ACCEPT, $request);
$request->redirect(null, null, 'submissionReview', $articleId);
} else {
$this->setupTemplate(true, $articleId, 'review');
$templateMgr =& TemplateManager::getManager();
$templateMgr->assign('articleId', $articleId);
$templateMgr->assign('reviewId', $reviewId);
import('classes.submission.reviewAssignment.ReviewAssignment');
$templateMgr->assign_by_ref('reviewerRecommendationOptions', ReviewAssignment::getReviewerRecommendationOptions());
$templateMgr->display('sectionEditor/reviewerRecommendation.tpl');
}
}
/**
* 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));
}
}
/**
* 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->setPaperId($row['paper_id']);
$reviewAssignment->setReviewerId($row['reviewer_id']);
$reviewAssignment->setReviewerFullName($row['first_name'] . ' ' . $row['last_name']);
$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->setStage($row['stage']);
$reviewAssignment->setReviewFileId($row['review_file_id']);
$reviewAssignment->setReviewRevision($row['review_revision']);
$reviewAssignment->setReviewFormId($row['review_form_id']);
// Files
$reviewAssignment->setReviewFile($this->paperFileDao->getPaperFile($row['review_file_id'], $row['review_revision']));
$reviewAssignment->setReviewerFile($this->paperFileDao->getPaperFile($row['reviewer_file_id']));
$reviewAssignment->setReviewerFileRevisions($this->paperFileDao->getPaperFileRevisions($row['reviewer_file_id']));
$reviewAssignment->setSuppFiles($this->suppFileDao->getSuppFilesByPaper($row['paper_id']));
// Comments
$reviewAssignment->setMostRecentPeerReviewComment($this->paperCommentDao->getMostRecentPaperComment($row['paper_id'], COMMENT_TYPE_PEER_REVIEW, $row['review_id']));
HookRegistry::call('ReviewAssignmentDAO::_returnReviewAssignmentFromRow', array(&$reviewAssignment, &$row));
return $reviewAssignment;
}
/**
* Assigns a reviewer to a submission.
* @param $sectionEditorSubmission object
* @param $reviewerId int
*/
function addReviewer($lastSectionDecisionId, $reviewerId)
{
$sectionDecisionDao =& DAORegistry::getDAO('SectionDecisionDAO');
$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.
$lastSectionDecision =& $sectionDecisionDao->getSectionDecision($lastSectionDecisionId);
$assigned = $sectionDecisionDao->reviewerExists($lastSectionDecision->getId(), $reviewerId);
// Only add the reviewer if he has not already
// been assigned to review this article.
if (!$assigned && isset($reviewer) && !HookRegistry::call('SectionEditorAction::addReviewer', array(&$lastSectionDecision, $reviewerId))) {
$reviewAssignment = new ReviewAssignment();
$reviewAssignment->setReviewerId($reviewerId);
$reviewAssignment->setDateAssigned(Core::getCurrentDate());
// Assign review form automatically if needed
$journal =& Request::getJournal();
$sectionDao =& DAORegistry::getDAO('SectionDAO');
$reviewFormDao =& DAORegistry::getDAO('ReviewFormDAO');
$sectionId = $lastSectionDecision->getSectionId();
$section =& $sectionDao->getSection($sectionId, $journal->getId());
if ($section && ($reviewFormId = (int) $section->getReviewFormId())) {
if ($reviewFormDao->reviewFormExists($reviewFormId, ASSOC_TYPE_JOURNAL, $journal->getId())) {
$reviewAssignment->setReviewFormId($reviewFormId);
}
}
$lastSectionDecision->addReviewAssignment($reviewAssignment);
$sectionDecisionDao->updateSectionDecision($lastSectionDecision);
$reviewAssignment = $reviewAssignmentDao->getReviewAssignment($lastSectionDecision->getId(), $reviewerId);
$settingsDao =& DAORegistry::getDAO('JournalSettingsDAO');
$settings =& $settingsDao->getJournalSettings($journal->getId());
if (isset($settings['numWeeksPerReview'])) {
SectionEditorAction::setDueDate($lastSectionDecision->getArticleId(), $reviewAssignment->getId(), null, $settings['numWeeksPerReview'], false);
}
// Add log
import('classes.article.log.ArticleLog');
import('classes.article.log.ArticleEventLogEntry');
Locale::requireComponents(array(LOCALE_COMPONENT_APPLICATION_COMMON));
ArticleLog::logEvent($lastSectionDecision->getArticleId(), ARTICLE_LOG_REVIEW_ASSIGN, ARTICLE_LOG_TYPE_REVIEW, $reviewAssignment->getId(), 'log.review.reviewerAssigned', array('reviewerName' => $reviewer->getFullName(), 'articleId' => $lastSectionDecision->getProposalId()));
}
}
/**
* 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));
}
}
/**
* Retrieve a formatted HTML string that displays the state of the review
* with the review recommendation if one exists. Or return just the state.
* Only works with some states.
*
* @param string $statusKey Locale key for status text
* @param ReviewAssignment $reviewAssignment
* @return string
*/
function _getStatusWithRecommendation($statusKey, $reviewAssignment)
{
if (!$reviewAssignment->getRecommendation()) {
return __($statusKey);
}
return '<span class="state">' . __($statusKey) . '</span><span class="details">' . __('submission.recommendation', array('recommendation' => $reviewAssignment->getLocalizedRecommendation())) . '</span>';
}
/**
* Open a modal to read the reviewer's review and
* download any files they may have uploaded
* @param $args array
* @param $request PKPRequest
* @return JSONMessage JSON object
*/
function readReview($args, $request)
{
$templateMgr = TemplateManager::getManager($request);
$reviewAssignment = $this->getAuthorizedContextObject(ASSOC_TYPE_REVIEW_ASSIGNMENT);
$templateMgr->assign(array('submission' => $this->getSubmission(), 'reviewAssignment' => $reviewAssignment, 'reviewerRecommendationOptions' => ReviewAssignment::getReviewerRecommendationOptions()));
if ($reviewAssignment->getReviewFormId()) {
// Retrieve review form
$context = $request->getContext();
$reviewFormElementDao = DAORegistry::getDAO('ReviewFormElementDAO');
$reviewFormElements = $reviewFormElementDao->getByReviewFormId($reviewAssignment->getReviewFormId());
$reviewFormResponseDao = DAORegistry::getDAO('ReviewFormResponseDAO');
$reviewFormResponses = $reviewFormResponseDao->getReviewReviewFormResponseValues($reviewAssignment->getId());
$reviewFormDao = DAORegistry::getDAO('ReviewFormDAO');
$reviewformid = $reviewAssignment->getReviewFormId();
$reviewForm = $reviewFormDao->getById($reviewAssignment->getReviewFormId(), Application::getContextAssocType(), $context->getId());
$templateMgr->assign(array('reviewForm' => $reviewForm, 'reviewFormElements' => $reviewFormElements, 'reviewFormResponses' => $reviewFormResponses, 'disabled' => true));
} else {
// Retrieve reviewer comments.
$submissionCommentDao = DAORegistry::getDAO('SubmissionCommentDAO');
$templateMgr->assign(array('comments' => $submissionCommentDao->getReviewerCommentsByReviewerId($reviewAssignment->getSubmissionId(), null, $reviewAssignment->getId(), true), 'commentsPrivate' => $submissionCommentDao->getReviewerCommentsByReviewerId($reviewAssignment->getSubmissionId(), null, $reviewAssignment->getId(), false)));
}
// Render the response.
return $templateMgr->fetchJson('controllers/grid/users/reviewer/readReview.tpl');
}
function enterReviewerRecommendation($args)
{
$articleId = Request::getUserVar('articleId');
list($journal, $submission) = SubmissionEditHandler::validate($articleId, SECTION_EDITOR_ACCESS_REVIEW);
$reviewId = Request::getUserVar('reviewId');
$recommendation = Request::getUserVar('recommendation');
if ($recommendation != null) {
SectionEditorAction::setReviewerRecommendation($articleId, $reviewId, $recommendation, SUBMISSION_REVIEWER_RECOMMENDATION_ACCEPT);
Request::redirect(null, null, 'submissionReview', $articleId);
} else {
parent::setupTemplate(true, $articleId, 'review');
$templateMgr =& TemplateManager::getManager();
$templateMgr->assign('articleId', $articleId);
$templateMgr->assign('reviewId', $reviewId);
import('submission.reviewAssignment.ReviewAssignment');
$templateMgr->assign_by_ref('reviewerRecommendationOptions', ReviewAssignment::getReviewerRecommendationOptions());
$templateMgr->display('sectionEditor/reviewerRecommendation.tpl');
}
}
function importArticles()
{
assert($this->xml->name == 'articles');
$articleDAO =& DAORegistry::getDAO('ArticleDAO');
$articles = $articleDAO->getArticlesByJournalId($this->journal->getId());
$journalFileManager = new JournalFileManager($this->journal);
$publicFileManager =& new PublicFileManager();
$this->nextElement();
while ($this->xml->name == 'article') {
$articleXML = $this->getCurrentElementAsDom();
$article = new Article();
$article->setJournalId($this->journal->getId());
$article->setUserId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_USER, (int) $articleXML->userId));
$article->setSectionId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_SECTION, (int) $articleXML->sectionId));
$article->setLocale((string) $articleXML->locale);
$article->setLanguage((string) $articleXML->language);
$article->setCommentsToEditor((string) $articleXML->commentsToEditor);
$article->setCitations((string) $articleXML->citations);
$article->setDateSubmitted((string) $articleXML->dateSubmitted);
$article->setDateStatusModified((string) $articleXML->dateStatusModified);
$article->setLastModified((string) $articleXML->lastModified);
$article->setStatus((int) $articleXML->status);
$article->setSubmissionProgress((int) $articleXML->submissionProgress);
$article->setCurrentRound((int) $articleXML->currentRound);
$article->setPages((string) $articleXML->pages);
$article->setFastTracked((int) $articleXML->fastTracked);
$article->setHideAuthor((int) $articleXML->hideAuthor);
$article->setCommentsStatus((int) $articleXML->commentsStatus);
$articleDAO->insertArticle($article);
$oldArticleId = (int) $articleXML->oldId;
$this->restoreDataObjectSettings($articleDAO, $articleXML->settings, 'article_settings', 'article_id', $article->getId());
$article =& $articleDAO->getArticle($article->getId());
// Reload article with restored settings
$covers = $article->getFileName(null);
if ($covers) {
foreach ($covers as $locale => $oldCoverFileName) {
$sourceFile = $this->publicFolderPath . '/' . $oldCoverFileName;
$extension = $publicFileManager->getExtension($oldCoverFileName);
$destFile = 'cover_issue_' . $article->getId() . "_{$locale}.{$extension}";
$publicFileManager->copyJournalFile($this->journal->getId(), $sourceFile, $destFile);
unlink($sourceFile);
$article->setFileName($destFile, $locale);
$articleDAO->updateArticle($article);
}
}
$articleFileManager = new ArticleFileManager($article->getId());
$authorDAO =& DAORegistry::getDAO('AuthorDAO');
foreach ($articleXML->author as $authorXML) {
$author = new Author();
$author->setArticleId($article->getId());
$author->setFirstName((string) $authorXML->firstName);
$author->setMiddleName((string) $authorXML->middleName);
$author->setLastName((string) $authorXML->lastName);
$author->setSuffix((string) $authorXML->suffix);
$author->setCountry((string) $authorXML->country);
$author->setEmail((string) $authorXML->email);
$author->setUrl((string) $authorXML->url);
$author->setUserGroupId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_GROUP, (int) $authorXML->userGroupId));
$author->setPrimaryContact((int) $authorXML->primaryContact);
$author->setSequence((int) $authorXML->sequence);
$authorDAO->insertAuthor($author);
$this->restoreDataObjectSettings($authorDAO, $authorXML->settings, 'author_settings', 'author_id', $author->getId());
unset($author);
}
$articleEmailLogDAO =& DAORegistry::getDAO('ArticleEmailLogDAO');
$emailLogsXML = array();
foreach ($articleXML->emailLogs->emailLog as $emailLogXML) {
array_unshift($emailLogsXML, $emailLogXML);
}
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);
$suppFile->setShowReviewers((int) $suppFileXML->showReviewers);
$suppFile->setDateSubmitted((string) $suppFileXML->dateSubmitted);
$suppFile->setSequence((int) $suppFileXML->sequence);
$suppFileDAO->insertSuppFile($suppFile);
$this->restoreDataObjectSettings($suppFileDAO, $suppFileXML->settings, 'article_supp_file_settings', 'supp_id', $suppFile->getId());
}
$articleCommentDAO =& DAORegistry::getDAO('ArticleCommentDAO');
foreach ($articleXML->articleComment as $articleCommentXML) {
$articleComment = new ArticleComment();
$articleComment->setArticleId($article->getId());
$articleComment->setAssocId($article->getId());
$articleComment->setCommentType((int) $articleCommentXML->commentType);
$articleComment->setRoleId((int) $articleCommentXML->roleId);
$articleComment->setAuthorId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_USER, (int) $articleCommentXML->authorId));
$articleComment->setCommentTitle((string) $articleCommentXML->commentTitle);
$articleComment->setComments((string) $articleCommentXML->comments);
$articleComment->setDatePosted((string) $articleCommentXML->datePosted);
$articleComment->setDateModified((string) $articleCommentXML->dateModified);
$articleComment->setViewable((int) $articleCommentXML->viewable);
$articleCommentDAO->insertArticleComment($articleComment);
}
$articleGalleyDAO =& DAORegistry::getDAO('ArticleGalleyDAO');
foreach ($articleXML->articleGalley as $articleGalleyXML) {
$articleGalley = null;
if ($articleGalleyXML->htmlGalley == "1") {
$articleGalley = new ArticleHTMLGalley();
} else {
$articleGalley = new ArticleGalley();
}
$articleGalley->setArticleId($article->getId());
$articleGalley->setLocale((string) $articleGalleyXML->locale);
$articleGalley->setFileId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, (int) $articleGalleyXML->fileId));
$articleGalley->setLabel((string) $articleGalleyXML->label);
$articleGalley->setSequence((int) $articleGalleyXML->sequence);
$articleGalley->setRemoteURL((string) $articleGalleyXML->remoteURL);
if ($articleGalley instanceof ArticleHTMLGalley) {
$articleGalley->setStyleFileId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, (int) $articleGalleyXML->styleFileId));
}
$articleGalleyDAO->insertGalley($articleGalley);
if ($articleGalley instanceof ArticleHTMLGalley) {
foreach ($articleGalleyXML->htmlGalleyImage as $articleGalleyImageXML) {
$imageId = $this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, (int) $articleGalleyImageXML);
$articleGalleyDAO->insertGalleyImage($articleGalley->getId(), $imageId);
}
}
$this->restoreDataObjectSettings($articleGalleyDAO, $articleGalleyXML->settings, 'article_galley_settings', 'galley_id', $articleGalley->getId());
}
$noteDAO =& DAORegistry::getDAO('NoteDAO');
foreach ($articleXML->articleNote as $articleNoteXML) {
$articleNote = new Note();
$articleNote->setUserId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_USER, (int) $articleNoteXML->userId));
$articleNote->setFileId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, (int) $articleNoteXML->fileId));
$articleNote->setAssocType(ASSOC_TYPE_ARTICLE);
$articleNote->setAssocId($article->getId());
$articleNote->setDateCreated((string) $articleNoteXML->dateCreated);
$articleNote->setDateModified((string) $articleNoteXML->dateModified);
$articleNote->setContents((string) $articleNoteXML->contents);
$articleNote->setTitle((string) $articleNoteXML->title);
$noteDAO->insertObject($articleNote);
}
$editAssignmentDAO =& DAORegistry::getDAO('EditAssignmentDAO');
foreach ($articleXML->editAssignment as $editAssignmentXML) {
$editAssignment = new EditAssignment();
$editAssignment->setArticleId($article->getId());
$editAssignment->setEditorId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_USER, (int) $editAssignmentXML->editorId));
$editAssignment->setCanReview((int) $editAssignmentXML->canReview);
$editAssignment->setCanEdit((int) $editAssignmentXML->canEdit);
$editAssignment->setDateUnderway((string) $editAssignmentXML->dateUnderway);
$editAssignment->setDateNotified((string) $editAssignmentXML->dateNotified);
$editAssignmentDAO->insertEditAssignment($editAssignment);
}
$reviewAssignmentDAO =& DAORegistry::getDAO('ReviewAssignmentDAO');
$reviewFormResponseDAO =& DAORegistry::getDAO('ReviewFormResponseDAO');
foreach ($articleXML->reviewAssignment as $reviewAssignmentXML) {
$reviewAssignment = new ReviewAssignment();
$reviewAssignment->setSubmissionId($article->getId());
$reviewAssignment->setReviewerId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_USER, (int) $reviewAssignmentXML->reviewerId));
try {
$reviewAssignment->setReviewerFileId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, (int) $reviewAssignmentXML->reviewerFileId));
} catch (Exception $e) {
$this->logger->log("Arquivo do artigo {$oldArticleId} não encontrado. ID: " . (int) $reviewAssignmentXML->reviewerFileId . "\n");
}
$reviewAssignment->setReviewFormId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_REVIEW_FORM, (int) $reviewAssignmentXML->reviewFormId));
$reviewAssignment->setReviewRoundId((int) $reviewAssignmentXML->reviewRoundId);
$reviewAssignment->setStageId((int) $reviewAssignmentXML->stageId);
$reviewAssignment->setReviewerFullName((string) $reviewAssignmentXML->reviewerFullName);
$reviewAssignment->setCompetingInterests((string) $reviewAssignmentXML->competingInterests);
$reviewAssignment->setRegretMessage((string) $reviewAssignmentXML->regretMessage);
$reviewAssignment->setRecommendation((string) $reviewAssignmentXML->recommendation);
$reviewAssignment->setDateAssigned((string) $reviewAssignmentXML->dateAssigned);
$reviewAssignment->setDateNotified((string) $reviewAssignmentXML->dateNotified);
$reviewAssignment->setDateConfirmed((string) $reviewAssignmentXML->dateConfirmed);
$reviewAssignment->setDateCompleted((string) $reviewAssignmentXML->dateCompleted);
$reviewAssignment->setDateAcknowledged((string) $reviewAssignmentXML->dateAcknowledged);
$reviewAssignment->setDateDue((string) $reviewAssignmentXML->dateDue);
$reviewAssignment->setDateResponseDue((string) $reviewAssignmentXML->dateResponseDue);
$reviewAssignment->setLastModified((string) $reviewAssignmentXML->lastModified);
$reviewAssignment->setDeclined((int) $reviewAssignmentXML->declined);
$reviewAssignment->setReplaced((int) $reviewAssignmentXML->replaced);
$reviewAssignment->setCancelled((int) $reviewAssignmentXML->cancelled);
$reviewAssignment->setQuality((int) $reviewAssignmentXML->quality);
$reviewAssignment->setDateRated((string) $reviewAssignmentXML->dateRated);
$reviewAssignment->setDateReminded((string) $reviewAssignmentXML->dateReminded);
$reviewAssignment->setReminderWasAutomatic((int) $reviewAssignmentXML->reminderWasAutomatic);
$reviewAssignment->setRound((int) $reviewAssignmentXML->round);
$reviewAssignment->setReviewRevision((int) $reviewAssignmentXML->reviewRevision);
$reviewAssignment->setReviewMethod((int) $reviewAssignmentXML->reviewMethod);
$reviewAssignment->setUnconsidered((int) $reviewAssignmentXML->unconsidered);
$reviewAssignmentDAO->insertObject($reviewAssignment);
foreach ($reviewAssignmentXML->formResponses->formResponse as $formResponseXML) {
$reviewFormResponseDAO->update('INSERT INTO review_form_responses
(review_form_element_id, review_id, response_type, response_value)
VALUES
(?, ?, ?, ?)', array($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_REVIEW_FORM_ELEMENT, (int) $formResponseXML->reviewFormElementId), $reviewAssignment->getId(), (string) $formResponseXML->responseType, (string) $formResponseXML->responseValue));
}
}
$signoffDAO =& DAORegistry::getDAO('SignoffDAO');
foreach ($articleXML->signoff as $signoffXML) {
$signoff = new Signoff();
$signoff->setAssocType(ASSOC_TYPE_ARTICLE);
$signoff->setAssocId($article->getId());
$signoff->setUserId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_USER, (int) $signoffXML->userId));
$signoff->setFileId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, (int) $signoffXML->fileId));
$signoff->setUserGroupId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_GROUP, (int) $signoffXML->userGroupId));
$signoff->setSymbolic((string) $signoffXML->symbolic);
$signoff->setFileRevision((int) $signoffXML->fileRevision);
$signoff->setDateUnderway((string) $signoffXML->dateUnderway);
$signoff->setDateNotified((string) $signoffXML->dateNotified);
$signoff->setDateCompleted((string) $signoffXML->dateCompleted);
$signoff->setDateAcknowledged((string) $signoffXML->dateAcknowledged);
$signoffDAO->insertObject($signoff);
}
$editorSubmissionDAO =& DAORegistry::getDAO('EditorSubmissionDAO');
foreach ($articleXML->editDecisions as $editDecisionXML) {
$editDecisions =& $editorSubmissionDAO->update('INSERT INTO edit_decisions (article_id, round, editor_id, decision, date_decided) values (?, ?, ?, ?, ?)', array($article->getId(), (string) $editDecisionXML->round, $this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_USER, (int) $editDecisionXML->editorId), (string) $editDecisionXML->decision, (string) $editDecisionXML->dateDecided));
}
$publishedArticleDAO =& DAORegistry::getDAO('PublishedArticleDAO');
if (isset($articleXML->publishedArticle)) {
$publishedArticleXML = $articleXML->publishedArticle;
$publishedArticle = new PublishedArticle();
$publishedArticle->setId($article->getId());
$publishedArticle->setIssueId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ISSUE, (int) $publishedArticleXML->issueId));
$publishedArticle->setDatePublished((string) $publishedArticleXML->datePublished);
$publishedArticle->setSeq((int) $publishedArticleXML->seq);
$publishedArticle->setAccessStatus((int) $publishedArticleXML->accessStatus);
$publishedArticleDAO->insertPublishedArticle($publishedArticle);
}
$articleEventLogDAO =& DAORegistry::getDAO('ArticleEventLogDAO');
$eventLogsXML =& iterator_to_array($articleXML->eventLogs->eventLog);
$eventLogsXML = array();
foreach ($articleXML->eventLogs->eventLog as $eventLogXML) {
array_unshift($eventLogsXML, $eventLogXML);
}
foreach ($eventLogsXML as $eventLogXML) {
$eventLog = new ArticleEventLogEntry();
$eventLog->setAssocType(ASSOC_TYPE_ARTICLE);
$eventLog->setAssocId($article->getId());
$eventLog->setUserId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_USER, (int) $eventLogXML->userId));
$eventLog->setDateLogged((string) $eventLogXML->dateLogged);
$eventLog->setIPAddress((string) $eventLogXML->IPAddress);
$eventLog->setEventType((int) $eventLogXML->eventType);
$eventLog->setMessage((string) $eventLogXML->message);
$eventLog->setIsTranslated((int) $eventLogXML->isTranslated);
$articleEventLogDAO->insertObject($eventLog);
$this->restoreDataObjectSettings($articleEventLogDAO, $eventLogXML->settings, 'event_log_settings', 'log_id', $eventLog->getId());
}
try {
$article->setSubmissionFileId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, (int) $articleXML->submissionFileId));
} catch (Exception $e) {
}
try {
$article->setRevisedFileId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, (int) $articleXML->revisedFileId));
} catch (Exception $e) {
}
try {
$article->setReviewFileId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, (int) $articleXML->reviewFileId));
} catch (Exception $e) {
}
try {
$article->setEditorFileId($this->idTranslationTable->resolve(INTERNAL_TRANSFER_OBJECT_ARTICLE_FILE, (int) $articleXML->editorFileId));
} catch (Exception $e) {
}
$articleDAO->updateArticle($article);
$this->nextElement();
}
}
/**
* Assigns a reviewer to a submission.
* @param $trackDirectorSubmission object
* @param $reviewerId int
* @param $stage int
*/
function addReviewer($trackDirectorSubmission, $reviewerId, $stage)
{
$trackDirectorSubmissionDao =& DAORegistry::getDAO('TrackDirectorSubmissionDAO');
$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 paper.
if ($stage == null) {
$stage = $trackDirectorSubmission->getCurrentStage();
}
$assigned = $trackDirectorSubmissionDao->reviewerExists($trackDirectorSubmission->getPaperId(), $reviewerId, $stage);
// 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->setStage($stage);
// Assign review form automatically if needed
$schedConfId = $trackDirectorSubmission->getSchedConfId();
$schedConfDao =& DAORegistry::getDAO('SchedConfDAO');
$schedConf =& $schedConfDao->getSchedConf($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->getPaperId(), $reviewerId, $stage);
$schedConf =& Request::getSchedConf();
if ($schedConf->getSetting('reviewDeadlineType') != null) {
if ($schedConf->getSetting('reviewDeadlineType') == REVIEW_DEADLINE_TYPE_ABSOLUTE) {
TrackDirectorAction::setDueDate($trackDirectorSubmission->getPaperId(), $reviewAssignment->getId(), $schedConf->getSetting('numWeeksPerReviewAbsolute'), null, false);
} elseif ($schedConf->getSetting('reviewDeadlineType') == REVIEW_DEADLINE_TYPE_RELATIVE) {
TrackDirectorAction::setDueDate($trackDirectorSubmission->getPaperId(), $reviewAssignment->getId(), null, $schedConf->getSetting('numWeeksPerReviewRelative'), false);
}
}
// Add log
import('paper.log.PaperLog');
import('paper.log.PaperEventLogEntry');
PaperLog::logEvent($trackDirectorSubmission->getPaperId(), PAPER_LOG_REVIEW_ASSIGN, LOG_TYPE_REVIEW, $reviewAssignment->getId(), 'log.review.reviewerAssigned', array('reviewerName' => $reviewer->getFullName(), 'paperId' => $trackDirectorSubmission->getPaperId(), 'stage' => $stage));
}
}
/**
* Construct a new data object corresponding to this DAO.
* @return ReviewAssignment
*/
function newDataObject()
{
$reviewAssignment = new ReviewAssignment();
$reviewAssignment->setStageId(1);
// Ensure correct default is used
return $reviewAssignment;
}
