def send_mail_after_annual_procedure_of_automatic_postponement_of_egy( end_academic_year, egys_postponed, egys_already_existing, egys_ending_this_year, egys_with_errors): html_template_ref = 'egy_after_auto_postponement_html' txt_template_ref = 'egy_after_auto_postponement_txt' permission = Permission.objects.filter( codename='can_receive_emails_about_automatic_postponement') managers = Person.objects.filter(Q(user__groups__permissions=permission) | Q(user__user_permissions=permission)) \ .distinct() receivers = [ message_config.create_receiver(manager.id, manager.email, manager.language) for manager in managers ] template_base_data = { 'academic_year': end_academic_year.past().year, 'end_academic_year': end_academic_year.year, 'egys_postponed': len(egys_postponed), 'egys_already_existing': len(egys_already_existing), 'egys_ending_this_year': len(egys_ending_this_year), 'egys_with_errors': egys_with_errors } message_content = message_config.create_message_content( html_template_ref, txt_template_ref, None, receivers, template_base_data, None, None) return message_service.send_messages(message_content)
def generate_receivers(receivers): return [ message_config.create_receiver(receiver.person.id, receiver.person.email, receiver.person.language) for receiver in receivers ]
def send_mail_after_the_learning_unit_year_deletion(managers, acronym, academic_year, msg_list): """ Send email to the program managers after deletions made on a learning_unit_year or partials or classes :param acronym: the deleted learning unit :param academic_year: starting academic year at which the deletion must start (can be None if it is a learning_unit) :param msg_list : the list of the messages detailing the deletion :return An error message if the template is not in the database """ # TODO : At the moment, there is no link between managers and learning_units. So here is an empty list. #Later on, we will have to call a function like 'get_managers(learning_unit_year)' instead. #Something like this : #managers = learning_unit_year.get_managers_of_learning_unit_year(learning_unit_year) html_template_ref = 'learning_unit_year_deletion_html' txt_template_ref = 'learning_unit_year_deletion_txt' receivers = [ message_config.create_receiver(manager.id, manager.email, manager.language) for manager in managers ] suject_data = {'learning_unit_acronym': acronym} template_base_data = { 'learning_unit_acronym': acronym, 'academic_year': academic_year, 'msg_list': msg_list, } message_content = message_config.create_message_content( html_template_ref, txt_template_ref, None, receivers, template_base_data, suject_data, None) return message_service.send_messages(message_content)
def send_mail_before_annual_procedure_of_automatic_postponement( end_academic_year, luys_to_postpone, luys_already_existing, luys_ending_this_year): html_template_ref = 'luy_before_auto_postponement_html' txt_template_ref = 'luy_before_auto_postponement_txt' permission = Permission.objects.filter( codename='can_receive_emails_about_automatic_postponement') managers = Person.objects.filter(Q(user__groups__permissions=permission) | Q(user__user_permissions=permission))\ .distinct() receivers = [ message_config.create_receiver(manager.id, manager.email, manager.language) for manager in managers ] template_base_data = { 'academic_year': current_academic_year().year, 'end_academic_year': end_academic_year.year, 'luys_to_postpone': luys_to_postpone.count(), 'luys_already_existing': luys_already_existing.count(), 'luys_ending_this_year': luys_ending_this_year.count(), } message_content = message_config.create_message_content( html_template_ref, txt_template_ref, None, receivers, template_base_data, None, None) return message_service.send_messages(message_content)
def send_internship_score_encoding_recaps(period): organizations, specialties = _get_effective_internships_data(period) active_user_allocations = _get_active_user_allocations( organizations, specialties) for allocation in active_user_allocations: affectations = InternshipStudentAffectationStat.objects.filter( period=period, speciality=allocation.specialty, organization=allocation.organization).select_related( 'score', 'student__person').order_by('student__person__last_name') message_content = message_config.create_message_content( html_template_ref='internship_end_period_recap_html', txt_template_ref='internship_end_period_recap_txt', tables=[], receivers=[ message_config.create_receiver(allocation.master.person_id, allocation.master.person.email, None) ], template_base_data={ 'apds': ['{}'.format(index) for index in range(1, APD_NUMBER + 1)], 'allocation': allocation, 'affectations': affectations, 'period': period.name, 'link': settings.INTERNSHIP_SCORE_ENCODING_URL }, subject_data={'period': period.name}) send_messages(message_content=message_content)
def send_mail_after_academic_calendar_changes(academic_calendar, offer_year_calendar, programm_managers): """ Send an email to all the programme manager after changes has been made on a offer_year_calendar with customized = True :param academic_calendar: :param offer_year_calendar: :param programm_managers: :return un error message if the template does not exists. """ html_template_ref = 'academic_calendar_changes_html' txt_template_ref = 'academic_calendar_changes_txt' receivers = [ message_config.create_receiver(manager.person.id, manager.person.email, manager.person.language) for manager in programm_managers ] suject_data = { 'offer_year': str(offer_year_calendar.offer_year.acronym), 'academic_calendar': str(academic_calendar) } template_base_data = { 'offer_year_title': offer_year_calendar.offer_year.title, 'offer_year_acronym': offer_year_calendar.offer_year.acronym, 'academic_calendar': str(academic_calendar), } message_content = message_config.create_message_content( html_template_ref, txt_template_ref, None, receivers, template_base_data, suject_data) return message_service.send_messages(message_content)
def generate_receivers(*receivers): receivers_tab = [] for receiver in receivers: receivers_tab.append(message_config.create_receiver(receiver.person.id, receiver.person.email, receiver.person.language)) return receivers_tab
def _send_mail_action_learning_unit_proposal(manager, tuple_proposals_results, html_template_ref, txt_template_ref, operation, research_criteria): receivers = [ message_config.create_receiver(manager.id, manager.email, manager.language) ] suject_data = {} template_base_data = { "first_name": manager.first_name, "last_name": manager.last_name } attachment = ( "report.xlsx", build_proposal_report_attachment(manager, tuple_proposals_results, operation, research_criteria), "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet") message_content = message_config.create_message_content( html_template_ref, txt_template_ref, None, receivers, template_base_data, suject_data, attachment=attachment) return message_service.send_messages(message_content)
def send_mail_before_annual_procedure_of_automatic_postponement_of_luy( statistics_context: dict): html_template_ref = 'luy_before_auto_postponement_html' txt_template_ref = 'luy_before_auto_postponement_txt' permission = Permission.objects.get( codename='can_receive_emails_about_automatic_postponement') managers = Person.objects.filter(Q(user__groups__permissions=permission) | Q(user__user_permissions=permission)) \ .distinct() receivers = [ message_config.create_receiver(manager.id, manager.email, manager.language) for manager in managers ] template_base_data = { 'academic_year': statistics_context['max_academic_year_to_postpone'].past(), 'end_academic_year': statistics_context['max_academic_year_to_postpone'], # Use len instead of count() (it's buggy when a queryset is built with a difference()) 'luys_to_postpone': len(statistics_context['to_duplicate']), 'luys_already_existing': statistics_context['already_duplicated'].count(), 'luys_ending_this_year': statistics_context['ending_on_max_academic_year'].count(), } message_content = message_config.create_message_content( html_template_ref, txt_template_ref, None, receivers, template_base_data, None, None) return message_service.send_messages(message_content)
def send_mail_after_scores_submission(persons, learning_unit_name, submitted_enrollments, all_encoded): """ Send an email to all the teachers after the scores submission for a learning unit :param persons: The list of the teachers of the leaning unit :param learning_unit_name: The name of the learning unit for which scores were submitted :param submitted_enrollments : The list of newly sibmitted enrollments :param all_encoded : Tell if all the scores are encoded and submitted :return An error message if the template is not in the database """ html_template_ref = 'assessments_scores_submission_html' txt_template_ref = 'assessments_scores_submission_txt' receivers = [message_config.create_receiver(person.id, person.email, person.language) for person in persons] suject_data = {'learning_unit_name': learning_unit_name} template_base_data = {'learning_unit_name': learning_unit_name, 'encoding_status': _('encoding_status_ended') if all_encoded else _('encoding_status_notended') } header_txt = ['acronym', 'session_title', 'registration_number', 'lastname', 'firstname', 'score', 'documentation'] submitted_enrollments_data = [ ( enrollment.learning_unit_enrollment.offer_enrollment.offer_year.acronym, enrollment.session_exam.number_session, enrollment.learning_unit_enrollment.offer_enrollment.student.registration_id, enrollment.learning_unit_enrollment.offer_enrollment.student.person.last_name, enrollment.learning_unit_enrollment.offer_enrollment.student.person.first_name, enrollment.score_final, _(enrollment.justification_final) if enrollment.justification_final else None, ) for enrollment in submitted_enrollments] table = message_config.create_table('submitted_enrollments', header_txt, submitted_enrollments_data) message_content = message_config.create_message_content(html_template_ref, txt_template_ref, [table], receivers, template_base_data, suject_data) return message_service.send_messages(message_content)
def send_message(person, html_template_ref, txt_template_ref, assistant=None, role=None, entity=None): procedure_dates = settings.get_settings() receivers = [ message_config.create_receiver(person.id, person.email, person.language) ] template_base_data = { 'start_date': procedure_dates.assistants_contract_end_starting_date, 'end_date': procedure_dates.assistants_contract_end_ending_date, 'first_name': person.first_name, 'last_name': person.last_name, 'roles': reviewer_role, 'gender': person.gender } if assistant: template_base_data['assistant'] = assistant.person if role: template_base_data['role'] = role if entity: template_base_data['entity'] = entity subject_data = None table = None message_content = message_config.create_message_content( html_template_ref, txt_template_ref, table, receivers, template_base_data, subject_data) return message_service.send_messages(message_content)
def _get_admission_managers_email_receivers(admission): if admission.formation.send_notification_emails is False: return [] alternative_email_receivers = admission.formation.get_alternative_notification_email_receivers( ) if alternative_email_receivers: return [ message_config.create_receiver(None, receiver_email, None) for receiver_email in alternative_email_receivers ] else: return [ message_config.create_receiver(manager.id, manager.email, manager.language) for manager in admission.formation.managers.all() if manager.email ]
def send_mail_for_educational_information_update(teachers, learning_units_years): html_template_ref = EDUCATIONAL_INFORMATION_UPDATE_HTML txt_template_ref = EDUCATIONAL_INFORMATION_UPDATE_TXT receivers = [message_config.create_receiver(teacher.id, teacher.email, teacher.language) for teacher in teachers] template_base_data = {'learning_unit_years': learning_units_years} message_content = message_config.create_message_content(html_template_ref, txt_template_ref, None, receivers, template_base_data, {}, None) return message_service.send_messages(message_content)
def test_build_participant_receivers_1_unique_email(self): self.admission.email = self.admission.person_information.person.email self.admission.save() receivers = _build_participant_receivers(self.admission) excepted_receivers = [ message_config.create_receiver( self.admission.person_information.person.id, self.admission.email, None) ] self.assertCountEqual(receivers, excepted_receivers)
def _build_participant_receivers(admission): person = admission.person_information.person receivers_emails = [ mail for mail in [person.email, admission.email] if mail ] unique_receivers_emails = set(receivers_emails) receivers = [ message_config.create_receiver(person.id, mail, None) for mail in unique_receivers_emails ] return receivers
def test_build_participant_receivers_2_different_emails(self): receivers = _build_participant_receivers(self.admission) excepted_receivers = [ message_config.create_receiver( self.admission.person_information.person.id, mail, None) for mail in [ self.admission.email, self.admission.person_information.person.email ] ] self.assertCountEqual(receivers, excepted_receivers)
def test_build_and_send_messages_called_once_with_one_receiver( self, mock_get_all_lang_templates, mock_build_and_send_message): mock_get_all_lang_templates.return_value = 'template_html', 'template_txt' receiver = PersonFactory() receivers = [ message_config.create_receiver(receiver.id, receiver.email, None) ] msg_content = message_config.create_message_content( 'template_html', 'template_txt', [], receivers, {}, {}) send_message.send_messages(msg_content) self.assertEqual(mock_build_and_send_message.call_count, 1)
def send_mail_after_the_learning_unit_year_deletion(managers, acronym, academic_year, msg_list): html_template_ref = 'learning_unit_year_deletion_html' txt_template_ref = 'learning_unit_year_deletion_txt' receivers = [message_config.create_receiver(manager.id, manager.email, manager.language) for manager in managers] suject_data = {'learning_unit_acronym': acronym} template_base_data = {'learning_unit_acronym': acronym, 'academic_year': academic_year, 'msg_list':msg_list, } message_content = message_config.create_message_content(html_template_ref, txt_template_ref, None, receivers, template_base_data, suject_data, None) return message_service.send_messages(message_content)
def send_message_after_all_encoded_by_manager(persons, enrollments, learning_unit_acronym, offer_acronym): """ Send a message to all tutor from a learning unit when all scores are submitted by program manager :param persons: The list of the tutor (person) of the learning unit :param enrollments: The enrollments that are encoded and submitted :param learning_unit_acronym The learning unit encoded :param offer_acronym: The offer which is managed :return: A message if an error occured, None if it's ok """ html_template_ref = 'assessments_all_scores_by_pgm_manager_html' txt_template_ref = 'assessments_all_scores_by_pgm_manager_txt' receivers = [ message_config.create_receiver(person.id, person.email, person.language) for person in persons ] suject_data = { 'learning_unit_acronym': learning_unit_acronym, 'offer_acronym': offer_acronym } template_base_data = { 'learning_unit_acronym': learning_unit_acronym, 'offer_acronym': offer_acronym, } enrollments_data = [( enrollment.learning_unit_enrollment.offer_enrollment.offer_year. acronym, enrollment.session_exam.number_session, enrollment.learning_unit_enrollment.offer_enrollment.student. registration_id, enrollment.learning_unit_enrollment.offer_enrollment.student.person. last_name, enrollment.learning_unit_enrollment.offer_enrollment.student.person. first_name, enrollment.score_final, enrollment.justification_final if enrollment.justification_final else None, ) for enrollment in enrollments] enrollments_headers = ('acronym', 'session_title', 'registration_number', 'lastname', 'firstname', 'score', 'justification') table = message_config.create_table('enrollments', enrollments_headers, enrollments_data, data_translatable=['justification']) attachment = build_scores_sheet_attachment(enrollments) message_content = message_config.create_message_content( html_template_ref, txt_template_ref, [table], receivers, template_base_data, suject_data, attachment) return message_service.send_messages(message_content)
def _send_mail_after_learning_unit_proposal_action(managers, proposals, html_template_ref, txt_template_ref): receivers = [ message_config.create_receiver(manager.id, manager.email, manager.language) for manager in managers ] suject_data = {} template_base_data = {'proposals': proposals} message_content = message_config.create_message_content( html_template_ref, txt_template_ref, None, receivers, template_base_data, suject_data, None) return message_service.send_messages(message_content)
def send_mail_after_annual_procedure_of_automatic_postponement_of_egy( statistics_context: dict, egys_postponed: list, egys_with_errors: list): html_template_ref = 'egy_after_auto_postponement_html' txt_template_ref = 'egy_after_auto_postponement_txt' permission = Permission.objects.filter( codename='can_receive_emails_about_automatic_postponement') managers = Person.objects.filter(Q(user__groups__permissions=permission) | Q(user__user_permissions=permission)) \ .distinct() egys_postponed = [ edy for edy in egys_postponed if edy.academic_year_id == statistics_context['max_academic_year_to_postpone'].pk ] receivers = [ message_config.create_receiver(manager.id, manager.email, manager.language) for manager in managers ] template_base_data = { 'academic_year': statistics_context['max_academic_year_to_postpone'].past().year, 'end_academic_year': statistics_context['max_academic_year_to_postpone'].year, 'egys_postponed': len(egys_postponed), 'egys_postponed_qs': sorted(egys_postponed, key=__sort_education_group_type), 'egys_already_existing': statistics_context['already_duplicated'].count(), 'egys_already_existing_qs': statistics_context['already_duplicated'].order_by( 'educationgroupyear__education_group_type__name', 'educationgroupyear__acronym'), 'egys_ending_this_year': statistics_context['ending_on_max_academic_year'].count(), 'egys_ending_this_year_qs': statistics_context['ending_on_max_academic_year'].order_by( 'educationgroupyear__education_group_type__name', 'educationgroupyear__acronym'), 'egys_with_errors': sorted(egys_with_errors) } message_content = message_config.create_message_content( html_template_ref, txt_template_ref, None, receivers, template_base_data, None, None) return message_service.send_messages(message_content)
def test_send_again(self): count_messages_before_send_again = len( message_history.MessageHistory.objects.all()) message = message_history.MessageHistory.objects.get(id=1) receiver = create_receiver(message.receiver_id, '*****@*****.**', 'fr-BE') message = send_again(receiver, message.id) self.assertIsNotNone(message, 'Message history should have been sent again') count_messages_after_send_again = len( message_history.MessageHistory.objects.all()) self.assertTrue( count_messages_after_send_again == count_messages_before_send_again + 1, 'It should be {} messges in messages history'.format( count_messages_before_send_again + 1))
def save_state_changed_and_send_email(admission, connected_user=None): person = admission.person_information.person mails = _get_managers_mails(admission.formation) condition_of_acceptance, registration_required = None, None state_message = get_valid_state_change_message(admission) save_and_create_revision(get_revision_messages(state_message), admission, connected_user) if admission.state in (SUBMITTED, REGISTRATION_SUBMITTED): send_submission_email_to_admission_managers(admission, connected_user) send_submission_email_to_participant(admission, connected_user) return elif admission.state in (ACCEPTED, REJECTED, WAITING, VALIDATED, ACCEPTED_NO_REGISTRATION_REQUIRED): condition_of_acceptance, lower_state, registration_required = _get_datas_from_admission(admission) else: lower_state = 'other' send_email( template_references={ 'html': 'iufc_participant_state_changed_{}_html'.format(lower_state), 'txt': 'iufc_participant_state_changed_{}_txt'.format(lower_state), }, data={ 'template': { 'first_name': admission.person_information.person.first_name, 'last_name': admission.person_information.person.last_name, 'formation': admission.formation, 'state': _(admission.state), 'reason': admission.state_reason if admission.state_reason else '-', 'mails': mails, 'original_state': _(admission._original_state), 'condition_of_acceptance': condition_of_acceptance, 'registration_required': registration_required }, 'subject': { 'state': _(admission.state) } }, receivers=[ message_config.create_receiver( person.id, person.email, None ) ], connected_user=connected_user ) MAIL['text'] = MAIL_MESSAGE % {'receiver': person.email} save_and_create_revision(get_revision_messages(MAIL), admission, connected_user)
def send_score_validated_email(score): message_content = message_config.create_message_content( html_template_ref='internship_score_validated_email_html', txt_template_ref='internship_score_validated_email_txt', tables=[], receivers=[ message_config.create_receiver( score.student_affectation.student.person_id, score.student_affectation.student.person.email, None) ], template_base_data={ 'period': score.student_affectation.period.name, 'link': settings.INTERNSHIP_SCORE_ENCODING_URL }, subject_data={'period': score.student_affectation.period.name}) send_messages(message_content=message_content)
def send_again(message_history_id): """ send a message from message history again :param message_history_id The id of the message history to send again :return the sent message TO-DO : correction of send_message in osis-common to get the associated receiver , based on id and receiver model """ message_history = message_history_mdl.find_by_id(message_history_id) person = person_mdl.find_by_id(message_history.receiver_id) if person: receiver = message_config.create_receiver(person.id, person.email, person.language) return message_service.send_again(receiver, message_history_id) else: return _('no_receiver_error')
def send_mail_after_annual_procedure_of_automatic_postponement_of_luy( statistics_context: dict, luys_postponed: list, luys_with_errors: list): html_template_ref = 'luy_after_auto_postponement_html' txt_template_ref = 'luy_after_auto_postponement_txt' permission = Permission.objects.get( codename='can_receive_emails_about_automatic_postponement') managers = Person.objects.filter( Q(user__groups__permissions=permission) | Q(user__user_permissions=permission)).distinct() receivers = [ message_config.create_receiver(manager.id, manager.email, manager.language) for manager in managers ] template_base_data = { 'academic_year': statistics_context['max_academic_year_to_postpone'].past(), 'end_academic_year': statistics_context['max_academic_year_to_postpone'], 'luys_postponed': len(luys_postponed), 'luys_postponed_qs': sorted(luys_postponed, key=lambda luy: luy.acronym), 'luys_already_existing': statistics_context['already_duplicated'].count(), 'luys_already_existing_qs': statistics_context['already_duplicated'].order_by( "learningunityear__acronym"), 'luys_ending_this_year': statistics_context['ending_on_max_academic_year'].count(), 'luys_ending_this_year_qs': statistics_context['ending_on_max_academic_year'].order_by( "learningunityear__acronym"), 'luys_with_errors': luys_with_errors } message_content = message_config.create_message_content( html_template_ref, txt_template_ref, None, receivers, template_base_data, None, None) return message_service.send_messages(message_content)
def send_mail_to_teacher_new_dissert(adviser): """ Notify (for the teacher) of a new dissertation project """ html_template_ref = 'dissertation_adviser_new_project_dissertation_html' txt_template_ref = 'dissertation_adviser_new_project_dissertation_txt' receivers = [ message_config.create_receiver(adviser.person.id, adviser.person.email, adviser.person.language) ] suject_data = None template_base_data = { 'adviser': adviser, } tables = None message_content = message_config.create_message_content( html_template_ref, txt_template_ref, tables, receivers, template_base_data, suject_data) return message_service.send_messages(message_content)
def send_score_encoding_recap(data, connected_user): student_info = InternshipStudentInformation.objects.get( person__id=data['person_id'], cohort__id=data['cohort_id']) message_content = message_config.create_message_content( html_template_ref='internship_score_encoding_recap_email_html', txt_template_ref='internship_score_encoding_recap_email_txt', tables=[], receivers=[ message_config.create_receiver(student_info.person_id, student_info.email, None) ], template_base_data={ 'today': data['today'], 'periods': data['periods'], 'ordered_periods': data['ordered_periods'] }, subject_data={}) send_messages(message_content=message_content, connected_user=connected_user)
def send_message(person, html_template_ref, txt_template_ref, assistant=None, role=None, entity=None): procedure_dates = settings.get_settings() receivers = [message_config.create_receiver(person.id, person.email, person.language)] template_base_data = {'start_date': procedure_dates.assistants_contract_end_starting_date, 'end_date': procedure_dates.assistants_contract_end_ending_date, 'first_name': person.first_name, 'last_name': person.last_name, 'roles': reviewer_role, 'gender': person.gender} if assistant: template_base_data['assistant'] = assistant.person if role: template_base_data['role'] = role if entity: template_base_data['entity'] = entity subject_data = None table = None message_content = message_config.create_message_content(html_template_ref, txt_template_ref, table, receivers, template_base_data, subject_data) return message_service.send_messages(message_content)
def _send_creation_account_email(master, connected_user=None): set_password_link = '{}?email={}'.format( settings.LDAP_ACCOUNT_CONFIGURATION_URL, master.person.email) send_email(template_references={ 'html': 'internship_create_master_account_email_html', 'txt': 'internship_create_master_account_email_txt', }, data={ 'template': { 'set_password_link': set_password_link, 'score_encoding_link': settings.INTERNSHIP_SCORE_ENCODING_URL }, 'subject': {} }, receivers=[ message_config.create_receiver(master.id, master.person.email, None) ], connected_user=connected_user)
def send_mail_applications_summary(global_id): application_list = get_application_list(global_id) if not application_list: return _('No application found') person = mdl_base.person.find_by_global_id(global_id) html_template_ref = 'applications_confirmation_html' txt_template_ref = 'applications_confirmation_txt' receivers = [ message_config.create_receiver(person.id, person.email, person.language) ] applications = _get_applications_table(application_list) table_applications = message_config.create_table( 'applications', [_('Acronym'), 'Vol. 1', 'Vol. 2'], applications) template_base_data = { 'first_name': person.first_name, 'last_name': person.last_name, } message_content = message_config.create_message_content( html_template_ref, txt_template_ref, [table_applications], receivers, template_base_data, None) return message_service.send_messages(message_content)