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('mail.ArticleMailTemplate');
$reviewerAccessKeysEnabled = $journal->getSetting('reviewerAccessKeysEnabled');
$email = new ArticleMailTemplate($article, $reviewerAccessKeysEnabled ? 'REVIEW_REMIND_AUTO_ONECLICK' : 'REVIEW_REMIND_AUTO', null, false, $journal);
$email->setJournal($journal);
$email->setFrom($journal->getSetting('contactEmail'), $journal->getSetting('contactName'));
$email->addRecipient($reviewer->getEmail(), $reviewer->getFullName());
$email->setAssoc(ARTICLE_EMAIL_REVIEW_REMIND, ARTICLE_EMAIL_TYPE_REVIEW, $reviewId);
$email->setSubject($email->getSubject($journal->getPrimaryLocale()));
$email->setBody($email->getBody($journal->getPrimaryLocale()));
$urlParams = array();
if ($reviewerAccessKeysEnabled) {
import('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);
$paramArray = array('reviewerName' => $reviewer->getFullName(), 'reviewerUsername' => $reviewer->getUsername(), 'journalUrl' => $journal->getUrl(), 'reviewerPassword' => $reviewer->getPassword(), 'reviewDueDate' => strftime(Config::getVar('general', 'date_format_short'), strtotime($reviewAssignment->getDateDue())), '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);
}
/**
* 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;
}
}
/**
* 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;
}
/**
* Copyeditor completes final copyedit.
* @param $copyeditorSubmission object
*/
function completeFinalCopyedit($copyeditorSubmission, $send = false)
{
$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->getArticleId());
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->setAssoc(ARTICLE_EMAIL_COPYEDIT_NOTIFY_FINAL_COMPLETE, ARTICLE_EMAIL_TYPE_COPYEDIT, $copyeditorSubmission->getArticleId());
$email->send();
}
$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->getArticleId());
if (!$layoutSignoff->getFileId()) {
import('classes.file.ArticleFileManager');
$articleFileManager = new ArticleFileManager($copyeditorSubmission->getArticleId());
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($copyeditorSubmission->getArticleId(), ARTICLE_LOG_COPYEDIT_FINAL, ARTICLE_LOG_TYPE_COPYEDIT, $user->getId(), 'log.copyedit.finalEditComplete', array('copyeditorName' => $user->getFullName(), 'articleId' => $copyeditorSubmission->getArticleId()));
return true;
} else {
if (!Request::getUserVar('continued')) {
$assignedSectionEditors = $email->toAssignedEditingSectionEditors($copyeditorSubmission->getArticleId());
$assignedEditors = $email->ccAssignedEditors($copyeditorSubmission->getArticleId());
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->getArticleId()));
return false;
}
}
/**
* Sends acknowledgement email to the current layout editor.
* @param $submission object
* @param $send boolean
* @return boolean true iff ready for redirect
*/
function thankLayoutEditor($submission, $send = false)
{
$signoffDao =& DAORegistry::getDAO('SignoffDAO');
$submissionDao =& DAORegistry::getDAO('SectionEditorSubmissionDAO');
$userDao =& DAORegistry::getDAO('UserDAO');
$journal =& Request::getJournal();
$user =& Request::getUser();
import('classes.mail.ArticleMailTemplate');
$email = new ArticleMailTemplate($submission, 'LAYOUT_ACK');
$layoutSignoff = $signoffDao->build('SIGNOFF_LAYOUT', ASSOC_TYPE_ARTICLE, $submission->getArticleId());
$layoutEditor =& $userDao->getUser($layoutSignoff->getUserId());
if (!isset($layoutEditor)) {
return true;
}
if (!$email->isEnabled() || $send && !$email->hasErrors()) {
HookRegistry::call('SectionEditorAction::thankLayoutEditor', array(&$submission, &$layoutEditor, &$email));
if ($email->isEnabled()) {
$email->setAssoc(ARTICLE_EMAIL_LAYOUT_THANK_EDITOR, ARTICLE_EMAIL_TYPE_LAYOUT, $layoutSignoff->getId());
$email->send();
}
$layoutSignoff->setDateAcknowledged(Core::getCurrentDate());
$signoffDao->updateObject($layoutSignoff);
} else {
if (!Request::getUserVar('continued')) {
$email->addRecipient($layoutEditor->getEmail(), $layoutEditor->getFullName());
$paramArray = array('layoutEditorName' => $layoutEditor->getFullName(), 'editorialContactSignature' => $user->getContactSignature());
$email->assignParams($paramArray);
}
$email->displayEditForm(Request::url(null, null, 'thankLayoutEditor', 'send'), array('articleId' => $submission->getArticleId()));
return false;
}
return true;
}
/**
* Author completes editor / author review.
* @param $authorSubmission object
*/
function completeAuthorCopyedit($authorSubmission, $send = false)
{
$authorSubmissionDao =& DAORegistry::getDAO('AuthorSubmissionDAO');
$signoffDao =& DAORegistry::getDAO('SignoffDAO');
$userDao =& DAORegistry::getDAO('UserDAO');
$journal =& Request::getJournal();
$authorSignoff = $signoffDao->build('SIGNOFF_COPYEDITING_AUTHOR', ASSOC_TYPE_ARTICLE, $authorSubmission->getId());
if ($authorSignoff->getDateCompleted() != null) {
return true;
}
$user =& Request::getUser();
import('classes.mail.ArticleMailTemplate');
$email = new ArticleMailTemplate($authorSubmission, 'COPYEDIT_AUTHOR_COMPLETE');
$editAssignments = $authorSubmission->getEditAssignments();
$copyeditor = $authorSubmission->getUserBySignoffType('SIGNOFF_COPYEDITING_INITIAL');
if (!$email->isEnabled() || $send && !$email->hasErrors()) {
HookRegistry::call('AuthorAction::completeAuthorCopyedit', array(&$authorSubmission, &$email));
if ($email->isEnabled()) {
$email->setAssoc(ARTICLE_EMAIL_COPYEDIT_NOTIFY_AUTHOR_COMPLETE, ARTICLE_EMAIL_TYPE_COPYEDIT, $authorSubmission->getId());
$email->send();
}
$authorSignoff->setDateCompleted(Core::getCurrentDate());
$finalSignoff = $signoffDao->build('SIGNOFF_COPYEDITING_FINAL', ASSOC_TYPE_ARTICLE, $authorSubmission->getId());
if ($copyeditor) {
$finalSignoff->setUserId($copyeditor->getId());
}
$finalSignoff->setDateNotified(Core::getCurrentDate());
$signoffDao->updateObject($authorSignoff);
$signoffDao->updateObject($finalSignoff);
// Add log entry
import('classes.article.log.ArticleLog');
import('classes.article.log.ArticleEventLogEntry');
ArticleLog::logEvent($authorSubmission->getId(), ARTICLE_LOG_COPYEDIT_REVISION, ARTICLE_LOG_TYPE_AUTHOR, $user->getId(), 'log.copyedit.authorFile');
return true;
} else {
if (!Request::getUserVar('continued')) {
if (isset($copyeditor)) {
$email->addRecipient($copyeditor->getEmail(), $copyeditor->getFullName());
$assignedSectionEditors = $email->ccAssignedEditingSectionEditors($authorSubmission->getId());
$assignedEditors = $email->ccAssignedEditors($authorSubmission->getId());
if (empty($assignedSectionEditors) && empty($assignedEditors)) {
$email->addCc($journal->getSetting('contactEmail'), $journal->getSetting('contactName'));
$editorName = $journal->getSetting('contactName');
} else {
$editor = array_shift($assignedSectionEditors);
if (!$editor) {
$editor = array_shift($assignedEditors);
}
$editorName = $editor->getEditorFullName();
}
} else {
$assignedSectionEditors = $email->toAssignedEditingSectionEditors($authorSubmission->getId());
$assignedEditors = $email->ccAssignedEditors($authorSubmission->getId());
if (empty($assignedSectionEditors) && empty($assignedEditors)) {
$email->addRecipient($journal->getSetting('contactEmail'), $journal->getSetting('contactName'));
$editorName = $journal->getSetting('contactName');
} else {
$editor = array_shift($assignedSectionEditors);
if (!$editor) {
$editor = array_shift($assignedEditors);
}
$editorName = $editor->getEditorFullName();
}
}
$paramArray = array('editorialContactName' => isset($copyeditor) ? $copyeditor->getFullName() : $editorName, 'authorName' => $user->getFullName());
$email->assignParams($paramArray);
}
$email->displayEditForm(Request::url(null, 'author', 'completeAuthorCopyedit', 'send'), array('articleId' => $authorSubmission->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 $actionPath string - form action
* @return true iff ready for a redirect
*/
function proofreadEmail($articleId, $mailType, $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, null, $mailType);
switch ($mailType) {
case 'PROOFREAD_AUTHOR_REQUEST':
$eventType = ARTICLE_EMAIL_PROOFREAD_NOTIFY_AUTHOR;
$assocType = ARTICLE_EMAIL_TYPE_PROOFREAD;
$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->getArticleId());
$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;
$assocType = ARTICLE_EMAIL_TYPE_PROOFREAD;
$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->getArticleId());
$addParamArray = array('authorName' => $receiver->getFullName(), 'editorialContactSignature' => $user->getContactSignature());
break;
case 'PROOFREAD_AUTHOR_COMPLETE':
$eventType = ARTICLE_EMAIL_PROOFREAD_NOTIFY_AUTHOR_COMPLETE;
$assocType = ARTICLE_EMAIL_TYPE_PROOFREAD;
$signoffType = 'SIGNOFF_PROOFREADING_AUTHOR';
$setDateField = 'setDateCompleted';
$getDateField = 'getDateCompleted';
$sectionEditorsDao =& DAORegistry::getDAO('SectionEditorsDAO');
$sectionEditors =& $sectionEditorsDao->getEditorsBySectionId($journal->getId(), $sectionEditorSubmission->getSectionId());
$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 ($sectionEditors as $sectionEditor) {
$ccs[$sectionEditor->getEmail()] = $sectionEditor->getFullName();
$editorAdded = true;
}
if (!$editorAdded) {
$ccs[$journal->getSetting('contactEmail')] = $journal->getSetting('contactName');
}
} else {
$editorAdded = false;
$assignmentIndex = 0;
foreach ($sectionEditors as $sectionEditor) {
if ($assignmentIndex++ == 0) {
$receiverName = $sectionEditor->getFullName();
$receiverAddress = $sectionEditor->getEmail();
} else {
$ccs[$sectionEditor->getEmail()] = $sectionEditor->getFullName();
}
$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;
$assocType = ARTICLE_EMAIL_TYPE_PROOFREAD;
$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->getArticleId());
$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;
$assocType = ARTICLE_EMAIL_TYPE_PROOFREAD;
$signoffType = 'SIGNOFF_PROOFREADING_PROOFREADER';
$setDateField = 'setDateAcknowledged';
$receiver = $sectionEditorSubmission->getUserBySignoffType($signoffType);
if (!isset($receiver)) {
return true;
}
$receiverName = $receiver->getFullName();
$receiverAddress = $receiver->getEmail();
$email->ccAssignedEditingSectionEditors($sectionEditorSubmission->getArticleId());
$addParamArray = array('proofreaderName' => $receiverName, 'editorialContactSignature' => $user->getContactSignature());
break;
case 'PROOFREAD_COMPLETE':
$eventType = ARTICLE_EMAIL_PROOFREAD_NOTIFY_PROOFREADER_COMPLETE;
$assocType = ARTICLE_EMAIL_TYPE_PROOFREAD;
$signoffType = 'SIGNOFF_PROOFREADING_PROOFREADER';
$setDateField = 'setDateCompleted';
$getDateField = 'getDateCompleted';
$setNextDateField = 'setDateNotified';
$nextSignoff = $signoffDao->build('SIGNOFF_PROOFREADING_LAYOUT', ASSOC_TYPE_ARTICLE, $articleId);
$sectionEditorsDao =& DAORegistry::getDAO('SectionEditorsDAO');
$sectionEditors =& $sectionEditorsDao->getEditorsBySectionId($journal->getId(), $sectionEditorSubmission->getSectionId());
$receiver = null;
$editorAdded = false;
foreach ($sectionEditors as $sectionEditor) {
if ($receiver === null) {
$receiver = $sectionEditor;
} else {
$ccs[$sectionEditor->getEmail()] = $sectionEditor->getFullName();
}
$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;
$assocType = ARTICLE_EMAIL_TYPE_PROOFREAD;
$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->getArticleId());
$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;
$assocType = ARTICLE_EMAIL_TYPE_PROOFREAD;
$signoffType = 'SIGNOFF_PROOFREADING_LAYOUT';
$setDateField = 'setDateAcknowledged';
$receiver = $sectionEditorSubmission->getUserBySignoffType($signoffType);
if (!isset($receiver)) {
return true;
}
$receiverName = $receiver->getFullName();
$receiverAddress = $receiver->getEmail();
$email->ccAssignedEditingSectionEditors($sectionEditorSubmission->getArticleId());
$addParamArray = array('layoutEditorName' => $receiverName, 'editorialContactSignature' => $user->getContactSignature());
break;
case 'PROOFREAD_LAYOUT_COMPLETE':
$eventType = ARTICLE_EMAIL_PROOFREAD_NOTIFY_LAYOUTEDITOR_COMPLETE;
$assocType = ARTICLE_EMAIL_TYPE_PROOFREAD;
$signoffType = 'SIGNOFF_PROOFREADING_LAYOUT';
$setDateField = 'setDateCompleted';
$getDateField = 'getDateCompleted';
$sectionEditorsDao =& DAORegistry::getDAO('SectionEditorsDAO');
$sectionEditors =& $sectionEditorsDao->getEditorsBySectionId($journal->getId(), $sectionEditorSubmission->getSectionId());
$assignmentIndex = 0;
$editorAdded = false;
foreach ($sectionEditors as $sectionEditor) {
if ($assignmentIndex++ == 0) {
$receiverName = $sectionEditor->getFullName();
$receiverAddress = $sectionEditor->getEmail();
} else {
$ccs[$sectionEditor->getEmail()] = $sectionEditor->getFullName();
}
$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->setAssoc($eventType, $assocType, $articleId);
$email->send();
}
$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;
}
}
