/**
* 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));
}
}
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();
}
}
/**
* 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();
}
/**
* 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));
}
}
