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)