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 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]) ))