def get_form_kwargs(self):
""" For the creation, the group_element_year needs a parent and a child """
kwargs = super().get_form_kwargs()
try:
cached_data = extract_child_from_cache(self.education_group_year,
self.request.user)
kwargs.update({
'parent': self.education_group_year,
'child_branch': cached_data.get('child_branch'),
'child_leaf': cached_data.get('child_leaf')
})
child = kwargs['child_branch'] if kwargs[
'child_branch'] else kwargs['child_leaf']
strategy = AttachEducationGroupYearStrategy if isinstance(child, EducationGroupYear) else \
AttachLearningUnitYearStrategy
strategy(parent=self.education_group_year, child=child).is_valid()
except ObjectDoesNotExist:
warning_msg = _("Please select an item before attach it")
display_warning_messages(self.request, warning_msg)
except ValidationError as e:
display_error_messages(self.request, e.messages)
except IntegrityError as e:
warning_msg = str(e)
display_warning_messages(self.request, warning_msg)
return kwargs
def learning_units_proposal_search(request):
search_form = LearningUnitProposalForm(request.GET or None, initial={'academic_year_id': current_academic_year()})
user_person = get_object_or_404(Person, user=request.user)
proposals = []
research_criteria = []
try:
if search_form.is_valid():
research_criteria = get_research_criteria(search_form)
proposals = search_form.get_proposal_learning_units()
check_if_display_message(request, proposals)
except TooManyResultsException:
display_error_messages(request, 'too_many_results')
if request.GET.get('xls_status') == "xls":
return create_xls_proposal(request.user, proposals, _get_filter(search_form, PROPOSAL_SEARCH))
if request.POST:
selected_proposals_id = request.POST.getlist("selected_action", default=[])
selected_proposals = ProposalLearningUnit.objects.filter(id__in=selected_proposals_id)
messages_by_level = apply_action_on_proposals(selected_proposals, user_person, request.POST, research_criteria)
display_messages_by_level(request, messages_by_level)
return redirect(reverse("learning_unit_proposal_search") + "?{}".format(request.GET.urlencode()))
context = {
'form': search_form,
'form_proposal_state': ProposalStateModelForm(),
'academic_years': get_last_academic_years(),
'current_academic_year': current_academic_year(),
'experimental_phase': True,
'search_type': PROPOSAL_SEARCH,
'proposals': proposals,
'is_faculty_manager': user_person.is_faculty_manager(),
'form_comparison': SelectComparisonYears(academic_year=get_academic_year_of_reference(proposals)),
}
return layout.render(request, "learning_units.html", context)
def _display_adapted_ucl_registration_message(admission, request):
if admission.ucl_registration_complete == UCLRegistrationState.SENDED.name:
display_warning_messages(
request, _('Folder sended to EPC : waiting for response'))
elif admission.ucl_registration_complete == UCLRegistrationState.REJECTED.name:
display_error_messages(
request,
mark_safe(
_('Folder injection into EPC failed : %(reasons)s') %
{'reasons': admission.get_ucl_registration_error_display()}))
elif admission.ucl_registration_complete == UCLRegistrationState.DEMANDE.name:
display_info_messages(
request,
_('Folder injection into EPC succeeded : UCLouvain registration on demand'
))
elif admission.ucl_registration_complete == UCLRegistrationState.INSCRIT.name:
display_success_messages(
request,
_('Folder injection into EPC succeeded : UCLouvain registration completed'
))
elif admission.ucl_registration_complete != UCLRegistrationState.INIT_STATE.name:
display_info_messages(
request,
_('Folder injection into EPC succeeded : UCLouvain registration status : %(status)s'
) %
{'status': admission.get_ucl_registration_complete_display()})
def learning_units_proposal_search(request):
search_form = LearningUnitProposalForm(request.GET or None)
proposals = []
try:
if search_form.is_valid():
proposals = search_form.get_proposal_learning_units()
check_if_display_message(request, proposals)
except TooManyResultsException:
display_error_messages(request, 'too_many_results')
if proposals:
proposals = _proposal_management(request, proposals)
a_person = find_by_user(request.user)
context = {
'form': search_form,
'academic_years': get_last_academic_years(),
'current_academic_year': current_academic_year(),
'experimental_phase': True,
'search_type': PROPOSAL_SEARCH,
'proposals': proposals,
'is_faculty_manager': a_person.is_faculty_manager()
}
return layout.render(request, "learning_units.html", context)
def get_form_kwargs(self):
""" For the creation, the group_element_year needs a parent and a child """
kwargs = super().get_form_kwargs()
# Formset don't use instance parameter
if "instance" in kwargs:
del kwargs["instance"]
kwargs_form_kwargs = []
children = fetch_elements_selected(self.request.GET, self.request.user)
messages = _check_attach(self.education_group_year, children)
if messages:
display_error_messages(self.request, messages)
for child in children:
kwargs_form_kwargs.append({
'parent':
self.education_group_year,
'child_branch':
child if isinstance(child, EducationGroupYear) else None,
'child_leaf':
child if isinstance(child, LearningUnitYear) else None,
'empty_permitted':
False
})
kwargs["form_kwargs"] = kwargs_form_kwargs
kwargs["queryset"] = GroupElementYear.objects.none()
return kwargs
def learning_units_external_search(request):
search_form = ExternalLearningUnitYearForm(request.GET or None,
initial={'academic_year_id': current_academic_year()})
user_person = get_object_or_404(Person, user=request.user)
external_learning_units = []
try:
if search_form.is_valid():
external_learning_units = search_form.get_learning_units()
check_if_display_message(request, external_learning_units)
except TooManyResultsException:
display_error_messages(request, 'too_many_results')
if request.POST:
return redirect(reverse("learning_unit_proposal_search") + "?{}".format(request.GET.urlencode()))
context = {
'form': search_form,
'academic_years': get_last_academic_years(),
'current_academic_year': current_academic_year(),
'experimental_phase': True,
'search_type': EXTERNAL_SEARCH,
'learning_units': external_learning_units,
'is_faculty_manager': user_person.is_faculty_manager(),
'form_comparison': SelectComparisonYears(academic_year=get_academic_year_of_reference(external_learning_units)),
}
return layout.render(request, "learning_units.html", context)
def _upload_file(request, admission):
my_file = request.FILES['myfile']
file_category = request.POST.get('file_category', None)
person = Person.objects.get(user=request.user)
file_to_admission = AdmissionFile(
admission=admission,
path=my_file,
name=my_file.name,
size=my_file.size,
uploaded_by=person,
file_category=file_category,
)
try:
file_to_admission.save()
display_success_messages(request,
_("The document is uploaded correctly"))
if _email_notification_must_be_sent(file_category, request):
send_invoice_uploaded_email(admission)
display_success_messages(
request,
_("A notification email has been sent to the participant"))
except ManagerFileUploadExceptions as e:
display_error_messages(request, str(e))
except Exception as e:
display_error_messages(
request, _("A problem occured : the document is not uploaded"))
return redirect(
reverse('admission_detail', kwargs={'admission_id': admission.pk}) +
'#documents')
def _process_evaluations(request, cohort, evaluations):
registration_ids = [eval['registration_id'] for eval in evaluations]
valid_reg_ids, non_valid_reg_ids = _check_registration_ids_validity(
cohort, registration_ids)
if non_valid_reg_ids:
display_error_messages(
request,
_('Evaluation status importation aborted. '
'Following registration ids do not exist in cohort: %(registration_ids)s'
) % {'registration_ids': ', '.join(non_valid_reg_ids)})
else:
filtered_evaluations = [
eval for eval in evaluations
if eval['registration_id'] in valid_reg_ids
]
status_updated, info = _update_evaluation_status(
status=True, evaluations=filtered_evaluations, cohort=cohort)
if status_updated:
display_success_messages(
request,
_('Evaluation status successfully updated for %(periods)s' %
{'periods': ', '.join(info['periods'])}))
else:
period = info['period']
display_error_messages(
request,
_('An error occured during evaluation status update in {}').
format(period))
def learning_unit_edition_end_date(request, learning_unit_year_id):
learning_unit_year = get_object_or_404(LearningUnitYear,
pk=learning_unit_year_id)
person = get_object_or_404(Person, user=request.user)
context = get_learning_unit_identification_context(learning_unit_year_id,
person)
learning_unit_to_edit = learning_unit_year.learning_unit
form = LearningUnitEndDateForm(request.POST or None,
learning_unit=learning_unit_to_edit)
if form.is_valid():
try:
result = form.save()
display_success_messages(request, result, extra_tags='safe')
learning_unit_year_id = _get_current_learning_unit_year_id(
learning_unit_to_edit, learning_unit_year_id)
return HttpResponseRedirect(
reverse('learning_unit', args=[learning_unit_year_id]))
except IntegrityError as e:
display_error_messages(request, e.args[0])
context['form'] = form
return layout.render(request, 'learning_unit/update_end_date.html',
context)
def formation_edit(request, formation_id):
formation = get_object_or_404(ContinuingEducationTraining, pk=formation_id)
if _can_edit_formation(request, formation):
form = ContinuingEducationTrainingForm(request.POST or None,
user=request.user,
instance=formation)
address_form = AddressForm(request.POST or None,
instance=formation.postal_address)
if all([form.is_valid(), address_form.is_valid()]):
address = address_form.save()
formation = form.save(commit=False)
formation.postal_address = address
formation.save()
return redirect(
reverse('formation_detail',
kwargs={'formation_id': formation.education_group.id}))
return render(request, "formation_form.html", {
'formation': formation,
'form': form,
'address_form': address_form
})
else:
display_error_messages(
request, _("You are not authorized to edit this training"))
return redirect(
reverse('formation_detail',
kwargs={'formation_id': formation.education_group.id}))
def get_appropriate_sections(self):
sections = []
try:
sections = general_information.get_relevant_sections(self.object)
except RelevantSectionException as e:
display_error_messages(self.request, str(e))
return sections
def learning_units_summary_list(request):
a_user_person = find_by_user(request.user)
learning_units_found = []
initial_academic_year = current_academic_year()
if academic_calendar.is_academic_calendar_has_started(initial_academic_year, SUMMARY_COURSE_SUBMISSION):
initial_academic_year = initial_academic_year.next()
search_form = LearningUnitYearForm(request.GET or None, initial={'academic_year_id': initial_academic_year})
try:
if search_form.is_valid():
learning_units_found_search = search_form.get_learning_units(
requirement_entities=a_user_person.find_main_entities_version,
luy_status=True
)
learning_units_found = get_learning_units_and_summary_status(learning_units_found_search)
check_if_display_message(request, learning_units_found_search)
except TooManyResultsException:
display_error_messages(request, 'too_many_results')
responsible_and_learning_unit_yr_list = get_responsible_and_learning_unit_yr_list(learning_units_found)
learning_units = sorted(learning_units_found, key=lambda learning_yr: learning_yr.acronym)
errors = [can_learning_unit_year_educational_information_be_udpated(learning_unit_year_id=luy.id)
for luy in learning_units]
context = {
'form': search_form,
'formset': _get_formset(request, responsible_and_learning_unit_yr_list),
'learning_units_with_errors': list(zip(learning_units, errors)),
'experimental_phase': True,
'search_type': SUMMARY_LIST,
'is_faculty_manager': a_user_person.is_faculty_manager()
}
return layout.render(request, "learning_units.html", context)
def delete_all_learning_units_year(request, learning_unit_year_id):
learning_unit_year = get_object_or_404(LearningUnitYear,
pk=learning_unit_year_id)
learning_unit = learning_unit_year.learning_unit
messages_deletion = deletion.check_learning_unit_deletion(learning_unit)
if messages_deletion:
display_error_messages(request, sorted(messages_deletion.values()))
return redirect('learning_unit',
learning_unit_year_id=learning_unit_year.id)
try:
with transaction.atomic():
result = deletion.delete_learning_unit(learning_unit)
display_success_messages(
request,
_("The learning unit %(acronym)s has been successfully deleted for all years."
) % {'acronym': learning_unit.acronym})
display_success_messages(request, sorted(result))
send_mail_after_the_learning_unit_year_deletion([],
learning_unit.acronym,
None, result)
except (ProtectedError, IntegrityError) as e:
display_error_messages(request, str(e))
return redirect('learning_units')
def get_form_kwargs(self):
kwargs = super().get_form_kwargs()
if not self.strategy.is_valid():
display_error_messages(self.request, self.strategy.errors)
return kwargs
def learning_units_search(request, search_type):
service_course_search = search_type == SERVICE_COURSES_SEARCH
borrowed_course_search = search_type == BORROWED_COURSE
form = LearningUnitYearForm(
request.GET or None,
service_course_search=service_course_search,
borrowed_course_search=borrowed_course_search,
initial={'academic_year_id': starting_academic_year()}
)
found_learning_units = LearningUnitYear.objects.none()
try:
if form.is_valid():
found_learning_units = form.get_activity_learning_units()
check_if_display_message(request, found_learning_units)
except TooManyResultsException:
display_error_messages(request, 'too_many_results')
if request.POST.get('xls_status') == "xls":
return create_xls(request.user, found_learning_units, _get_filter(form, search_type))
if request.POST.get('xls_status') == "xls_comparison":
return create_xls_comparison(
request.user,
found_learning_units,
_get_filter(form, search_type),
request.POST.get('comparison_year')
)
if request.POST.get('xls_status') == "xls_with_parameters":
return create_xls_with_parameters(
request.user,
found_learning_units,
_get_filter(form, search_type),
{
WITH_GRP: request.POST.get('with_grp') == 'true',
WITH_ATTRIBUTIONS: request.POST.get('with_attributions') == 'true'
}
)
form_comparison = SelectComparisonYears(academic_year=get_academic_year_of_reference(found_learning_units))
context = {
'form': form,
'academic_years': get_last_academic_years(),
'container_types': learning_container_year_types.LEARNING_CONTAINER_YEAR_TYPES,
'types': learning_unit_year_subtypes.LEARNING_UNIT_YEAR_SUBTYPES,
'learning_units_count': len(found_learning_units)
if isinstance(found_learning_units, list) else
found_learning_units.count(),
'current_academic_year': starting_academic_year(),
'experimental_phase': True,
'search_type': search_type,
'is_faculty_manager': request.user.person.is_faculty_manager,
'form_comparison': form_comparison,
'page_obj': paginate_queryset(found_learning_units, request.GET),
}
return render(request, "learning_units.html", context)
def manager_offer_parameters_edit(request):
list_offer_prop = get_list_or_404(OfferProposition,
pk__in=request.GET.getlist('pk'))
list_form_valid = []
forms = []
for offer_prop in list_offer_prop:
form = ManagerOfferPropositionForm(request.POST or None,
instance=offer_prop)
forms.append(form)
list_form_valid.append(form.is_valid())
if form.errors:
errors = form.non_field_errors().as_ul()
display_error_messages(request, errors, extra_tags='safe')
return render(request, "manager_offer_parameters_edit.html", {
'list_offer_proposition': list_offer_prop,
'form': forms[0]
})
if all(list_form_valid):
for form in forms:
form.save()
return redirect('manager_offer_parameters')
return render(request, "manager_offer_parameters_edit.html", {
'list_offer_proposition': list_offer_prop,
'form': forms[0]
})
def send_admission_to_queue(request, admission):
data = get_json_for_epc(admission)
credentials = pika.PlainCredentials(settings.QUEUES.get('QUEUE_USER'),
settings.QUEUES.get('QUEUE_PASSWORD'))
rabbit_settings = pika.ConnectionParameters(
settings.QUEUES.get('QUEUE_URL'), settings.QUEUES.get('QUEUE_PORT'),
settings.QUEUES.get('QUEUE_CONTEXT_ROOT'), credentials)
try:
connect = pika.BlockingConnection(rabbit_settings)
channel = connect.channel()
queue_name = settings.QUEUES.get('QUEUES_NAME').get('IUFC_TO_EPC')
send_message(queue_name, data, connect, channel)
admission.ucl_registration_complete = UCLRegistrationState.SENDED.name
save_and_create_revision(
get_revision_messages(UCL_REGISTRATION_SENDED), admission,
request.user)
except (RuntimeError, pika.exceptions.ConnectionClosed,
pika.exceptions.ChannelClosed, pika.exceptions.AMQPError):
logger.exception(
_('Could not send admission json with uuid %(uuid)s in queue') %
{'uuid': admission.uuid})
display_error_messages(
request,
_('Could not send admission json with uuid %(uuid)s in queue') %
{'uuid': admission.uuid})
def learning_unit_edition(request, learning_unit_year_id):
learning_unit_year = get_object_or_404(LearningUnitYear,
pk=learning_unit_year_id)
user_person = get_object_or_404(Person, user=request.user)
context = get_learning_unit_identification_context(learning_unit_year_id,
user_person)
learning_unit_to_edit = learning_unit_year.learning_unit
form = LearningUnitEndDateForm(request.POST or None,
learning_unit=learning_unit_to_edit)
if form.is_valid():
new_academic_year = form.cleaned_data['academic_year']
try:
result = edit_learning_unit_end_date(learning_unit_to_edit,
new_academic_year)
display_success_messages(request, result)
learning_unit_year_id = _get_current_learning_unit_year_id(
learning_unit_to_edit, learning_unit_year_id)
return HttpResponseRedirect(
reverse('learning_unit', args=[learning_unit_year_id]))
except IntegrityError as e:
display_error_messages(request, e.args[0])
context['form'] = form
return layout.render(request, 'learning_unit/edition.html', context)
def _upload_eval_file(request, cohort):
if request.method == 'POST':
file_name = request.FILES['file_upload']
if file_name and ".xlsx" not in str(file_name):
display_error_messages(request, _('File extension must be .xlsx'))
else:
evaluations = import_eval.import_xlsx(file_name)
_process_evaluations(request, cohort, evaluations)
def check_file_format(request, titles_rows):
if len(titles_rows) != COLS_NUMBER:
display_error_messages(request, _('columns_number_error'))
return False
if titles_rows != COLS_TITLES:
display_error_messages(request, _('columns_title_error'))
return False
return True
def upload_mandates_file(request):
global ASSISTANTS_IMPORTED, ASSISTANTS_UPDATED, MANDATES_IMPORTED, MANDATES_UPDATED, PERSONS_NOT_FOUND
form = MandateFileForm(request.POST, request.FILES)
if form.is_valid() and request.FILES['file']:
read_xls_mandates(request, request.FILES['file'])
else:
display_error_messages(request, [error_msg for error_msgs in form.errors.values() for error_msg in error_msgs])
return show_import_result(request)
def _validate_admission(request, adm_form):
if request.user.has_perm("continuing_education.validate_registration"):
save_state_changed_and_send_email(adm_form.instance, request.user)
else:
display_error_messages(
request,
_("Continuing education managers and student workers only are allowed to validate a registration")
)
def check_file_format(request, titles_rows):
if len(titles_rows) != COLS_NUMBER:
display_error_messages(request, _('columns_number_error'))
return False
if titles_rows != COLS_TITLES:
display_error_messages(request, _('columns_title_error'))
return False
return True
def delete_file(request, admission_id, file_id):
file = AdmissionFile.objects.filter(id=file_id)
try:
file.delete()
display_success_messages(request, _("File correctly deleted"))
except Exception as e:
display_error_messages(request, _("A problem occured during delete"))
return redirect(reverse('admission_detail', kwargs={'admission_id': admission_id}) + '#documents')
def check_file_format(request, titles_rows):
if len(titles_rows) != COLS_NUMBER:
display_error_messages(request, _('The number of cols is wrong.'))
return False
if titles_rows != COLS_TITLES:
display_error_messages(request, _('The cols title are wrong.'))
return False
return True
def read_xls_mandates(request, file_name):
try:
workbook = load_workbook(file_name, read_only=True, data_only=True)
except KeyError:
display_error_messages(request, _('file_must_be_xlsx'))
return False
first_sheet = workbook.get_sheet_names()[0]
worksheet = workbook.get_sheet_by_name(first_sheet)
titles_row = []
current_row = 1
for row in worksheet.iter_rows():
if current_row == 1:
titles_row = save_xls_rows_titles(row)
if check_file_format(request, titles_row) is False:
return False
else:
current_record = xls_row_to_dict(row, titles_row)
end_date = check_date_format(current_record.get('END_DATE'))
entry_date = check_date_format(current_record.get('ENTRY_DATE'))
if end_date is False or entry_date is False:
display_error_messages(request, _('date_format_error') + _('line_nbr') + str(current_row))
return False
assistant = create_academic_assistant_if_not_exists(current_record)
if assistant:
mandate = create_assistant_mandate_if_not_exists(current_record, assistant, entry_date, end_date)
sector = search_entity_by_acronym_and_type(
current_record.get('SECTOR'),
entity_type.SECTOR
)
if sector:
link_mandate_to_entity(mandate, sector)
logistic_entity = search_entity_by_acronym_and_type(
current_record.get('LOGISTICS_ENTITY'),
entity_type.LOGISTICS_ENTITY
)
if logistic_entity:
link_mandate_to_entity(mandate, logistic_entity)
faculty = search_entity_by_acronym_and_type(current_record.get('FACULTY'),
entity_type.FACULTY)
if faculty:
link_mandate_to_entity(mandate, faculty)
school = search_entity_by_acronym_and_type(
current_record.get('SCHOOL'),
entity_type.SCHOOL
)
if school:
link_mandate_to_entity(mandate, school)
institute = search_entity_by_acronym_and_type(
current_record.get('INSTITUTE'),
entity_type.INSTITUTE)
if institute:
link_mandate_to_entity(mandate, institute)
pole = search_entity_by_acronym_and_type(current_record.get('POLE'), entity_type.POLE)
if pole:
link_mandate_to_entity(mandate, pole)
current_row += 1
return True
def send_invoice_notification_mail(request, admission_id):
admission = get_object_or_404(Admission, pk=admission_id)
if _invoice_file_exists_for_admission(admission):
send_invoice_uploaded_email(admission)
display_success_messages(request, _("A notification email has been sent to the participant"))
else:
display_error_messages(request, _("There is no invoice for this admission, notification email not sent"))
return redirect(reverse('admission_detail', kwargs={'admission_id': admission.pk}) + '#documents')
def read_xls_mandates(request, file_name):
try:
workbook = load_workbook(file_name, read_only=True, data_only=True)
except KeyError:
display_error_messages(request, _('File must be xlsx'))
return False
first_sheet = workbook.get_sheet_names()[0]
worksheet = workbook.get_sheet_by_name(first_sheet)
titles_row = []
current_row = 1
for row in worksheet.iter_rows():
if current_row == 1:
titles_row = save_xls_rows_titles(row)
if check_file_format(request, titles_row) is False:
return False
else:
current_record = xls_row_to_dict(row, titles_row)
end_date = check_date_format(current_record.get('END_DATE'))
entry_date = check_date_format(current_record.get('ENTRY_DATE'))
if end_date is False or entry_date is False:
display_error_messages(
request,
_('A date is invalid in the file') +
_(' at line number : ') + str(current_row))
return False
assistant = create_academic_assistant_if_not_exists(current_record)
if assistant:
mandate = create_assistant_mandate_if_not_exists(
current_record, assistant, entry_date, end_date)
sector = search_entity_by_acronym_and_type(
current_record.get('SECTOR'), entity_type.SECTOR)
if sector:
link_mandate_to_entity(mandate, sector)
logistic_entity = search_entity_by_acronym_and_type(
current_record.get('LOGISTICS_ENTITY'),
entity_type.LOGISTICS_ENTITY)
if logistic_entity:
link_mandate_to_entity(mandate, logistic_entity)
faculty = search_entity_by_acronym_and_type(
current_record.get('FACULTY'), entity_type.FACULTY)
if faculty:
link_mandate_to_entity(mandate, faculty)
school = search_entity_by_acronym_and_type(
current_record.get('SCHOOL'), entity_type.SCHOOL)
if school:
link_mandate_to_entity(mandate, school)
institute = search_entity_by_acronym_and_type(
current_record.get('INSTITUTE'), entity_type.INSTITUTE)
if institute:
link_mandate_to_entity(mandate, institute)
pole = search_entity_by_acronym_and_type(
current_record.get('POLE'), entity_type.POLE)
if pole:
link_mandate_to_entity(mandate, pole)
current_row += 1
return True
def _check_credits(request, learning_unit_year_parent, form):
luy_credits = form.cleaned_data['credits']
luy_subtype = form.cleaned_data['subtype']
if luy_subtype == 'PARTIM' and learning_unit_year_parent:
if luy_credits > learning_unit_year_parent.credits:
display_error_messages(request,
_('partim_credits_gt_parent_credits'))
elif luy_credits == learning_unit_year_parent.credits:
display_error_messages(request,
_('partim_credits_equals_parent_credits'))
def learning_units_summary_list(request):
a_user_person = request.user.person
found_learning_units = LearningUnitYear.objects.none()
initial_academic_year = current_academic_year()
if academic_calendar.is_academic_calendar_has_started(
initial_academic_year, SUMMARY_COURSE_SUBMISSION):
initial_academic_year = initial_academic_year.next()
search_form = LearningUnitYearForm(request.GET or None,
initial={
'academic_year_id':
initial_academic_year,
'with_entity_subordinated': True
})
try:
if search_form.is_valid():
found_learning_units = search_form.get_learning_units_and_summary_status(
requirement_entities=a_user_person.find_main_entities_version,
)
check_if_display_message(request, found_learning_units)
except TooManyResultsException:
display_error_messages(request, 'too_many_results')
responsible_and_learning_unit_yr_list = get_responsible_and_learning_unit_yr_list(
found_learning_units)
for luy in found_learning_units:
luy.errors = can_learning_unit_year_educational_information_be_udpated(
learning_unit_year_id=luy)
if request.GET.get('xls_status') == "xls_teaching_material":
try:
return generate_xls_teaching_material(request.user,
found_learning_units)
except ObjectDoesNotExist:
display_warning_messages(
request,
_("the list to generate is empty.").capitalize())
form_comparison = SelectComparisonYears(
academic_year=get_academic_year_of_reference(found_learning_units))
context = {
'form': search_form,
'formset': _get_formset(request,
responsible_and_learning_unit_yr_list),
'learning_units_count': found_learning_units.count(),
'search_type': SUMMARY_LIST,
'is_faculty_manager': a_user_person.is_faculty_manager,
'form_comparison': form_comparison,
'page_obj': paginate_queryset(found_learning_units, request.GET),
}
return render(request, "learning_units.html", context)
def learning_units_summary_list(request):
a_user_person = find_by_user(request.user)
learning_units_found = []
initial_academic_year = current_academic_year()
if academic_calendar.is_academic_calendar_has_started(
initial_academic_year, SUMMARY_COURSE_SUBMISSION):
initial_academic_year = initial_academic_year.next()
search_form = LearningUnitYearForm(
request.GET or None,
initial={'academic_year_id': initial_academic_year})
try:
if search_form.is_valid():
learning_units_found_search = search_form.get_learning_units(
requirement_entities=a_user_person.find_main_entities_version,
luy_status=True)
# TODO refactoring : too many queries
learning_units_found = get_learning_units_and_summary_status(
learning_units_found_search)
check_if_display_message(request, learning_units_found_search)
except TooManyResultsException:
display_error_messages(request, 'too_many_results')
responsible_and_learning_unit_yr_list = get_responsible_and_learning_unit_yr_list(
learning_units_found)
learning_units = sorted(learning_units_found,
key=lambda learning_yr: learning_yr.acronym)
errors = [
can_learning_unit_year_educational_information_be_udpated(
learning_unit_year_id=luy.id) for luy in learning_units
]
if request.GET.get('xls_status') == "xls_teaching_material":
try:
return generate_xls_teaching_material(request.user,
learning_units_found)
except ObjectDoesNotExist:
display_warning_messages(
request,
_("the list to generate is empty.").capitalize())
form_comparison = SelectComparisonYears(
academic_year=get_academic_year_of_reference(learning_units_found))
context = {
'form': search_form,
'formset': _get_formset(request,
responsible_and_learning_unit_yr_list),
'learning_units_with_errors': list(zip(learning_units, errors)),
'search_type': SUMMARY_LIST,
'is_faculty_manager': a_user_person.is_faculty_manager(),
'form_comparison': form_comparison
}
return layout.render(request, "learning_units.html", context)
def upload_mandates_file(request):
global ASSISTANTS_IMPORTED, ASSISTANTS_UPDATED, MANDATES_IMPORTED, MANDATES_UPDATED, PERSONS_NOT_FOUND
form = MandateFileForm(request.POST, request.FILES)
if form.is_valid() and request.FILES['file']:
read_xls_mandates(request, request.FILES['file'])
else:
display_error_messages(request, [
error_msg for error_msgs in form.errors.values()
for error_msg in error_msgs
])
return show_import_result(request)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
if self.strategy.is_valid():
context['confirmation_message'] = _(
"Are you sure you want to detach %(acronym)s ?") % {
"acronym": self.object.child.acronym
}
display_warning_messages(self.request, self.strategy.warnings)
else:
display_error_messages(self.request, self.strategy.errors)
return context
def apply_learning_unit_year_postponement(self, request, queryset):
# Potential circular imports
from base.business.learning_units.automatic_postponement import LearningUnitAutomaticPostponementToN6
from base.views.common import display_success_messages, display_error_messages
result, errors = LearningUnitAutomaticPostponementToN6(queryset).postpone()
count = len(result)
display_success_messages(
request, ngettext(
'%(count)d learning unit has been postponed with success',
'%(count)d learning units have been postponed with success', count
) % {'count': count}
)
if errors:
display_error_messages(request, "{} : {}".format(
_("The following learning units ended with error"),
", ".join([str(error) for error in errors])
))
def copy_reddot_data(self, request, queryset):
# Potential circular imports
from base.business.education_groups.automatic_postponement import ReddotEducationGroupAutomaticPostponement
from base.views.common import display_success_messages, display_error_messages
result, errors = ReddotEducationGroupAutomaticPostponement(queryset).postpone()
count = len(result)
display_success_messages(
request, ngettext(
"%(count)d education group has been updated with success.",
"%(count)d education groups have been updated with success.", count
) % {'count': count}
)
if errors:
display_error_messages(request, "{} : {}".format(
_("The following education groups ended with error"),
", ".join([str(error) for error in errors])
))
