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 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_email(template_references, receivers, data, connected_user=None): message_content = message_config.create_message_content( template_references['html'], template_references['txt'], [], receivers, data['template'], data['subject'], data.get('attachment', None) ) message_service.send_messages( message_content=message_content, connected_user=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_mail_activation(request, activation_code, applicant, template_reference): logger.info('Sending mail activation to : {} '.format( applicant.user.email)) message_content = { 'html_template_ref': '{0}_html'.format(template_reference), 'txt_template_ref': '{0}_txt'.format(template_reference) } receivers = [] receiver = { 'receiver_email': applicant.user.email, 'receiver_id': applicant.id } receivers.append(receiver) message_content['receivers'] = receivers activation_link = "{0}://{1}/admission/admission/user/{2}/activation".format( request.scheme, request.get_host(), activation_code) data = { 'title': title(applicant.gender), 'academic_year': academic_year.current_academic_year(), 'activation_link': activation_link, 'signature': render_to_string( 'messaging/html_email_signature.html', { 'logo_mail_signature_url': LOGO_EMAIL_SIGNATURE_URL, 'logo_osis_url': LOGO_OSIS_URL }) } message_content['template_base_data'] = data return send_message.send_messages(message_content)
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_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 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_mail_before_annual_procedure_of_automatic_postponement_of_egy( statistics_context: dict): html_template_ref = 'egy_before_auto_postponement_html' txt_template_ref = 'egy_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': statistics_context['max_academic_year_to_postpone'].past().year, 'end_academic_year': statistics_context['max_academic_year_to_postpone'].year, # Use len instead of count() (it's buggy when a queryset is built with a difference()) 'egys_to_postpone': len(statistics_context['to_duplicate']), 'egys_already_existing': statistics_context['already_duplicated'].count(), 'egys_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_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 _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 test_send_messages(self): count_messages_before_send = len( message_history.MessageHistory.objects.all()) receivers = self.__make_receivers() tables = (self.__make_table(), ) template_base_data = { 'learning_unit_name': 'DROI1100', } subject_data = {} message_content = create_message_content( 'assessments_scores_submission_html', 'assessments_scores_submission_txt', tables, receivers, template_base_data, subject_data) message_error = send_message.send_messages( message_content=message_content, connected_user=self.connected_user) self.assertIsNone(message_error, 'No message error should be sent') count_messages_after_send_again = len( message_history.MessageHistory.objects.all()) self.assertTrue( count_messages_after_send_again == count_messages_before_send + 5, '5 messages should have been sent') content_no_html_ref = create_message_content( None, 'assessments_scores_submission_txt', tables, receivers, template_base_data, subject_data) message_error = send_message.send_messages( message_content=content_no_html_ref, connected_user=self.connected_user) self.assertIsNotNone(message_error, 'A message error should be sent') content_no_receivers = create_message_content( 'assessments_scores_submission_html', 'assessments_scores_submission_txt', tables, None, template_base_data, subject_data) message_error = send_message.send_messages( message_content=content_no_receivers, connected_user=self.connected_user) self.assertIsNotNone(message_error, 'A message error should be sent') content_wrong_html_ref = create_message_content( 'unknown_template_html', 'assessments_scores_submission_txt', tables, receivers, template_base_data, subject_data) message_error = send_message.send_messages( message_content=content_wrong_html_ref, connected_user=self.connected_user) self.assertIsNotNone(message_error, 'A message error should be sent')
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 send_email(dissert, template_ref, receivers): receivers = generate_receivers(receivers) html_template_ref = template_ref + '_html' txt_template_ref = template_ref + '_txt' suject_data = None template_base_data = get_base_template(dissert) 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_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_email(dissert, template_ref, receivers): receivers = generate_receivers(receivers) html_template_ref = template_ref + '_html' txt_template_ref = template_ref + '_txt' suject_data = get_subject_template(dissert) if template_ref is not 'dissertation_to_commission_list': template_base_data = get_base_template(dissert) else: template_base_data = get_commission_template(dissert) 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_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 send_internship_period_encoding_reminder(period): organizations, specialties = _get_effective_internships_data(period) active_user_allocations = _get_active_user_allocations( organizations, specialties) deduplicated_active_masters = _get_deduplicated_active_masters( active_user_allocations) message_content = message_config.create_message_content( html_template_ref='internship_end_period_reminder_html', txt_template_ref='internship_end_period_reminder_txt', tables=[], receivers=[ message_config.create_receiver(master_person_id, master_email, None) for master_person_id, master_email in deduplicated_active_masters ], template_base_data={ 'period': period.name, 'link': settings.INTERNSHIP_SCORE_ENCODING_URL }, subject_data={'period': period.name}) send_messages(message_content=message_content) period.reminder_mail_sent = True period.save()
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_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_mail_activation(request, activation_code, applicant, template_reference): logger.info('Sending mail activation to : {} '.format(applicant.user.email)) message_content = {'html_template_ref': '{0}_html'.format(template_reference), 'txt_template_ref': '{0}_txt'.format(template_reference)} receivers = [] receiver = {'receiver_email': applicant.user.email, 'receiver_id': applicant.id} receivers.append(receiver) message_content['receivers'] = receivers activation_link = "{0}://{1}/admission/admission/user/{2}/activation".format(request.scheme, request.get_host(), activation_code) data = {'title': title(applicant.gender), 'academic_year': academic_year.current_academic_year(), 'activation_link': activation_link, 'signature': render_to_string('messaging/html_email_signature.html', {'logo_mail_signature_url': LOGO_EMAIL_SIGNATURE_URL, 'logo_osis_url': LOGO_OSIS_URL})} message_content['template_base_data'] = data return send_message.send_messages(message_content)
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)
def send_message(person, html_template_ref, txt_template_ref, assistant=None): procedure_dates = settings.get_settings() receivers = [ message_config.create_receiver(person.id, person.email, person.language) ] first_ending_year = academic_year.current_academic_year().year + 1 last_ending_year = first_ending_year + 1 template_base_data = { 'start_date': procedure_dates.starting_date, 'end_date': procedure_dates.ending_date, 'first_name': person.first_name, 'last_name': person.last_name, 'first_ending_year': first_ending_year, 'last_ending_year': last_ending_year } if assistant is not None: template_base_data['assistant'] = assistant.person 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)