def send_emails(institution, currency, amount, display, request):
if institution.banding.billing_agent:
users = [
user for user in institution.banding.billing_agent.users.all()
]
users = users + [
user
for user in core_models.Account.objects.filter(is_superuser=True)
]
if request.journal:
host = request.journal_base_url
else:
host = request.press_base_url
url = reverse('consortial_institution_id',
kwargs={'institution_id': institution.pk})
for user in users:
message = get_signup_email_content(request, institution, currency,
amount, host, url, display,
user)
notify_helpers.send_email_with_body_from_user(
request, 'New Supporting Institution for {0}'.format(
request.press.name), user.email, message)
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_reset_token(request, reset_token):
core_reset_password_url = request.site_type.site_url(
reverse(
'core_reset_password',
kwargs={'token': reset_token.token},
))
context = {
'reset_token': reset_token,
'core_reset_password_url': core_reset_password_url,
}
log_dict = {'level': 'Info', 'types': 'Reset Token', 'target': None}
if not request.journal:
message = render_template.get_message_content(
request,
context,
request.press.password_reset_text,
template_is_setting=True,
)
subject = 'Password Reset'
else:
message = render_template.get_message_content(
request,
context,
'password_reset',
)
subject = 'subject_password_reset'
notify_helpers.send_email_with_body_from_user(
request,
subject,
reset_token.account.email,
message,
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_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 handle_email_change(request, email_address):
request.user.email = email_address
request.user.is_active = False
request.user.confirmation_code = uuid.uuid4()
request.user.clean()
request.user.save()
core_confirm_account_url = request.site_type.site_url(
reverse(
'core_confirm_account',
kwargs={'token': request.user.confirmation_code},
))
context = {
'user': request.user,
'core_confirm_account_url': core_confirm_account_url,
}
message = render_template.get_message_content(
request,
context,
'user_email_change',
)
notify_helpers.send_email_with_body_from_user(
request,
'subject_user_email_change',
request.user.email,
message,
)
logout(request)
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_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_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 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_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 preprint_publication(**kwargs):
"""
Called by events.Event.ON_PREPRINT_PUBLICATIONS handles logging and emails.
:param kwargs: Dictionary containing article and request objects
:return: None
"""
request = kwargs.get('request')
article = kwargs.get('article')
description = '{editor} has published a preprint titled {title}.'.format(editor=request.user.full_name(),
title=article.title)
log_dict = {'level': 'Info', 'action_text': description, 'types': 'Preprint Publication',
'target': article}
util_models.LogEntry.add_entry('Publication', description, 'Info', request.user, request, article)
# Send an email to the article owner.
context = {'article': article}
template = request.press.preprint_publication
email_text = render_template.get_message_content(request, context, template, template_is_setting=True)
notify_helpers.send_email_with_body_from_user(request, ' Preprint Submission Decision', article.owner.email,
email_text, log_dict=log_dict)
# Stops this notification being sent multiple times.c
article.preprint_decision_notification = True
article.save()
def preprint_submission(**kwargs):
"""
Called by events.Event.ON_PRPINT_SUBMISSIONS, logs and emails the author and preprint editor.
:param kwargs: Dictionary containing article and request objects
:return: None
"""
request = kwargs.get('request')
article = kwargs.get('article')
description = '{author} has submitted a new preprint titled {title}.'.format(author=request.user.full_name(),
title=article.title)
log_dict = {'level': 'Info', 'action_text': description, 'types': 'Submission',
'target': article}
# Send an email to the user
context = {'article': article}
template = request.press.preprint_submission
email_text = render_template.get_message_content(request, context, template, template_is_setting=True)
notify_helpers.send_email_with_body_from_user(request, 'Preprint Submission', request.user.email, email_text,
log_dict=log_dict)
# Send an email to the preprint editor
url = request.press_base_url + reverse('preprints_manager_article', kwargs={'article_id': article.pk})
editor_email_text = 'A new preprint has been submitted to {press}: <a href="{url}">{title}</a>.'.format(
press=request.press.name,
url=url,
title=article.title
)
for editor in request.press.preprint_editors():
notify_helpers.send_email_with_body_from_user(request, 'Preprint Submission', editor.email,
editor_email_text, 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())
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_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 email_poll_to_institutions(poll, request):
institutions = models.Institution.objects.filter(
email_address__isnull=False)
for institution in institutions:
content = get_poll_email_content(request, poll, institution)
notify_helpers.send_email_with_body_from_user(
request, 'New Consortium Poll', institution.email_address, content)
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_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 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 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 handle_email_change(request, email_address):
request.user.email = email_address
request.user.is_active = False
request.user.confirmation_code = uuid.uuid4()
request.user.save()
context = {'user': request.user}
message = render_template.get_message_content(request, context, 'user_email_change')
notify_helpers.send_email_with_body_from_user(request, 'subject_user_email_change', request.user.email, message)
logout(request)
def resend_email(article, log_entry, request, form):
to_list = [x.strip() for x in form.cleaned_data['to'].split(';') if x]
valid_email_addresses = validate_to_list(to_list)
subject = form.cleaned_data['subject']
message = form.cleaned_data['body']
log_dict = {'level': 'Info',
'action_text': 'Resending an email.',
'types': 'Email Resend',
'target': article}
notify_helpers.send_email_with_body_from_user(request, subject, valid_email_addresses, message, log_dict=log_dict)
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_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_corrections_complete(**kwargs):
request = kwargs['request']
typeset_task = kwargs['typeset_task']
article = kwargs['article']
description = '{0} has completed corrections task for article {1} (proofing task {2}'.format(
request.user.full_name(),
article.title,
typeset_task.pk,
)
notify_helpers.send_email_with_body_from_user(
request, 'subject_typesetter_corrections_complete',
article.proofingassignment.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)
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'])
def send_proofing_typeset_decision(**kwargs):
request = kwargs['request']
typeset_task = kwargs['typeset_task']
decision = kwargs['decision']
description = '{0} has made a decision for proofing task on {1}: {2}'.format(
typeset_task.typesetter.full_name(),
typeset_task.proofing_task.round.assignment.article.title, decision)
notify_helpers.send_email_with_body_from_user(
request, 'Proofing Typesetting Changes',
typeset_task.proofing_task.round.assignment.proofing_manager.email,
description)
notify_helpers.send_slack(request, description, ['slack_editors'])
def send_reset_token(request, reset_token):
context = {'reset_token': reset_token}
if not request.journal:
message = render_template.get_message_content(
request,
context,
request.press.password_reset_text,
template_is_setting=True)
else:
message = render_template.get_message_content(request, context,
'password_reset')
notify_helpers.send_email_with_body_from_user(request,
'subject_password_reset',
reset_token.account.email,
message)
