/**
* Save changes to submission.
* @param $args array
* @param $request PKPRequest
* @return int the submission ID
*/
function execute($args, $request)
{
parent::execute($args, $request);
$submission = $this->submission;
// Send author notification email
import('classes.mail.ArticleMailTemplate');
$mail = new ArticleMailTemplate($submission, 'SUBMISSION_ACK');
$authorMail = new ArticleMailTemplate($submission, 'SUBMISSION_ACK_NOT_USER');
$context = $request->getContext();
$router = $request->getRouter();
if ($mail->isEnabled()) {
// submission ack emails should be from the contact.
$mail->setFrom($this->context->getSetting('contactEmail'), $this->context->getSetting('contactName'));
$authorMail->setFrom($this->context->getSetting('contactEmail'), $this->context->getSetting('contactName'));
$user = $request->getUser();
$primaryAuthor = $submission->getPrimaryAuthor();
if (!isset($primaryAuthor)) {
$authors = $submission->getAuthors();
$primaryAuthor = $authors[0];
}
$mail->addRecipient($user->getEmail(), $user->getFullName());
if ($user->getEmail() != $primaryAuthor->getEmail()) {
$authorMail->addRecipient($primaryAuthor->getEmail(), $primaryAuthor->getFullName());
}
if ($context->getSetting('copySubmissionAckPrimaryContact')) {
$authorMail->addBcc($context->getSetting('contactEmail'), $context->getSetting('contactName'));
}
if ($copyAddress = $context->getSetting('copySubmissionAckAddress')) {
$authorMail->addBcc($copyAddress);
}
$assignedAuthors = $submission->getAuthors();
foreach ($assignedAuthors as $author) {
$authorEmail = $author->getEmail();
// only add the author email if they have not already been added as the primary author
// or user creating the submission.
if ($authorEmail != $primaryAuthor->getEmail() && $authorEmail != $user->getEmail()) {
$authorMail->addRecipient($author->getEmail(), $author->getFullName());
}
}
$mail->bccAssignedSubEditors($submission->getId(), WORKFLOW_STAGE_ID_SUBMISSION);
$mail->assignParams(array('authorName' => $user->getFullName(), 'authorUsername' => $user->getUsername(), 'editorialContactSignature' => $context->getSetting('contactName'), 'submissionUrl' => $router->url($request, null, 'authorDashboard', 'submission', $submission->getId())));
$authorMail->assignParams(array('submitterName' => $user->getFullName(), 'editorialContactSignature' => $context->getSetting('contactName')));
$mail->send($request);
$recipients = $authorMail->getRecipients();
if (!empty($recipients)) {
$authorMail->send($request);
}
}
// Log submission.
import('classes.log.SubmissionEventLogEntry');
// Constants
import('lib.pkp.classes.log.SubmissionLog');
SubmissionLog::logEvent($request, $submission, SUBMISSION_LOG_SUBMISSION_SUBMIT, 'submission.event.submissionSubmitted');
return $this->submissionId;
}
/**
* Assigns a section editor to a submission.
* @param $articleId int
* @return boolean true iff ready for redirect
*/
function assignEditor($articleId, $sectionEditorId, $isEditor = false, $send = false)
{
$editorSubmissionDao =& DAORegistry::getDAO('EditorSubmissionDAO');
$editAssignmentDao =& DAORegistry::getDAO('EditAssignmentDAO');
$userDao =& DAORegistry::getDAO('UserDAO');
$user =& Request::getUser();
$journal =& Request::getJournal();
$editorSubmission =& $editorSubmissionDao->getEditorSubmission($articleId);
$sectionEditor =& $userDao->getUser($sectionEditorId);
if (!isset($sectionEditor)) {
return true;
}
import('classes.mail.ArticleMailTemplate');
$email = new ArticleMailTemplate($editorSubmission, 'EDITOR_ASSIGN');
if ($user->getId() === $sectionEditorId || !$email->isEnabled() || $send && !$email->hasErrors()) {
HookRegistry::call('EditorAction::assignEditor', array(&$editorSubmission, &$sectionEditor, &$isEditor, &$email));
if ($email->isEnabled() && $user->getId() !== $sectionEditorId) {
$email->setAssoc(ARTICLE_EMAIL_EDITOR_ASSIGN, ARTICLE_EMAIL_TYPE_EDITOR, $sectionEditor->getId());
$email->send();
}
$editAssignment = new EditAssignment();
$editAssignment->setArticleId($articleId);
$editAssignment->setCanEdit(1);
$editAssignment->setCanReview(1);
// Make the selected editor the new editor
$editAssignment->setEditorId($sectionEditorId);
$editAssignment->setDateNotified(Core::getCurrentDate());
$editAssignment->setDateUnderway(null);
$editAssignments =& $editorSubmission->getEditAssignments();
array_push($editAssignments, $editAssignment);
$editorSubmission->setEditAssignments($editAssignments);
$editorSubmissionDao->updateEditorSubmission($editorSubmission);
// Add log
import('classes.article.log.ArticleLog');
import('classes.article.log.ArticleEventLogEntry');
ArticleLog::logEvent($articleId, ARTICLE_LOG_EDITOR_ASSIGN, ARTICLE_LOG_TYPE_EDITOR, $sectionEditorId, 'log.editor.editorAssigned', array('editorName' => $sectionEditor->getFullName(), 'articleId' => $articleId));
return true;
} else {
if (!Request::getUserVar('continued')) {
$email->addRecipient($sectionEditor->getEmail(), $sectionEditor->getFullName());
$paramArray = array('editorialContactName' => $sectionEditor->getFullName(), 'editorUsername' => $sectionEditor->getUsername(), 'editorPassword' => $sectionEditor->getPassword(), 'editorialContactSignature' => $user->getContactSignature(), 'submissionUrl' => Request::url(null, $isEditor ? 'editor' : 'sectionEditor', 'submissionReview', $articleId), 'submissionEditingUrl' => Request::url(null, $isEditor ? 'editor' : 'sectionEditor', 'submissionReview', $articleId));
$email->assignParams($paramArray);
}
$email->displayEditForm(Request::url(null, null, 'assignEditor', 'send'), array('articleId' => $articleId, 'editorId' => $sectionEditorId));
return false;
}
}
function sendReminder($reviewAssignment, $article, $journal)
{
$reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
$userDao =& DAORegistry::getDAO('UserDAO');
$reviewId = $reviewAssignment->getId();
$reviewer =& $userDao->getUser($reviewAssignment->getReviewerId());
if (!isset($reviewer)) {
return false;
}
import('classes.mail.ArticleMailTemplate');
$reviewerAccessKeysEnabled = $journal->getSetting('reviewerAccessKeysEnabled');
$email = new ArticleMailTemplate($article, $reviewerAccessKeysEnabled ? 'REVIEW_REMIND_AUTO_ONECLICK' : 'REVIEW_REMIND_AUTO', $journal->getPrimaryLocale(), false, $journal, false, true);
$email->setJournal($journal);
$email->setReplyTo(null);
$email->addRecipient($reviewer->getEmail(), $reviewer->getFullName());
$email->setSubject($email->getSubject($journal->getPrimaryLocale()));
$email->setBody($email->getBody($journal->getPrimaryLocale()));
$urlParams = array();
if ($reviewerAccessKeysEnabled) {
import('lib.pkp.classes.security.AccessKeyManager');
$accessKeyManager = new AccessKeyManager();
// Key lifetime is the typical review period plus four weeks
$keyLifetime = ($journal->getSetting('numWeeksPerReview') + 4) * 7;
$urlParams['key'] = $accessKeyManager->createKey('ReviewerContext', $reviewer->getId(), $reviewId, $keyLifetime);
}
$submissionReviewUrl = Request::url($journal->getPath(), 'reviewer', 'submission', $reviewId, $urlParams);
// Format the review due date
$reviewDueDate = strtotime($reviewAssignment->getDateDue());
$dateFormatShort = Config::getVar('general', 'date_format_short');
if ($reviewDueDate === -1 || $reviewDueDate === false) {
// Default to something human-readable if no date specified
$reviewDueDate = '_____';
} else {
$reviewDueDate = strftime($dateFormatShort, $reviewDueDate);
}
$paramArray = array('reviewerName' => $reviewer->getFullName(), 'reviewerUsername' => $reviewer->getUsername(), 'journalUrl' => $journal->getUrl(), 'reviewerPassword' => $reviewer->getPassword(), 'reviewDueDate' => $reviewDueDate, 'weekLaterDate' => strftime(Config::getVar('general', 'date_format_short'), strtotime('+1 week')), 'editorialContactSignature' => $journal->getSetting('contactName') . "\n" . $journal->getLocalizedTitle(), 'passwordResetUrl' => Request::url($journal->getPath(), 'login', 'resetPassword', $reviewer->getUsername(), array('confirm' => Validation::generatePasswordResetHash($reviewer->getId()))), 'submissionReviewUrl' => $submissionReviewUrl);
$email->assignParams($paramArray);
$email->send();
$reviewAssignment->setDateReminded(Core::getCurrentDate());
$reviewAssignment->setReminderWasAutomatic(1);
$reviewAssignmentDao->updateReviewAssignment($reviewAssignment);
}
/**
* Save changes to article.
*/
function execute()
{
$articleDao =& DAORegistry::getDAO('ArticleDAO');
$signoffDao =& DAORegistry::getDAO('SignoffDAO');
$journal = Request::getJournal();
$user = Request::getUser();
// Update article
$article =& $this->article;
if ($this->getData('commentsToEditor') != '') {
$article->setCommentsToEditor($this->getData('commentsToEditor'));
}
$article->setDateSubmitted(Core::getCurrentDate());
$article->setSubmissionProgress(0);
$article->stampStatusModified();
$articleDao->updateArticle($article);
// Designate this as the review version by default.
$authorSubmissionDao =& DAORegistry::getDAO('AuthorSubmissionDAO');
$authorSubmission =& $authorSubmissionDao->getAuthorSubmission($article->getId());
AuthorAction::designateReviewVersion($authorSubmission, true);
unset($authorSubmission);
$copyeditInitialSignoff = $signoffDao->build('SIGNOFF_COPYEDITING_INITIAL', ASSOC_TYPE_ARTICLE, $article->getId());
$copyeditAuthorSignoff = $signoffDao->build('SIGNOFF_COPYEDITING_AUTHOR', ASSOC_TYPE_ARTICLE, $article->getId());
$copyeditFinalSignoff = $signoffDao->build('SIGNOFF_COPYEDITING_FINAL', ASSOC_TYPE_ARTICLE, $article->getId());
$copyeditInitialSignoff->setUserId(0);
$copyeditAuthorSignoff->setUserId($user->getId());
$copyeditFinalSignoff->setUserId(0);
$signoffDao->updateObject($copyeditInitialSignoff);
$signoffDao->updateObject($copyeditAuthorSignoff);
$signoffDao->updateObject($copyeditFinalSignoff);
$layoutSignoff = $signoffDao->build('SIGNOFF_LAYOUT', ASSOC_TYPE_ARTICLE, $article->getId());
$layoutSignoff->setUserId(0);
$signoffDao->updateObject($layoutSignoff);
$proofAuthorSignoff = $signoffDao->build('SIGNOFF_PROOFREADING_AUTHOR', ASSOC_TYPE_ARTICLE, $article->getId());
$proofProofreaderSignoff = $signoffDao->build('SIGNOFF_PROOFREADING_PROOFREADER', ASSOC_TYPE_ARTICLE, $article->getId());
$proofLayoutEditorSignoff = $signoffDao->build('SIGNOFF_PROOFREADING_LAYOUT', ASSOC_TYPE_ARTICLE, $article->getId());
$proofAuthorSignoff->setUserId($user->getId());
$proofProofreaderSignoff->setUserId(0);
$proofLayoutEditorSignoff->setUserId(0);
$signoffDao->updateObject($proofAuthorSignoff);
$signoffDao->updateObject($proofProofreaderSignoff);
$signoffDao->updateObject($proofLayoutEditorSignoff);
$sectionEditors = $this->assignEditors($article);
$user =& Request::getUser();
// Update search index
import('classes.search.ArticleSearchIndex');
ArticleSearchIndex::indexArticleMetadata($article);
ArticleSearchIndex::indexArticleFiles($article);
// Send author notification email
import('classes.mail.ArticleMailTemplate');
$mail = new ArticleMailTemplate($article, 'SUBMISSION_ACK', null, null, null, false);
$mail->setFrom($journal->getSetting('contactEmail'), $journal->getSetting('contactName'));
if ($mail->isEnabled()) {
$mail->addRecipient($user->getEmail(), $user->getFullName());
// If necessary, BCC the acknowledgement to someone.
if ($journal->getSetting('copySubmissionAckPrimaryContact')) {
$mail->addBcc($journal->getSetting('contactEmail'), $journal->getSetting('contactName'));
}
if ($journal->getSetting('copySubmissionAckSpecified')) {
$copyAddress = $journal->getSetting('copySubmissionAckAddress');
if (!empty($copyAddress)) {
$mail->addBcc($copyAddress);
}
}
// Also BCC automatically assigned section editors
foreach ($sectionEditors as $sectionEditorEntry) {
$sectionEditor =& $sectionEditorEntry['user'];
$mail->addBcc($sectionEditor->getEmail(), $sectionEditor->getFullName());
unset($sectionEditor);
}
$mail->assignParams(array('authorName' => $user->getFullName(), 'authorUsername' => $user->getUsername(), 'editorialContactSignature' => $journal->getSetting('contactName') . "\n" . $journal->getLocalizedTitle(), 'submissionUrl' => Request::url(null, 'author', 'submission', $article->getId())));
$mail->send();
}
import('classes.article.log.ArticleLog');
import('classes.article.log.ArticleEventLogEntry');
ArticleLog::logEvent($this->articleId, ARTICLE_LOG_ARTICLE_SUBMIT, ARTICLE_LOG_TYPE_AUTHOR, $user->getId(), 'log.author.submitted', array('submissionId' => $article->getId(), 'authorName' => $user->getFullName()));
return $this->articleId;
}
/**
* Hook registry function that is called when it's time to perform all automatic
* deposits and notify the author of optional deposits.
* @param $hookName string
* @param $args array
*/
function callbackAuthorDeposits($hookName, $args)
{
$sectionEditorSubmission =& $args[0];
$request =& $this->getRequest();
// Determine if the most recent decision was an "Accept"
$decisions = $sectionEditorSubmission->getDecisions();
$decisions = array_pop($decisions);
// Rounds
$decision = array_pop($decisions);
$decisionConst = $decision ? $decision['decision'] : null;
if ($decisionConst != SUBMISSION_EDITOR_DECISION_ACCEPT) {
return false;
}
// The most recent decision was an "Accept"; perform auto deposits.
$journal = $request->getJournal();
$depositPoints = $this->getSetting($journal->getId(), 'depositPoints');
import('classes.sword.OJSSwordDeposit');
import('classes.notification.NotificationManager');
$notificationManager = new NotificationManager();
$sendDepositNotification = $this->getSetting($journal->getId(), 'allowAuthorSpecify') ? true : false;
foreach ($depositPoints as $depositPoint) {
$depositType = $depositPoint['type'];
if ($depositType == SWORD_DEPOSIT_TYPE_OPTIONAL_SELECTION || $depositType == SWORD_DEPOSIT_TYPE_OPTIONAL_FIXED) {
$sendDepositNotification = true;
}
if ($depositType != SWORD_DEPOSIT_TYPE_AUTOMATIC) {
continue;
}
// For each automatic deposit point, perform a deposit.
$deposit = new OJSSwordDeposit($sectionEditorSubmission);
$deposit->setMetadata();
$deposit->addEditorial();
$deposit->createPackage();
$deposit->deposit($depositPoint['url'], $depositPoint['username'], $depositPoint['password']);
$deposit->cleanup();
unset($deposit);
$user = $request->getUser();
$params = array('itemTitle' => $sectionEditorSubmission->getLocalizedTitle(), 'repositoryName' => $depositPoint['name']);
$notificationManager->createTrivialNotification($user->getId(), NOTIFICATION_TYPE_SWORD_AUTO_DEPOSIT_COMPLETE, $params);
}
if ($sendDepositNotification) {
$submittingUser = $sectionEditorSubmission->getUser();
import('classes.mail.ArticleMailTemplate');
$mail = new ArticleMailTemplate($sectionEditorSubmission, 'SWORD_DEPOSIT_NOTIFICATION', null, null, $journal, true, true);
$mail->setReplyTo(null);
$mail->addRecipient($submittingUser->getEmail(), $submittingUser->getFullName());
$mail->assignParams(array('journalName' => $journal->getLocalizedName(), 'articleTitle' => $sectionEditorSubmission->getLocalizedTitle(), 'swordDepositUrl' => $request->url(null, 'sword', 'index', $sectionEditorSubmission->getId())));
$mail->send($request);
}
return false;
}
/**
* Blind CC the editor decision email to reviewers.
* @param $article object
* @param $send boolean
* @return boolean true iff ready for redirect
*/
function bccEditorDecisionCommentToReviewers($article, $send, $request)
{
import('classes.mail.ArticleMailTemplate');
$email = new ArticleMailTemplate($article, 'SUBMISSION_DECISION_REVIEWERS');
if ($send && !$email->hasErrors()) {
HookRegistry::call('SectionEditorAction::bccEditorDecisionCommentToReviewers', array(&$article, &$reviewAssignments, &$email));
$email->send($request);
return true;
} else {
if (!$request->getUserVar('continued')) {
$userDao =& DAORegistry::getDAO('UserDAO');
$reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
$reviewAssignments =& $reviewAssignmentDao->getBySubmissionId($article->getId(), $article->getCurrentRound());
$email->clearRecipients();
foreach ($reviewAssignments as $reviewAssignment) {
if ($reviewAssignment->getDateCompleted() != null && !$reviewAssignment->getCancelled()) {
$reviewer =& $userDao->getUser($reviewAssignment->getReviewerId());
if (isset($reviewer)) {
$email->addBcc($reviewer->getEmail(), $reviewer->getFullName());
}
}
}
$commentsText = "";
if ($article->getMostRecentEditorDecisionComment()) {
$comment = $article->getMostRecentEditorDecisionComment();
$commentsText = String::html2text($comment->getComments()) . "\n\n";
}
$user =& $request->getUser();
$paramArray = array('comments' => $commentsText, 'editorialContactSignature' => $user->getContactSignature());
$email->assignParams($paramArray);
}
$email->displayEditForm($request->url(null, null, 'bccEditorDecisionCommentToReviewers', 'send'), array('articleId' => $article->getId()));
return false;
}
}
/**
* Email the comment.
* @param $recipients array of recipients (email address => name)
*/
function email($recipients)
{
$article = $this->article;
$articleCommentDao =& DAORegistry::getDAO('ArticleCommentDAO');
$journal =& Request::getJournal();
import('mail.ArticleMailTemplate');
$email = new ArticleMailTemplate($article, 'SUBMISSION_COMMENT');
$email->setFrom($this->user->getEmail(), $this->user->getFullName());
$commentText = $this->getData('comments');
// Individually send an email to each of the recipients.
foreach ($recipients as $emailAddress => $name) {
$email->addRecipient($emailAddress, $name);
$paramArray = array('name' => $name, 'commentName' => $this->user->getFullName(), 'comments' => $commentText);
$email->sendWithParams($paramArray);
$email->clearRecipients();
}
}
/**
* Email the comment.
* @param $recipients array of recipients (email address => name)
*/
function email($recipients)
{
import('classes.mail.ArticleMailTemplate');
$email = new ArticleMailTemplate($this->article, 'SUBMISSION_COMMENT');
$journal =& Request::getJournal();
if ($journal) {
$email->setFrom($journal->getSetting('contactEmail'), $journal->getSetting('contactName'));
}
foreach ($recipients as $emailAddress => $name) {
$email->addRecipient($emailAddress, $name);
$email->setSubject(strip_tags($this->article->getLocalizedTitle()));
$paramArray = array('name' => $name, 'commentName' => $this->user->getFullName(), 'comments' => String::html2text($this->getData('comments')));
$email->assignParams($paramArray);
$email->send();
$email->clearRecipients();
}
}
/**
* Copyeditor completes final copyedit.
* @param $copyeditorSubmission object
* @param $send boolean
* @param $request object
*/
function completeFinalCopyedit($copyeditorSubmission, $send, $request)
{
$copyeditorSubmissionDao =& DAORegistry::getDAO('CopyeditorSubmissionDAO');
$signoffDao =& DAORegistry::getDAO('SignoffDAO');
$userDao =& DAORegistry::getDAO('UserDAO');
$journal =& $request->getJournal();
$finalSignoff = $signoffDao->build('SIGNOFF_COPYEDITING_FINAL', ASSOC_TYPE_ARTICLE, $copyeditorSubmission->getId());
if ($finalSignoff->getDateCompleted() != null) {
return true;
}
$user =& $request->getUser();
import('classes.mail.ArticleMailTemplate');
$email = new ArticleMailTemplate($copyeditorSubmission, 'COPYEDIT_FINAL_COMPLETE');
$editAssignments = $copyeditorSubmission->getEditAssignments();
if (!$email->isEnabled() || $send && !$email->hasErrors()) {
HookRegistry::call('CopyeditorAction::completeFinalCopyedit', array(&$copyeditorSubmission, &$editAssignments, &$email));
if ($email->isEnabled()) {
$email->send($request);
}
$finalSignoff->setDateCompleted(Core::getCurrentDate());
$signoffDao->updateObject($finalSignoff);
if ($copyEdFile = $copyeditorSubmission->getFileBySignoffType('SIGNOFF_COPYEDITING_FINAL')) {
// Set initial layout version to final copyedit version
$layoutSignoff = $signoffDao->build('SIGNOFF_LAYOUT', ASSOC_TYPE_ARTICLE, $copyeditorSubmission->getId());
if (!$layoutSignoff->getFileId()) {
import('classes.file.ArticleFileManager');
$articleFileManager = new ArticleFileManager($copyeditorSubmission->getId());
if ($layoutFileId = $articleFileManager->copyToLayoutFile($copyEdFile->getFileId(), $copyEdFile->getRevision())) {
$layoutSignoff->setFileId($layoutFileId);
$signoffDao->updateObject($layoutSignoff);
}
}
}
// Add log entry
import('classes.article.log.ArticleLog');
import('classes.article.log.ArticleEventLogEntry');
ArticleLog::logEvent($request, $copyeditorSubmission, ARTICLE_LOG_COPYEDIT_FINAL, 'log.copyedit.finalEditComplete', array('copyeditorName' => $user->getFullName()));
return true;
} else {
if (!$request->getUserVar('continued')) {
$assignedSectionEditors = $email->toAssignedEditingSectionEditors($copyeditorSubmission->getId());
$assignedEditors = $email->ccAssignedEditors($copyeditorSubmission->getId());
if (empty($assignedSectionEditors) && empty($assignedEditors)) {
$email->addRecipient($journal->getSetting('contactEmail'), $journal->getSetting('contactName'));
$paramArray = array('editorialContactName' => $journal->getSetting('contactName'), 'copyeditorName' => $user->getFullName());
} else {
$editorialContact = array_shift($assignedSectionEditors);
if (!$editorialContact) {
$editorialContact = array_shift($assignedEditors);
}
$paramArray = array('editorialContactName' => $editorialContact->getEditorFullName(), 'copyeditorName' => $user->getFullName());
}
$email->assignParams($paramArray);
}
$email->displayEditForm($request->url(null, 'copyeditor', 'completeFinalCopyedit', 'send'), array('articleId' => $copyeditorSubmission->getId()));
return false;
}
}
/**
* 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;
}
/**
* Email editor decision comment.
* @param $authorSubmission object
* @param $send boolean
* @param $request object
*/
function emailEditorDecisionComment($authorSubmission, $send, $request)
{
$userDao =& DAORegistry::getDAO('UserDAO');
$journal =& $request->getJournal();
$user =& $request->getUser();
import('classes.mail.ArticleMailTemplate');
$email = new ArticleMailTemplate($authorSubmission);
$editAssignments = $authorSubmission->getEditAssignments();
$editors = array();
foreach ($editAssignments as $editAssignment) {
array_push($editors, $userDao->getUser($editAssignment->getEditorId()));
}
if ($send && !$email->hasErrors()) {
HookRegistry::call('AuthorAction::emailEditorDecisionComment', array(&$authorSubmission, &$email));
$email->send($request);
$articleCommentDao =& DAORegistry::getDAO('ArticleCommentDAO');
$articleComment = new ArticleComment();
$articleComment->setCommentType(COMMENT_TYPE_EDITOR_DECISION);
$articleComment->setRoleId(ROLE_ID_AUTHOR);
$articleComment->setArticleId($authorSubmission->getId());
$articleComment->setAuthorId($authorSubmission->getUserId());
$articleComment->setCommentTitle($email->getSubject());
$articleComment->setComments($email->getBody());
$articleComment->setDatePosted(Core::getCurrentDate());
$articleComment->setViewable(true);
$articleComment->setAssocId($authorSubmission->getId());
$articleCommentDao->insertArticleComment($articleComment);
return true;
} else {
if (!$request->getUserVar('continued')) {
$email->setSubject($authorSubmission->getLocalizedTitle());
if (!empty($editors)) {
foreach ($editors as $editor) {
$email->addRecipient($editor->getEmail(), $editor->getFullName());
}
} else {
$email->addRecipient($journal->getSetting('contactEmail'), $journal->getSetting('contactName'));
}
}
$email->displayEditForm(Request::url(null, null, 'emailEditorDecisionComment', 'send'), array('articleId' => $authorSubmission->getId()), 'submission/comment/editorDecisionEmail.tpl');
return false;
}
}
/**
* Blind CC the reviews to reviewers.
* @param $article object
* @param $send boolean
* @param $inhibitExistingEmail boolean
* @return boolean true iff ready for redirect
*/
function blindCcReviewsToReviewers($article, $send = false, $inhibitExistingEmail = false)
{
$commentDao =& DAORegistry::getDAO('ArticleCommentDAO');
$reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
$userDao =& DAORegistry::getDAO('UserDAO');
$journal =& Request::getJournal();
$comments =& $commentDao->getArticleComments($article->getId(), COMMENT_TYPE_EDITOR_DECISION);
$reviewAssignments =& $reviewAssignmentDao->getBySubmissionId($article->getId(), $article->getCurrentRound());
$commentsText = "";
foreach ($comments as $comment) {
$commentsText .= String::html2text($comment->getComments()) . "\n\n";
}
$user =& Request::getUser();
import('classes.mail.ArticleMailTemplate');
$email = new ArticleMailTemplate($article, 'SUBMISSION_DECISION_REVIEWERS', null, null, null, true, true);
if ($send && !$email->hasErrors() && !$inhibitExistingEmail) {
HookRegistry::call('SectionEditorAction::blindCcReviewsToReviewers', array(&$article, &$reviewAssignments, &$email));
$email->send();
return true;
} else {
if ($inhibitExistingEmail || !Request::getUserVar('continued')) {
$email->clearRecipients();
foreach ($reviewAssignments as $reviewAssignment) {
if ($reviewAssignment->getDateCompleted() != null && !$reviewAssignment->getCancelled()) {
$reviewer =& $userDao->getUser($reviewAssignment->getReviewerId());
if (isset($reviewer)) {
$email->addBcc($reviewer->getEmail(), $reviewer->getFullName());
}
}
}
$paramArray = array('comments' => $commentsText, 'editorialContactSignature' => $user->getContactSignature());
$email->assignParams($paramArray);
}
$email->displayEditForm(Request::url(null, null, 'blindCcReviewsToReviewers'), array('articleId' => $article->getId()));
return false;
}
}
/**
* Marks layout assignment as completed.
* @param $submission object
* @param $send boolean
*/
function completeLayoutEditing($submission, $send = false)
{
$signoffDao =& DAORegistry::getDAO('SignoffDAO');
$userDao =& DAORegistry::getDAO('UserDAO');
$journal =& Request::getJournal();
$layoutSignoff = $signoffDao->build('SIGNOFF_LAYOUT', ASSOC_TYPE_ARTICLE, $submission->getArticleId());
if ($layoutSignoff->getDateCompleted() != null) {
return true;
}
import('classes.mail.ArticleMailTemplate');
$email = new ArticleMailTemplate($submission, 'LAYOUT_COMPLETE');
$editAssignments =& $submission->getEditAssignments();
if (empty($editAssignments)) {
return;
}
if (!$email->isEnabled() || $send && !$email->hasErrors()) {
HookRegistry::call('LayoutEditorAction::completeLayoutEditing', array(&$submission, &$editAssignments, &$email));
if ($email->isEnabled()) {
$email->setAssoc(ARTICLE_EMAIL_LAYOUT_NOTIFY_COMPLETE, ARTICLE_EMAIL_TYPE_LAYOUT, $layoutSignoff->getId());
$email->send();
}
$layoutSignoff->setDateCompleted(Core::getCurrentDate());
$signoffDao->updateObject($layoutSignoff);
// Add log entry
$user =& Request::getUser();
import('classes.article.log.ArticleLog');
import('classes.article.log.ArticleEventLogEntry');
ArticleLog::logEvent($submission->getArticleId(), ARTICLE_LOG_LAYOUT_COMPLETE, ARTICLE_LOG_TYPE_LAYOUT, $user->getId(), 'log.layout.layoutEditComplete', array('editorName' => $user->getFullName(), 'articleId' => $submission->getArticleId()));
return true;
} else {
$user =& Request::getUser();
if (!Request::getUserVar('continued')) {
$assignedSectionEditors = $email->toAssignedEditingSectionEditors($submission->getArticleId());
$assignedEditors = $email->ccAssignedEditors($submission->getArticleId());
if (empty($assignedSectionEditors) && empty($assignedEditors)) {
$email->addRecipient($journal->getSetting('contactEmail'), $journal->getSetting('contactName'));
$editorialContactName = $journal->getSetting('contactName');
} else {
$editorialContact = array_shift($assignedSectionEditors);
if (!$editorialContact) {
$editorialContact = array_shift($assignedEditors);
}
$editorialContactName = $editorialContact->getEditorFullName();
}
$paramArray = array('editorialContactName' => $editorialContactName, 'layoutEditorName' => $user->getFullName());
$email->assignParams($paramArray);
}
$email->displayEditForm(Request::url(null, 'layoutEditor', 'completeAssignment', 'send'), array('articleId' => $submission->getArticleId()));
return false;
}
}
/**
* Proofread Emails
* @param $articleId int
* @param $mailType defined string - type of proofread mail being sent
* @param $request object
* @param $actionPath string - form action
* @return true iff ready for a redirect
*/
function proofreadEmail($articleId, $mailType, $request, $actionPath = '')
{
$signoffDao =& DAORegistry::getDAO('SignoffDAO');
$sectionEditorSubmissionDao =& DAORegistry::getDAO('SectionEditorSubmissionDAO');
$sectionEditorSubmission =& $sectionEditorSubmissionDao->getSectionEditorSubmission($articleId);
$userDao =& DAORegistry::getDAO('UserDAO');
$journal =& Request::getJournal();
$user =& Request::getUser();
$ccs = array();
import('classes.mail.ArticleMailTemplate');
$email = new ArticleMailTemplate($sectionEditorSubmission, $mailType);
switch ($mailType) {
case 'PROOFREAD_AUTHOR_REQUEST':
$eventType = ARTICLE_EMAIL_PROOFREAD_NOTIFY_AUTHOR;
$signoffType = 'SIGNOFF_PROOFREADING_AUTHOR';
$setDateField = 'setDateNotified';
$nullifyDateFields = array('setDateUnderway', 'setDateCompleted', 'setDateAcknowledged');
$setUserId = $sectionEditorSubmission->getUserId();
$receiver =& $userDao->getUser($setUserId);
$setUserId = $receiver;
if (!isset($receiver)) {
return true;
}
$receiverName = $receiver->getFullName();
$receiverAddress = $receiver->getEmail();
$email->ccAssignedEditingSectionEditors($sectionEditorSubmission->getId());
$addParamArray = array('authorName' => $receiver->getFullName(), 'authorUsername' => $receiver->getUsername(), 'authorPassword' => $receiver->getPassword(), 'editorialContactSignature' => $user->getContactSignature(), 'submissionUrl' => Request::url(null, 'author', 'submissionEditing', $articleId));
break;
case 'PROOFREAD_AUTHOR_ACK':
$eventType = ARTICLE_EMAIL_PROOFREAD_THANK_AUTHOR;
$signoffType = 'SIGNOFF_PROOFREADING_AUTHOR';
$setDateField = 'setDateAcknowledged';
$receiver =& $userDao->getUser($sectionEditorSubmission->getUserId());
if (!isset($receiver)) {
return true;
}
$receiverName = $receiver->getFullName();
$receiverAddress = $receiver->getEmail();
$email->ccAssignedEditingSectionEditors($sectionEditorSubmission->getId());
$addParamArray = array('authorName' => $receiver->getFullName(), 'editorialContactSignature' => $user->getContactSignature());
break;
case 'PROOFREAD_AUTHOR_COMPLETE':
$eventType = ARTICLE_EMAIL_PROOFREAD_NOTIFY_AUTHOR_COMPLETE;
$signoffType = 'SIGNOFF_PROOFREADING_AUTHOR';
$setDateField = 'setDateCompleted';
$getDateField = 'getDateCompleted';
$editAssignments =& $sectionEditorSubmission->getEditAssignments();
$nextSignoff = $signoffDao->build('SIGNOFF_PROOFREADING_PROOFREADER', ASSOC_TYPE_ARTICLE, $articleId);
if ($nextSignoff->getUserId() != 0) {
$setNextDateField = 'setDateNotified';
$proofreader =& $userDao->getUser($nextSignoff->getUserId());
$receiverName = $proofreader->getFullName();
$receiverAddress = $proofreader->getEmail();
$editorAdded = false;
foreach ($editAssignments as $editAssignment) {
if ($editAssignment->getIsEditor() || $editAssignment->getCanEdit()) {
$ccs[$editAssignment->getEditorEmail()] = $editAssignment->getEditorFullName();
$editorAdded = true;
}
}
if (!$editorAdded) {
$ccs[$journal->getSetting('contactEmail')] = $journal->getSetting('contactName');
}
} else {
$editorAdded = false;
$assignmentIndex = 0;
foreach ($editAssignments as $editAssignment) {
if ($editAssignment->getIsEditor() || $editAssignment->getCanEdit()) {
if ($assignmentIndex++ == 0) {
$receiverName = $editAssignment->getEditorFullName();
$receiverAddress = $editAssignment->getEditorEmail();
} else {
$ccs[$editAssignment->getEditorEmail()] = $editAssignment->getEditorFullName();
}
$editorAdded = true;
}
}
if (!$editorAdded) {
$receiverAddress = $journal->getSetting('contactEmail');
$receiverName = $journal->getSetting('contactName');
}
}
$addParamArray = array('editorialContactName' => $receiverName, 'authorName' => $user->getFullName());
break;
case 'PROOFREAD_REQUEST':
$eventType = ARTICLE_EMAIL_PROOFREAD_NOTIFY_PROOFREADER;
$signoffType = 'SIGNOFF_PROOFREADING_PROOFREADER';
$setDateField = 'setDateNotified';
$nullifyDateFields = array('setDateUnderway', 'setDateCompleted', 'setDateAcknowledged');
$receiver = $sectionEditorSubmission->getUserBySignoffType($signoffType);
if (!isset($receiver)) {
return true;
}
$receiverName = $receiver->getFullName();
$receiverAddress = $receiver->getEmail();
$email->ccAssignedEditingSectionEditors($sectionEditorSubmission->getId());
$addParamArray = array('proofreaderName' => $receiverName, 'proofreaderUsername' => $receiver->getUsername(), 'proofreaderPassword' => $receiver->getPassword(), 'editorialContactSignature' => $user->getContactSignature(), 'submissionUrl' => Request::url(null, 'proofreader', 'submission', $articleId));
break;
case 'PROOFREAD_ACK':
$eventType = ARTICLE_EMAIL_PROOFREAD_THANK_PROOFREADER;
$signoffType = 'SIGNOFF_PROOFREADING_PROOFREADER';
$setDateField = 'setDateAcknowledged';
$receiver = $sectionEditorSubmission->getUserBySignoffType($signoffType);
if (!isset($receiver)) {
return true;
}
$receiverName = $receiver->getFullName();
$receiverAddress = $receiver->getEmail();
$email->ccAssignedEditingSectionEditors($sectionEditorSubmission->getId());
$addParamArray = array('proofreaderName' => $receiverName, 'editorialContactSignature' => $user->getContactSignature());
break;
case 'PROOFREAD_COMPLETE':
$eventType = ARTICLE_EMAIL_PROOFREAD_NOTIFY_PROOFREADER_COMPLETE;
$signoffType = 'SIGNOFF_PROOFREADING_PROOFREADER';
$setDateField = 'setDateCompleted';
$getDateField = 'getDateCompleted';
$setNextDateField = 'setDateNotified';
$nextSignoff = $signoffDao->build('SIGNOFF_PROOFREADING_LAYOUT', ASSOC_TYPE_ARTICLE, $articleId);
$editAssignments =& $sectionEditorSubmission->getEditAssignments();
$receiver = null;
$editorAdded = false;
foreach ($editAssignments as $editAssignment) {
if ($editAssignment->getIsEditor() || $editAssignment->getCanEdit()) {
if ($receiver === null) {
$receiver =& $userDao->getUser($editAssignment->getEditorId());
} else {
$ccs[$editAssignment->getEditorEmail()] = $editAssignment->getEditorFullName();
}
$editorAdded = true;
}
}
if (isset($receiver)) {
$receiverName = $receiver->getFullName();
$receiverAddress = $receiver->getEmail();
} else {
$receiverAddress = $journal->getSetting('contactEmail');
$receiverName = $journal->getSetting('contactName');
}
if (!$editorAdded) {
$ccs[$journal->getSetting('contactEmail')] = $journal->getSetting('contactName');
}
$addParamArray = array('editorialContactName' => $receiverName, 'proofreaderName' => $user->getFullName());
break;
case 'PROOFREAD_LAYOUT_REQUEST':
$eventType = ARTICLE_EMAIL_PROOFREAD_NOTIFY_LAYOUTEDITOR;
$signoffType = 'SIGNOFF_PROOFREADING_LAYOUT';
$setDateField = 'setDateNotified';
$nullifyDateFields = array('setDateUnderway', 'setDateCompleted', 'setDateAcknowledged');
$receiver = $sectionEditorSubmission->getUserBySignoffType($signoffType);
if (!isset($receiver)) {
return true;
}
$receiverName = $receiver->getFullName();
$receiverAddress = $receiver->getEmail();
$email->ccAssignedEditingSectionEditors($sectionEditorSubmission->getId());
$addParamArray = array('layoutEditorName' => $receiverName, 'layoutEditorUsername' => $receiver->getUsername(), 'layoutEditorPassword' => $receiver->getPassword(), 'editorialContactSignature' => $user->getContactSignature(), 'submissionUrl' => Request::url(null, 'proofreader', 'submission', $articleId));
if (!$actionPath) {
// Reset underway/complete/thank dates
$signoffReset = $signoffDao->build($signoffType, ASSOC_TYPE_ARTICLE, $articleId);
$signoffReset->setDateUnderway(null);
$signoffReset->setDateCompleted(null);
$signoffReset->setDateAcknowledged(null);
}
break;
case 'PROOFREAD_LAYOUT_ACK':
$eventType = ARTICLE_EMAIL_PROOFREAD_THANK_LAYOUTEDITOR;
$signoffType = 'SIGNOFF_PROOFREADING_LAYOUT';
$setDateField = 'setDateAcknowledged';
$receiver = $sectionEditorSubmission->getUserBySignoffType($signoffType);
if (!isset($receiver)) {
return true;
}
$receiverName = $receiver->getFullName();
$receiverAddress = $receiver->getEmail();
$email->ccAssignedEditingSectionEditors($sectionEditorSubmission->getId());
$addParamArray = array('layoutEditorName' => $receiverName, 'editorialContactSignature' => $user->getContactSignature());
break;
case 'PROOFREAD_LAYOUT_COMPLETE':
$eventType = ARTICLE_EMAIL_PROOFREAD_NOTIFY_LAYOUTEDITOR_COMPLETE;
$signoffType = 'SIGNOFF_PROOFREADING_LAYOUT';
$setDateField = 'setDateCompleted';
$getDateField = 'getDateCompleted';
$editAssignments =& $sectionEditorSubmission->getEditAssignments();
$assignmentIndex = 0;
$editorAdded = false;
foreach ($editAssignments as $editAssignment) {
if ($editAssignment->getIsEditor() || $editAssignment->getCanEdit()) {
if ($assignmentIndex++ == 0) {
$receiverName = $editAssignment->getEditorFullName();
$receiverAddress = $editAssignment->getEditorEmail();
} else {
$ccs[$editAssignment->getEditorEmail()] = $editAssignment->getEditorFullName();
}
$editorAdded = true;
}
}
if (!$editorAdded) {
$receiverAddress = $journal->getSetting('contactEmail');
$receiverName = $journal->getSetting('contactName');
}
$addParamArray = array('editorialContactName' => $receiverName, 'layoutEditorName' => $user->getFullName());
break;
default:
return true;
}
$signoff = $signoffDao->build($signoffType, ASSOC_TYPE_ARTICLE, $articleId);
if (isset($getDateField)) {
$date = $signoff->{$getDateField}();
if (isset($date)) {
Request::redirect(null, null, 'submission', $articleId);
}
}
if ($email->isEnabled() && ($actionPath || $email->hasErrors())) {
if (!Request::getUserVar('continued')) {
$email->addRecipient($receiverAddress, $receiverName);
if (isset($ccs)) {
foreach ($ccs as $address => $name) {
$email->addCc($address, $name);
}
}
$paramArray = array();
if (isset($addParamArray)) {
$paramArray += $addParamArray;
}
$email->assignParams($paramArray);
}
$email->displayEditForm($actionPath, array('articleId' => $articleId));
return false;
} else {
HookRegistry::call('ProofreaderAction::proofreadEmail', array(&$email, $mailType));
if ($email->isEnabled()) {
$email->send($request);
}
$signoff->{$setDateField}(Core::getCurrentDate());
if (isset($setNextDateField)) {
$nextSignoff->{$setNextDateField}(Core::getCurrentDate());
}
if (isset($nullifyDateFields)) {
foreach ($nullifyDateFields as $fieldSetter) {
$signoff->{$fieldSetter}(null);
}
}
$signoffDao->updateObject($signoff);
if (isset($nextSignoff)) {
$signoffDao->updateObject($nextSignoff);
}
return true;
}
}
/**
* Records the reviewer's submission recommendation.
* @param $reviewId int
* @param $recommendation int
* @param $send boolean
* @param $request object
*/
function recordRecommendation(&$reviewerSubmission, $recommendation, $send, $request)
{
$reviewAssignmentDao =& DAORegistry::getDAO('ReviewAssignmentDAO');
$userDao =& DAORegistry::getDAO('UserDAO');
// Check validity of selected recommendation
$reviewerRecommendationOptions =& ReviewAssignment::getReviewerRecommendationOptions();
if (!isset($reviewerRecommendationOptions[$recommendation])) {
return true;
}
$reviewAssignment =& $reviewAssignmentDao->getById($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('classes.mail.ArticleMailTemplate');
$email = new ArticleMailTemplate($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->setReplyTo($reviewer->getEmail(), $reviewer->getFullName());
if (!$email->isEnabled() || $send && !$email->hasErrors()) {
HookRegistry::call('ReviewerAction::recordRecommendation', array(&$reviewerSubmission, &$email, $recommendation));
if ($email->isEnabled()) {
$email->send($request);
}
$reviewAssignment->setRecommendation($recommendation);
$reviewAssignment->setDateCompleted(Core::getCurrentDate());
$reviewAssignment->stampModified();
$reviewAssignmentDao->updateReviewAssignment($reviewAssignment);
// Add log
import('classes.article.log.ArticleLog');
ArticleLog::logEvent($request, $reviewerSubmission, ARTICLE_LOG_REVIEW_RECOMMENDATION, 'log.review.reviewRecommendationSet', array('reviewerName' => $reviewer->getFullName(), 'articleId' => $reviewAssignment->getSubmissionId(), 'round' => $reviewAssignment->getRound(), 'reviewId' => $reviewAssignment->getId()));
} else {
if (!$request->getUserVar('continued')) {
$assignedEditors = $email->ccAssignedEditors($reviewerSubmission->getId());
$reviewingSectionEditors = $email->toAssignedReviewingSectionEditors($reviewerSubmission->getId());
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);
}
$editorialContactName = $editorialContact->getEditorFullName();
}
$reviewerRecommendationOptions =& ReviewAssignment::getReviewerRecommendationOptions();
$email->assignParams(array('editorialContactName' => $editorialContactName, 'reviewerName' => $reviewer->getFullName(), 'articleTitle' => strip_tags($reviewerSubmission->getLocalizedTitle()), 'recommendation' => __($reviewerRecommendationOptions[$recommendation])));
}
$email->displayEditForm($request->url(null, 'reviewer', 'recordRecommendation'), array('reviewId' => $reviewerSubmission->getReviewId(), 'recommendation' => $recommendation));
return false;
}
}
return true;
}
/**
* Save changes to article.
*/
function execute()
{
$articleDao =& DAORegistry::getDAO('ArticleDAO');
$signoffDao =& DAORegistry::getDAO('SignoffDAO');
$sectionDao =& DAORegistry::getDAO('SectionDAO');
$ercReviewersDao =& DAORegistry::getDAO('ErcReviewersDAO');
$institutionDao =& DAORegistry::getDAO('InstitutionDAO');
$journal = Request::getJournal();
$user = Request::getUser();
// Update article
$article =& $this->article;
if ($article->getDateSubmitted() == null) {
$year = substr(Core::getCurrentDate(), 0, 4);
$countyear = $articleDao->getSubmissionsForYearCount($year) + 1;
$pSponsor = $article->getArticlePrimarySponsor();
$institution = $institutionDao->getInstitutionById($pSponsor->getInstitutionId());
$article->setProposalId($year . '-' . $countyear . '-' . $institution->getInstitutionAcronym());
}
if ($this->getData('commentsToEditor') != '') {
$article->setCommentsToEditor($this->getData('commentsToEditor'));
}
$article->setDateSubmitted(Core::getCurrentDate());
$article->setSubmissionProgress(0);
$article->stampStatusModified();
$articleDao->updateArticle($article);
// Designate this as the review version by default.
$authorSubmissionDao =& DAORegistry::getDAO('AuthorSubmissionDAO');
$authorSubmission =& $authorSubmissionDao->getAuthorSubmission($article->getId());
AuthorAction::designateReviewVersion($authorSubmission, true);
unset($authorSubmission);
$copyeditInitialSignoff = $signoffDao->build('SIGNOFF_COPYEDITING_INITIAL', ASSOC_TYPE_ARTICLE, $article->getId());
$copyeditAuthorSignoff = $signoffDao->build('SIGNOFF_COPYEDITING_AUTHOR', ASSOC_TYPE_ARTICLE, $article->getId());
$copyeditFinalSignoff = $signoffDao->build('SIGNOFF_COPYEDITING_FINAL', ASSOC_TYPE_ARTICLE, $article->getId());
$copyeditInitialSignoff->setUserId(0);
$copyeditAuthorSignoff->setUserId($user->getId());
$copyeditFinalSignoff->setUserId(0);
$signoffDao->updateObject($copyeditInitialSignoff);
$signoffDao->updateObject($copyeditAuthorSignoff);
$signoffDao->updateObject($copyeditFinalSignoff);
$layoutSignoff = $signoffDao->build('SIGNOFF_LAYOUT', ASSOC_TYPE_ARTICLE, $article->getId());
$layoutSignoff->setUserId(0);
$signoffDao->updateObject($layoutSignoff);
$proofAuthorSignoff = $signoffDao->build('SIGNOFF_PROOFREADING_AUTHOR', ASSOC_TYPE_ARTICLE, $article->getId());
$proofProofreaderSignoff = $signoffDao->build('SIGNOFF_PROOFREADING_PROOFREADER', ASSOC_TYPE_ARTICLE, $article->getId());
$proofLayoutEditorSignoff = $signoffDao->build('SIGNOFF_PROOFREADING_LAYOUT', ASSOC_TYPE_ARTICLE, $article->getId());
$proofAuthorSignoff->setUserId($user->getId());
$proofProofreaderSignoff->setUserId(0);
$proofLayoutEditorSignoff->setUserId(0);
$signoffDao->updateObject($proofAuthorSignoff);
$signoffDao->updateObject($proofProofreaderSignoff);
$signoffDao->updateObject($proofLayoutEditorSignoff);
$sectionEditorsDao =& DAORegistry::getDAO('SectionEditorsDAO');
$sectionEditors =& $sectionEditorsDao->getEditorsBySectionId($journal->getId(), $article->getSectionId());
$user =& Request::getUser();
// Update search index
import('classes.search.ArticleSearchIndex');
ArticleSearchIndex::indexArticleMetadata($article);
ArticleSearchIndex::indexArticleFiles($article);
// Send author notification email
import('classes.mail.ArticleMailTemplate');
$mail = new ArticleMailTemplate($article, null, 'SUBMISSION_ACK', null, null, null, false);
foreach ($sectionEditors as $sectionEditor) {
// If one of the secretary is the chair of the committee, send from the chair, if not, take the last secretary in the array
$from = $mail->getFrom();
if ($ercReviewersDao->isErcReviewer($journal->getId(), $sectionEditor->getId(), REVIEWER_CHAIR)) {
$mail->setFrom($sectionEditor->getEmail(), $sectionEditor->getFullName());
} elseif ($from['email'] == $user->getEmail()) {
$mail->setFrom($sectionEditor->getEmail(), $sectionEditor->getFullName());
}
$mail->addBcc($sectionEditor->getEmail(), $sectionEditor->getFullName());
unset($sectionEditor);
}
if ($mail->isEnabled()) {
$mail->addRecipient($user->getEmail(), $user->getFullName());
if ($journal->getSetting('copySubmissionAckSpecified')) {
$copyAddress = $journal->getSetting('copySubmissionAckAddress');
if (!empty($copyAddress)) {
$mail->addBcc($copyAddress);
}
}
$section = $sectionDao->getSection($article->getSectionId());
$mail->assignParams(array('authorName' => $user->getFullName(), 'authorUsername' => $user->getUsername(), 'address' => $sectionDao->getSettingValue($article->getSectionId(), 'address'), 'bankAccount' => $sectionDao->getSettingValue($article->getSectionId(), 'bankAccount'), 'proposalId' => $article->getProposalId(), 'submissionUrl' => Request::url(null, 'author', 'submission', $article->getId())));
$mail->send();
}
// Send a regular notification to section editors
$lastDecision = $article->getLastSectionDecision();
switch ($lastDecision->getReviewType()) {
case REVIEW_TYPE_INITIAL:
if ($lastDecision->getRound() == 1) {
$message = 'notification.type.articleSubmitted.initialReview';
} else {
$message = 'notification.type.articleReSubmitted.initialReview';
}
break;
case REVIEW_TYPE_PR:
if ($lastDecision->getRound() == 1) {
$message = 'notification.type.articleSubmitted.continuingReview';
} else {
$message = 'notification.type.articleReSubmitted.continuingReview';
}
break;
case REVIEW_TYPE_AMENDMENT:
if ($lastDecision->getRound() == 1) {
$message = 'notification.type.articleSubmitted.PAAmendmentReview';
} else {
$message = 'notification.type.articleReSubmitted.PAAmendmentReview';
}
break;
case REVIEW_TYPE_SAE:
if ($lastDecision->getRound() == 1) {
$message = 'notification.type.articleSubmitted.SAE';
} else {
$message = 'notification.type.articleReSubmitted.SAE';
}
break;
case REVIEW_TYPE_FR:
if ($lastDecision->getRound() == 1) {
$message = 'notification.type.articleSubmitted.EOS';
} else {
$message = 'notification.type.articleReSubmitted.EOS';
}
break;
}
import('lib.pkp.classes.notification.NotificationManager');
$notificationManager = new NotificationManager();
$url = Request::url($journal->getPath(), 'sectionEditor', 'submission', array($article->getId(), 'submissionReview'));
foreach ($sectionEditors as $sectionEditor) {
$notificationManager->createNotification($sectionEditor->getId(), $message, $article->getProposalId(), $url, 1, NOTIFICATION_TYPE_ARTICLE_SUBMITTED);
}
import('classes.article.log.ArticleLog');
import('classes.article.log.ArticleEventLogEntry');
if ($lastDecision->getRound() == 1) {
$message = 'log.author.submitted';
} else {
$message = 'log.author.resubmitted';
}
ArticleLog::logEvent($this->articleId, ARTICLE_LOG_ARTICLE_SUBMIT, ARTICLE_LOG_TYPE_AUTHOR, $user->getId(), $message, array('submissionId' => $article->getProposalId(), 'authorName' => $user->getFullName(), 'reviewType' => Locale::translate($lastDecision->getReviewTypeKey())));
return $this->articleId;
}
