def send_production_complete(**kwargs):
request = kwargs['request']
article = kwargs['article']
user_content_message = kwargs['user_content_message']
assignment = kwargs['assignment']
description = 'Production has been completed for article {0}.'.format(
article.title)
for task in assignment.typesettask_set.all():
notify_helpers.send_email_with_body_from_user(
request, 'Article Production Complete', task.typesetter.email,
user_content_message)
notify_helpers.send_email_with_body_from_setting_template(
request, 'production_complete', 'subject_production_complete',
article.editor_emails(), {
'article': article,
'assignment': assignment
})
notify_helpers.send_slack(request, description, ['slack_editors'])
util_models.LogEntry.add_entry(types='Production Complete',
description=description,
level='Info',
request=request,
target=article)
def send_typeset_task_deleted(**kwargs):
request = kwargs['request']
typeset_task = kwargs['typeset']
description = '{0} has deleted a typesetter task assigned to {1} for article {2}'.format(
request.user.full_name(),
typeset_task.typesetter.full_name(),
typeset_task.assignment.article.title,
)
# send to author
notify_helpers.send_email_with_body_from_setting_template(
request,
'typeset_deleted',
'subject_typeset_deleted',
typeset_task.typesetter.email,
context={
'request': request,
'typeset_task': typeset_task
})
notify_helpers.send_slack(request, description, ['slack_editors'])
util_models.LogEntry.add_entry(types='Typesetting Assignment Deleted',
description=description,
level='Info',
request=request,
target=typeset_task.assignment.article)
def send_draft_decison(**kwargs):
request = kwargs['request']
draft = kwargs['draft']
article = kwargs['article']
emails = article.section.editor_emails()
if not emails:
emails = request.journal.editor_emails
description = "Section Editor {0} has drafted a decision for Article {1}".format(
draft.section_editor.full_name(), article.title)
log_dict = {
'level': 'Info',
'action_text': description,
'types': 'Draft Decision',
'target': article
}
notify_helpers.send_slack(request, description, ['slack_editors'])
notify_helpers.send_email_with_body_from_setting_template(
request,
'draft_editor_message',
'subject_draft_editor_message',
emails, {
'draft': draft,
'article': article
},
log_dict=log_dict)
def send_proofing_typeset_request(**kwargs):
request = kwargs['request']
typeset_task = kwargs['typeset_task']
article = kwargs['article']
user_content_message = kwargs['user_content_message']
skip = kwargs['skip']
description = '{0} has requested typesetting updates from {1} for {2}'.format(
request.user.full_name(),
typeset_task.typesetter.full_name(),
article.title,
)
log_dict = {
'level': 'Info',
'action_text': description,
'types': 'Typesetting Updates Requested',
'target': article
}
if not skip:
notify_helpers.send_slack(request, description, ['slack_editors'])
notify_helpers.send_email_with_body_from_user(
request,
'subject_notify_typesetter_proofing_changes',
typeset_task.typesetter.email,
user_content_message,
log_dict=log_dict)
def send_copyedit_reopen(**kwargs):
request = kwargs['request']
copyedit_assignment = kwargs['copyedit_assignment']
user_message_content = kwargs['user_message_content']
skip = kwargs.get('skip', False)
description = '{0} has reopened copyediting for {1} from {2}'.format(
request.user.full_name(), copyedit_assignment.article.title,
copyedit_assignment.copyeditor.full_name())
if not skip:
log_dict = {
'level': 'Info',
'action_text': description,
'types': 'Copyedit Complete',
'target': copyedit_assignment.article
}
notify_helpers.send_email_with_body_from_user(
request,
'subject_copyeditor_reopen_task',
copyedit_assignment.copyeditor.email,
user_message_content,
log_dict=log_dict)
notify_helpers.send_slack(request, description, ['slack_editors'])
def send_article_decision(**kwargs):
article = kwargs['article']
request = kwargs['request']
decision = kwargs['decision']
user_message_content = kwargs['user_message_content']
if 'skip' not in kwargs:
kwargs['skip'] = True
skip = kwargs['skip']
description = '{0}\'s article "{1}" has been {2}ed by {3}'.format(
article.correspondence_author.full_name(), article.title, decision,
request.user.full_name())
log_dict = {
'level': 'Info',
'action_text': description,
'types': 'Article Decision',
'target': article
}
if not skip:
notify_helpers.send_email_with_body_from_user(
request,
'Article Review Decision',
article.correspondence_author.email,
user_message_content,
log_dict=log_dict)
notify_helpers.send_slack(request, description, ['slack_editors'])
def send_copyedit_deleted(**kwargs):
request = kwargs['request']
copyedit_assignment = kwargs['copyedit_assignment']
skip = kwargs.get('skip', False)
description = 'Copyedit task {0} for article {1} deleted.'.format(
copyedit_assignment.pk, copyedit_assignment.article.title)
if not skip:
# send to slack
notify_helpers.send_slack(
request,
'Copyedit assignment {0} updated'.format(copyedit_assignment.pk),
['slack_editors'])
# send to author
notify_helpers.send_email_with_body_from_setting_template(
request,
'copyedit_deleted',
'subject_copyedit_deleted',
copyedit_assignment.copyeditor.email,
context={
'request': request,
'copyedit_assignment': copyedit_assignment
})
util_models.LogEntry.add_entry(types='Copyedit Task Deleted',
description=description,
level='Info',
request=request,
target=copyedit_assignment.article)
def send_typeset_assignment(**kwargs):
request = kwargs['request']
typeset_task = kwargs['typeset_task']
user_message_content = kwargs['user_message_content']
skip = kwargs.get('skip', False)
description = '{0} has been assigned as a typesetter for {1}'.format(
typeset_task.typesetter.full_name(),
typeset_task.assignment.article.title)
if not skip:
log_dict = {
'level': 'Info',
'action_text': description,
'types': 'Typesetting Assignment',
'target': typeset_task.assignment.article
}
notify_helpers.send_email_with_body_from_user(
request,
'subject_typesetter_notification',
typeset_task.typesetter.email,
user_message_content,
log_dict=log_dict)
notify_helpers.send_slack(request, description, ['slack_editors'])
def send_confirmation_link(request, new_user):
context = {'user': new_user}
if not request.journal:
message = render_template.get_message_content(
request,
context,
request.press.registration_text,
template_is_setting=True)
subject = 'Registration Confirmation'
else:
message = render_template.get_message_content(request, context,
'new_user_registration')
subject = 'subject_new_user_registration'
notify_helpers.send_slack(
request, 'New registration: {0}'.format(new_user.full_name()),
['slack_admins'])
log_dict = {
'level': 'Info',
'types': 'Account Confirmation',
'target': None
}
notify_helpers.send_email_with_body_from_user(request,
subject,
new_user.email,
message,
log_dict=log_dict)
def send_reviewer_withdrawl_notice(**kwargs):
review_assignment = kwargs['review_assignment']
request = kwargs['request']
user_message_content = kwargs['user_message_content']
if 'skip' not in kwargs:
kwargs['skip'] = True
skip = kwargs['skip']
description = '{0}\'s review of "{1}" has been withdrawn by {2}'.format(
review_assignment.reviewer.full_name(),
review_assignment.article.title, request.user.full_name())
if not skip:
log_dict = {
'level': 'Info',
'action_text': description,
'types': 'Review Withdrawl',
'target': review_assignment.article
}
notify_helpers.send_email_with_body_from_user(
request,
'subject_review_withdrawl',
review_assignment.reviewer.email,
user_message_content,
log_dict=log_dict)
notify_helpers.send_slack(request, description, ['slack_editors'])
def send_typeset_task_deleted(**kwargs):
request = kwargs['request']
typeset_task = kwargs['typeset']
description = '{0} has deleted a typesetter task assigned to {1} for article {2}'.format(
request.user.full_name(),
typeset_task.typesetter.full_name(),
typeset_task.assignment.article.title,
)
log_dict = {
'level': 'Info',
'action_text': description,
'types': 'Typesetter Assignment Deleted',
'target': typeset_task.assignment.article
}
# send to author
notify_helpers.send_email_with_body_from_setting_template(
request,
'typeset_deleted',
'subject_typeset_deleted',
typeset_task.typesetter.email,
context={
'request': request,
'typeset_task': typeset_task
},
log_dict=log_dict)
notify_helpers.send_slack(request, description, ['slack_editors'])
def send_copyedit_deleted(**kwargs):
request = kwargs['request']
copyedit_assignment = kwargs['copyedit_assignment']
skip = kwargs.get('skip', False)
description = 'Copyedit task {0} for article {1} deleted.'.format(
copyedit_assignment.pk, copyedit_assignment.article.title)
if not skip:
# send to slack
notify_helpers.send_slack(
request,
'Copyedit assignment {0} updated'.format(copyedit_assignment.pk),
['slack_editors'])
log_dict = {
'level': 'Info',
'action_text': description,
'types': 'Copyedit Assignment Deleted',
'target': copyedit_assignment.article
}
# send to copyeditor
notify_helpers.send_email_with_body_from_setting_template(
request,
'copyedit_deleted',
'subject_copyedit_deleted',
copyedit_assignment.copyeditor.email,
context={
'request': request,
'copyedit_assignment': copyedit_assignment
},
log_dict=log_dict)
def fire_proofing_manager_assignment(**kwargs):
request = kwargs['request']
proofing_assignment = kwargs['proofing_assignment']
article = proofing_assignment.article
description = '{0} has been assigned as proofing manager for {1}'.format(
proofing_assignment.proofing_manager.full_name(),
article.title,
)
log_dict = {
'level': 'Info',
'action_text': description,
'types': 'Proofing Manager Assigned',
'target': article
}
context = {
'request': request,
'proofing_assignment': proofing_assignment,
'article': article
}
notify_helpers.send_email_with_body_from_setting_template(
request,
'notify_proofing_manager',
'subject_notify_proofing_manager',
proofing_assignment.proofing_manager.email,
context,
log_dict=log_dict)
notify_helpers.send_slack(request, description, ['slack_editors'])
def send_production_complete(**kwargs):
request = kwargs['request']
article = kwargs['article']
user_content_message = kwargs['user_content_message']
assignment = kwargs['assignment']
description = 'Production has been completed for article {0}.'.format(
article.title)
log_dict = {
'level': 'Info',
'action_text': description,
'types': 'Production Complete',
'target': article
}
for task in assignment.typesettask_set.all():
notify_helpers.send_email_with_body_from_user(
request, 'Article Production Complete', task.typesetter.email,
user_content_message)
notify_helpers.send_email_with_body_from_setting_template(
request,
'production_complete',
'subject_production_complete',
article.editor_emails(), {
'article': article,
'assignment': assignment
},
log_dict=log_dict)
notify_helpers.send_slack(request, description, ['slack_editors'])
def cancel_proofing_task(**kwargs):
request = kwargs['request']
article = kwargs['article']
proofing_task = kwargs['proofing_task']
user_content_message = kwargs.get('user_content_message', '')
description = 'Proofing request for article {0} from {1} has been cancelled by {2}'.format(
article.title, proofing_task.proofreader.full_name(),
request.user.full_name())
log_dict = {
'level': 'Info',
'action_text': description,
'types': 'Proofing Task Cancelled',
'target': article
}
context = {
'request': request,
'proofing_task': proofing_task,
'user_content_message': user_content_message
}
notify_helpers.send_email_with_body_from_setting_template(
request,
'notify_proofreader_cancelled',
'subject_notify_proofreader_cancelled',
proofing_task.proofreader.email,
context,
log_dict=log_dict)
notify_helpers.send_slack(request, description, ['slack_editors'])
def send_author_publication_notification(**kwargs):
request = kwargs['request']
article = kwargs['article']
user_message = kwargs['user_message']
section_editors = kwargs['section_editors']
peer_reviewers = kwargs['peer_reviewers']
description = "Article, {0}, set for publication on {1}, by {2}".format(
article.title, article.date_published, request.user.full_name())
notify_helpers.send_email_with_body_from_user(
request, '{0} Publication'.format(article.title),
article.editor_emails(), user_message)
notify_helpers.send_slack(request, description, ['slack_editors'])
# Check for SEs and PRs and notify them as well
if section_editors:
for editor in article.section_editors():
notify_helpers.send_email_with_body_from_setting_template(
request, 'section_editor_pub_notification',
'Article set for publication', editor.email, {
'article': article,
'editor': editor
})
if peer_reviewers:
for reviewer in article.peer_reviewers():
notify_helpers.send_email_with_body_from_setting_template(
request, 'peer_reviewer_pub_notification',
'Article set for publication', reviewer.email, {
'article': article,
'reviewer': reviewer
})
def send_reviewer_withdrawl_notice(**kwargs):
review_assignment = kwargs['review_assignment']
request = kwargs['request']
user_message_content = kwargs['user_message_content']
if 'skip' not in kwargs:
kwargs['skip'] = True
skip = kwargs['skip']
description = '{0}\'s review of "{1}" has been withdrawn by {2}'.format(
review_assignment.reviewer.full_name(),
review_assignment.article.title, request.user.full_name())
if not skip:
notify_helpers.send_email_with_body_from_user(
request, 'subject_review_withdrawl', request.user.email,
user_message_content)
notify_helpers.send_slack(request, description, ['slack_editors'])
util_models.LogEntry.add_entry(types='Review Withdrawl Notification',
description=description,
level='Info',
request=request,
target=review_assignment.article)
def send_revisions_request(**kwargs):
request = kwargs['request']
revision = kwargs['revision']
user_message_content = kwargs['user_message_content']
if 'skip' not in kwargs:
kwargs['skip'] = True
skip = kwargs['skip']
description = '{0} has requested revisions for {1} due on {2}'.format(
request.user.full_name(), revision.article.title, revision.date_due)
log_dict = {
'level': 'Info',
'action_text': description,
'types': 'Revision Request',
'target': revision.article
}
if not skip:
notify_helpers.send_email_with_body_from_user(
request,
'subject_request_revisions',
revision.article.correspondence_author.email,
user_message_content,
log_dict=log_dict)
notify_helpers.send_slack(request, description, ['slack_editors'])
def send_notification(self, request, article):
description = "Article \"{title}\" apc status: {status}".format(
title=article.title,
status=self.status_string(),
)
log_dict = {
'level': 'Info',
'action_text': description,
'types': 'APC Notification',
'target': article,
}
context = {
'article': article,
'billing_staffer': self,
'apc_index_value':
request.journal.site_url(path=reverse('apc_index'))
}
notify_helpers.send_email_with_body_from_setting_template(
request,
self.notification_setting_name(),
'Article APC Update',
self.staffer.email,
context,
log_dict=log_dict,
)
notify_helpers.send_slack(request, description, ['slack_editors'])
def send_copyedit_updated(**kwargs):
request = kwargs['request']
copyedit_assignment = kwargs['copyedit_assignment']
skip = kwargs.get('skip', False)
if not skip:
# send to slack
notify_helpers.send_slack(
request,
'Copyedit assignment {0} updated'.format(copyedit_assignment.pk),
['slack_editors'])
log_dict = {
'level':
'Info',
'action_text':
'Copyedit assignment #{number} update.'.format(
number=copyedit_assignment.pk),
'types':
'Revision Request',
'target':
copyedit_assignment.article
}
# send to author
notify_helpers.send_email_with_body_from_setting_template(
request,
'copyedit_updated',
'subject_copyedit_updated',
copyedit_assignment.copyeditor.email,
context={
'request': request,
'copyedit_assignment': copyedit_assignment
},
log_dict=log_dict)
def send_article_decision(**kwargs):
article = kwargs['article']
request = kwargs['request']
decision = kwargs['decision']
user_message_content = kwargs['user_message_content']
if 'skip' not in kwargs:
kwargs['skip'] = True
skip = kwargs['skip']
description = '{0}\'s article "{1}" has been {2}ed by {3}'.format(
article.correspondence_author.full_name(), article.title, decision,
request.user.full_name())
if not skip:
notify_helpers.send_email_with_body_from_user(
request, 'Article Review Decision', request.user.email,
user_message_content)
notify_helpers.send_slack(request, description, ['slack_editors'])
util_models.LogEntry.add_entry(types='Article Decision',
description=user_message_content,
level='Info',
request=request,
target=article)
def send_reviewer_accepted_or_decline_acknowledgements(**kwargs):
"""
This function is called via the event handling framework and it notifies that a reviewer has either accepted or
declined to review. It is wired up in core/urls.py.
:param kwargs: a list of kwargs that includes review_assignment, accepted and request
:return: None
"""
review_assignment = kwargs['review_assignment']
article = review_assignment.article
request = kwargs['request']
accepted = kwargs['accepted']
description = '{0} {1} to review {2}'.format(
review_assignment.reviewer.full_name(),
('accepted' if accepted else 'declined'), article.title)
util_models.LogEntry.add_entry(types='Review request {0}'.format(
('accepted' if accepted else 'declined')),
description=description,
level='Info',
actor=request.user,
target=article,
request=request)
context = {
'article': article,
'request': request,
'review_assignment': review_assignment
}
# send to slack
notify_helpers.send_slack(request, description, ['slack_editors'])
# send to reviewer
if accepted:
notify_helpers.send_email_with_body_from_setting_template(
request, 'review_accept_acknowledgement',
'subject_review_accept_acknowledgement',
review_assignment.reviewer.email, context)
# send to editor
notify_helpers.send_email_with_body_from_setting_template(
request, 'review_acknowledgement',
'subject_review_acknowledgement', review_assignment.editor.email,
context)
else:
notify_helpers.send_email_with_body_from_setting_template(
request, 'review_decline_acknowledgement',
'subject_review_decline_acknowledgement',
review_assignment.reviewer.email, context)
# send to editor
notify_helpers.send_email_with_body_from_setting_template(
request, 'review_acknowledgement',
'subject_review_acknowledgement', review_assignment.editor.email,
context)
def review_sec_override_notification(**kwargs):
request = kwargs['request']
override = kwargs['override']
description = "{0} overwrote their access to {1}".format(
override.editor.full_name(), override.article.title)
notify_helpers.send_slack(request, description, ['slack_editors'])
notify_helpers.send_email_with_body_from_user(
request, 'Review Security Override', request.journal.editor_emails,
description)
def send_reviewer_requested_acknowledgements_mandatory(**kwargs):
"""
This function is called via the event handling framework and it notifies that a reviewer has been requested.
It is wired up in core/urls.py.
:param kwargs: a list of kwargs that includes review_assignment, user_message_content, skip (boolean) and request
:return: None
"""
review_assignment = kwargs['review_assignment']
article = review_assignment.article
request = kwargs['request']
user_message_content = kwargs['user_message_content']
acknowledgement = kwargs['acknowledgement']
if 'skip' not in kwargs:
kwargs['skip'] = True
skip = kwargs['skip']
description = 'A review request was added to "{0}" for user {1}'.format(
article.title, review_assignment.reviewer.full_name())
context = {
'article': article,
'request': request,
'review_assignment': review_assignment
}
log_dict = {
'level': 'Info',
'action_text': description,
'types': 'Review Request',
'target': article
}
# send to requested reviewer
if not skip:
notify_helpers.send_email_with_body_from_user(
request,
'subject_review_request_sent',
review_assignment.reviewer.email,
user_message_content,
log_dict=log_dict)
if not acknowledgement:
# send slack
notify_helpers.send_slack(request, description, ['slack_editors'])
# send to editor
notify_helpers.send_email_with_body_from_setting_template(
request,
'review_request_sent',
'subject_review_request_sent',
review_assignment.editor.email,
context,
log_dict=log_dict)
def send_editor_assigned_acknowledgements_mandatory(**kwargs):
"""
This function is called via the event handling framework and it notifies that an editor has been assigned.
It is wired up in core/urls.py. It is different to the below function in that this is called when an editor is
assigned, whereas the below is only called when the user opts to send a message to the editor.
:param kwargs: a list of kwargs that includes editor_assignment, user_message_content, skip (boolean) and request
:return: None
"""
editor_assignment = kwargs['editor_assignment']
article = editor_assignment.article
request = kwargs['request']
user_message_content = kwargs['user_message_content']
if 'skip' not in kwargs:
kwargs['skip'] = True
skip = kwargs['skip']
acknowledgement = kwargs['acknowledgement']
description = '{0} was assigned as the editor for "{1}"'.format(
editor_assignment.editor.full_name(), article.title)
context = {
'article': article,
'request': request,
'editor_assignment': editor_assignment
}
log_dict = {
'level': 'Info',
'action_text': description,
'types': 'Editor Assignment',
'target': article
}
# send to assigned editor
if not skip:
notify_helpers.send_email_with_body_from_user(
request,
'subject_editor_assignment',
editor_assignment.editor.email,
user_message_content,
log_dict=log_dict)
# send to editor
if not acknowledgement:
notify_helpers.send_slack(request, description, ['slack_editors'])
notify_helpers.send_email_with_body_from_setting_template(
request,
'editor_assignment',
'subject_editor_assignment',
request.user.email,
context,
log_dict=log_dict)
def review_sec_override_notification(**kwargs):
request = kwargs['request']
override = kwargs['override']
description = "{0} overrode their access to {1}".format(override.editor.full_name(), override.article.title)
log_dict = {'level': 'Warning', 'action_text': description, 'types': 'Security Override',
'target': override.article}
notify_helpers.send_slack(request, description, ['slack_editors'])
notify_helpers.send_email_with_body_from_user(request, 'Review Security Override',
request.journal.editor_emails,
description, log_dict=log_dict)
def send_submission_acknowledgement(**kwargs):
"""
This function is called via the event handling framework and it notifies site operators of a submission. It is
wired up in core/urls.py.
:param kwargs: a list of kwargs that includes article and request
:return: None
"""
article = kwargs['article']
request = kwargs['request']
util_models.LogEntry.add_entry(types='Submission Complete',
description='A new article {0} was submitted'.format(article.title),
level='Info', actor=request.user, target=article, request=request)
context = {
'article': article,
'request': request
}
log_dict = {'level': 'Info',
'action_text': 'A new article {0} was submitted'.format(article.title),
'types': 'New Submission Acknowledgement',
'target': article}
# send to slack
notify_helpers.send_slack(request,
'New submission: {0} {1}'.format(article.title, article.get_remote_url(request)),
['slack_editors'])
# send to author
notify_helpers.send_email_with_body_from_setting_template(request,
'submission_acknowledgement',
'subject_submission_acknowledgement',
article.correspondence_author.email,
context, log_dict=log_dict)
# send to all authors
editors_to_email = setting_handler.get_setting(
'general', 'editors_for_notification', request.journal).processed_value
if editors_to_email:
editor_pks = [int(pk) for pk in editors_to_email]
editor_emails = [role.user.email for role in core_models.AccountRole.objects.filter(
role__slug='editor', user__id__in=editor_pks)]
else:
editor_emails = request.journal.editor_emails
notify_helpers.send_email_with_body_from_setting_template(request,
'editor_new_submission',
'subject_editor_new_submission',
editor_emails,
context, log_dict=log_dict)
def send_proofreader_decision(**kwargs):
request = kwargs['request']
proofing_task = kwargs['proofing_task']
decision = kwargs['decision']
description = '{0} has made a decision for proofing task on {1}: {2}'.format(
proofing_task.proofreader.full_name(),
proofing_task.round.assignment.article.title, decision)
notify_helpers.send_email_with_body_from_user(
request, 'Article Proofreading Update',
proofing_task.round.assignment.proofing_manager.email, description)
notify_helpers.send_slack(request, description, ['slack_editors'])
def send_proofing_complete(**kwargs):
request = kwargs['request']
user_message = kwargs['user_message']
article = kwargs['article']
skip = kwargs['skip']
description = "Proofing is now complete for {0}".format(article.title)
if not skip:
notify_helpers.send_email_with_body_from_user(
request, 'subject_notify_editor_proofing_complete',
article.editor_emails(), user_message)
notify_helpers.send_slack(request, description, ['slack_editors'])
def send_proofing_complete(**kwargs):
request = kwargs['request']
user_message = kwargs['user_message']
article = kwargs['article']
skip = kwargs['skip']
description = "Proofing is now complete for {0}".format(article.title)
log_dict = {'level': 'Info', 'action_text': description, 'types': 'Proofing Complete',
'target': article}
if not skip:
notify_helpers.send_email_with_body_from_user(request, 'subject_notify_editor_proofing_complete',
article.editor_emails(),
user_message, log_dict=log_dict)
notify_helpers.send_slack(request, description, ['slack_editors'])
