def mandate_save(request): mandate_id = request.POST.get("mandate_id") mandate = assistant_mdl.assistant_mandate.find_mandate_by_id(mandate_id) if request.POST.get('del_rev'): mandate.assistant.supervisor = None mandate.assistant.save() elif request.POST.get('person_id'): try: substitute_supervisor = person.find_by_id(request.POST.get('person_id')) if substitute_supervisor: mandate.assistant.supervisor = substitute_supervisor mandate.assistant.save() html_template_ref = 'assistant_phd_supervisor_html' txt_template_ref = 'assistant_phd_supervisor_txt' send_message(person=substitute_supervisor, html_template_ref=html_template_ref, txt_template_ref=txt_template_ref, assistant=mandate.assistant) except ObjectDoesNotExist: pass form = MandateForm(data=request.POST, instance=mandate, prefix='mand') formset = entity_inline_formset(request.POST, request.FILES, instance=mandate, prefix='entity') if form.is_valid(): form.save() if formset.is_valid(): formset.save() return mandate_edit(request) else: return layout.render(request, "mandate_form.html", {'mandate': mandate, 'form': form, 'formset': formset}) else: return layout.render(request, "mandate_form.html", {'mandate': mandate, 'form': form, 'formset': formset})
def dissertation_jury_new(request, pk): dissert = get_object_or_404(dissertation.Dissertation, pk=pk) if dissert.author_is_logged_student(request): count_dissertation_role = dissertation_role.count_by_dissertation(dissert) count_reader = dissertation_role.count_reader_by_dissertation(dissert) offer_pro = offer_proposition.search_by_offer(dissert.offer_year_start.offer) if offer_pro.student_can_manage_readers and count_dissertation_role < 5 and count_reader < 3: if request.method == "POST": form = DissertationRoleForm(request.POST) if form.is_valid(): data = form.cleaned_data if not dissertation_role.count_by_status_student_dissertation(data['status'], data['adviser'], data['dissertation']): form.save() justification = "%s %s" % ("student_add_reader", data['adviser']) dissertation_update.add(request, dissert, dissert.status, justification=justification) return redirect('dissertation_detail', pk=dissert.pk) else: form = DissertationRoleForm(initial={'status': "READER", 'dissertation': dissert}) return layout.render(request, 'dissertation_reader_edit.html', {'form': form}) else: return redirect('dissertation_detail', pk=dissert.pk) else: return redirect('dissertations')
def dissertation_to_dir_submit(request, pk): memory = get_object_or_404(dissertation.Dissertation, pk=pk) person = mdl.person.find_by_user(request.user) student = mdl.student.find_by_person(person) submitted_memories_count = dissertation.count_submit_by_user(student, memory.offer_year_start.offer) if memory.author_is_logged_student(request) and submitted_memories_count == 0: old_status = memory.status new_status = dissertation.get_next_status(memory, "go_forward") status_dict = dict(dissertation.STATUS_CHOICES) new_status_display = status_dict[new_status] if request.method == "POST": form = DissertationUpdateForm(request.POST) if form.is_valid(): memory.go_forward() data = form.cleaned_data justification = data['justification'] dissertation_update.add(request, memory, old_status, justification=justification) return redirect('dissertation_detail', pk=pk) else: form = DissertationUpdateForm() return layout.render(request, 'dissertation_add_justification.html', {'form': form, 'dissertation': memory, "new_status_display": new_status_display}) else: return redirect('dissertations')
def dissertation_new(request): person = mdl.person.find_by_user(request.user) student = mdl.student.find_by_person(person) offers = mdl.offer.find_by_student(student) offer_propositions = offer_proposition.search_by_offers(offers) date_now = timezone.now().date() if any(o.start_visibility_dissertation <= date_now <= o.end_visibility_dissertation for o in offer_propositions): if request.method == "POST": form = DissertationForm(request.POST) if form.is_valid(): memory = form.save() dissertation_update.add(request, memory, memory.status, justification="student_creation_dissertation") return redirect('dissertation_detail', pk=memory.pk) else: form.fields["offer_year_start"].queryset = offer_year.find_by_student_enrollment(student) form.fields["proposition_dissertation"].queryset = proposition_dissertation.search_by_offers(offers) else: form = DissertationForm(initial={'active': True, 'author': student}) form.fields["offer_year_start"].queryset = offer_year.find_by_student_enrollment(student) form.fields["proposition_dissertation"].queryset = proposition_dissertation.search_by_offers(offers) return layout.render(request, 'dissertation_form.html', {'form': form, 'defend_periode_choices': dissertation.DEFEND_PERIODE_CHOICES}) else: return redirect('dissertations')
def dissertations_search(request): person = mdl.person.find_by_user(request.user) student = mdl.student.find_by_person(person) memories = dissertation.search(terms=request.GET['search'], author=student) return layout.render(request, "dissertations_list.html", {'student': student, 'dissertations': memories})
def dissertation_history(request, pk): memory = get_object_or_404(dissertation.Dissertation, pk=pk) if memory.author_is_logged_student(request): dissertation_updates = dissertation_update.search_by_dissertation(memory) return layout.render(request, 'dissertation_history.html', {'dissertation': memory, 'dissertation_updates': dissertation_updates}) else: return redirect('dissertations')
def proposition_dissertations_search(request): person = mdl.person.find_by_user(request.user) student = mdl.student.find_by_person(person) offers = mdl.offer.find_by_student(student) proposition_offers = proposition_offer.search(offers=offers, terms=request.GET['search'], active=True, visibility=True) date_now = timezone.now().date() return layout.render(request, 'proposition_dissertations_list.html', {'date_now': date_now, 'proposition_offers': proposition_offers, 'student': student})
def proposition_dissertations(request): person = mdl.person.find_by_user(request.user) student = mdl.student.find_by_person(person) offers = mdl.offer.find_by_student(student) proposition_offers = proposition_offer.find_by_offers_ordered_by_proposition_dissertation(offers) date_now = timezone.now().date() return layout.render(request, 'proposition_dissertations_list.html', {'date_now': date_now, 'proposition_offers': proposition_offers, 'student': student})
def settings_save(request): global_settings = settings.get_settings() form = SettingsForm(data=request.POST, instance=global_settings, prefix='set') if form.is_valid(): form.save() return settings_edit(request) else: year = academic_year.current_academic_year().year return layout.render(request, 'settings.html', {'year': year, 'form': form})
def dissertation_edit(request, pk): memory = get_object_or_404(dissertation.Dissertation, pk=pk) person = mdl.person.find_by_user(request.user) student = mdl.student.find_by_person(person) if memory.author_is_logged_student(request): offers = mdl.offer.find_by_student(student) offer_pro = offer_proposition.search_by_offer(memory.offer_year_start.offer) if memory.status == 'DRAFT' or memory.status == 'DIR_KO': if request.method == "POST": form = DissertationEditForm(request.POST, instance=memory) if form.is_valid(): memory = form.save() dissertation_update.add(request, memory, memory.status, justification="student_edit_dissertation") return redirect('dissertation_detail', pk=memory.pk) else: form.fields["offer_year_start"].queryset = offer_year.find_by_offer(offers) form.fields["proposition_dissertation"].queryset = proposition_dissertation.search_by_offers(offers) else: form = DissertationEditForm(instance=memory) form.fields["offer_year_start"].queryset = offer_year.find_by_offer(offers) form.fields["proposition_dissertation"].queryset = proposition_dissertation.search_by_offers(offers) return layout.render(request, 'dissertation_edit_form.html', {'form': form, 'defend_periode_choices': dissertation.DEFEND_PERIODE_CHOICES}) else: if offer_pro.start_edit_title <= timezone.now().date() <= offer_pro.end_edit_title: if request.method == "POST": form = DissertationTitleForm(request.POST, instance=memory) if form.is_valid(): memory = form.save() dissertation_update.add(request, memory, memory.status, justification="student_edit_title") return redirect('dissertation_detail', pk=memory.pk) else: form = DissertationTitleForm(instance=memory) return layout.render(request, 'dissertation_title_form.html', {'form': form}) else: return redirect('dissertation_detail', pk=memory.pk) else: return redirect('dissertations')
def scores_responsible_management(request): context = { 'course_code': request.GET.get('course_code'), 'learning_unit_title': request.GET.get('learning_unit_title'), 'tutor': request.GET.get('tutor'), 'scores_responsible': request.GET.get('scores_responsible') } learning_unit_year_id = request.GET.get('learning_unit_year').strip( 'learning_unit_year_') attributions_data = get_attributions_data(request.user, learning_unit_year_id) context.update(attributions_data) return layout.render(request, 'scores_responsible_edit.html', context)
def delete_from_given_learning_unit_year(request, learning_unit_year_id): person = get_object_or_404(Person, user=request.user) learning_unit_year = mdl.learning_unit_year.get_by_id( learning_unit_year_id) if not can_delete_learning_unit_year(learning_unit_year, person): return HttpResponseForbidden() messages_deletion = learning_unit_deletion.check_learning_unit_year_deletion( learning_unit_year) if not messages_deletion and request.method == 'POST': try: result = learning_unit_deletion.delete_from_given_learning_unit_year( learning_unit_year) success_msg = _("You asked the deletion of the learning unit %(acronym)s from the year %(year)s") \ % {'acronym': learning_unit_year.acronym, 'year': learning_unit_year.academic_year} messages.add_message(request, messages.SUCCESS, success_msg) for msg in sorted(result): messages.add_message(request, messages.SUCCESS, msg) send_mail_after_the_learning_unit_year_deletion( [], learning_unit_year.acronym, learning_unit_year.academic_year, result) except ProtectedError as e: messages.add_message(request, messages.ERROR, str(e)) return redirect('learning_units') else: if messages_deletion: context = { 'title': _("cannot_delete_learning_unit_year") % { 'learning_unit': learning_unit_year.acronym, 'year': learning_unit_year.academic_year }, 'messages_deletion': sorted(messages_deletion.values()) } else: learning_units_to_delete = learning_unit_year.find_gte_learning_units_year( ) context = { 'title': _("msg_warning_delete_learning_unit") % learning_unit_year, 'learning_units_to_delete': learning_units_to_delete } return layout.render(request, "learning_unit/deletion.html", context)
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 = [] try: if form.is_valid(): found_learning_units = form.get_activity_learning_units() check_if_display_message(request, found_learning_units) except TooManyResultsException: messages.add_message(request, messages.ERROR, _('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_attribution": return create_xls_attribution(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'}) a_person = find_by_user(request.user) 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': found_learning_units, 'current_academic_year': starting_academic_year(), 'experimental_phase': True, 'search_type': search_type, 'is_faculty_manager': a_person.is_faculty_manager(), 'form_comparison': form_comparison } return layout.render(request, "learning_units.html", context)
def dissertations_detail_updates(request, pk): dissert = dissertation.find_by_id(pk) if dissert is None: return redirect('dissertations_list') person = mdl.person.find_by_user(request.user) adv = adviser.search_by_person(person) if teacher_is_promotor(adv, dissert): dissertation_updates = dissertation_update.search_by_dissertation(dissert) return layout.render(request, 'dissertations_detail_updates.html', {'dissertation': dissert, 'adviser': adv, 'dissertation_updates': dissertation_updates}) else: return redirect('dissertations_list')
def visualize_student_programs(request, registration_id): """ View to visualize a particular student list of academic programs. !!! Should only be accessible for staff having the rights. """ stud = student.find_by_registration_id(registration_id) list_student_programs = None if stud: list_student_programs = get_student_programs_list(stud) return layout.render(request, "performance_home.html", { "student": stud, "programs": list_student_programs })
def settings_save(request): global_settings = settings.get_settings() form = SettingsForm(data=request.POST, instance=global_settings, prefix='set') if form.is_valid(): form.save() return settings_edit(request) else: year = academic_year.current_academic_year().year return layout.render(request, 'settings.html', { 'year': year, 'form': form })
def _update_or_create_proposal(request, learning_unit_year, proposal=None): person = get_object_or_404(Person, user=request.user) proposal_base_form = ProposalBaseForm(request.POST or None, person, learning_unit_year, proposal) if proposal_base_form.is_valid(): proposal = proposal_base_form.save() display_success_messages( request, _("success_modification_proposal").format( _(proposal.type), learning_unit_year.acronym)) return redirect('learning_unit', learning_unit_year_id=learning_unit_year.id) context = proposal_base_form.get_context() if proposal: return layout.render( request, 'learning_unit/proposal/update_modification.html', context) return layout.render(request, 'learning_unit/proposal/create_modification.html', context)
def home(request): return layout.render( request, "dashboard.html", { 'online_application_opened': permission.is_online_application_opened(request.user), 'summary_course_submission_opened': permission.is_summary_course_submission_opened(request.user), 'is_summary_responsible': permission.is_summary_responsible(request.user), 'manage_courses_url': settings.OSIS_MANAGE_COURSES_URL, 'osis_vpn_help_url': settings.OSIS_VPN_HELP_URL })
def display_result_for_specific_student_performance(request, pk): """ Display the student result for a particular year and program. """ try: stud = student.find_by_user(request.user) except MultipleObjectsReturned: return dash_main_view.show_multiple_registration_id_error(request) stud_perf = mdl_performance.student_performance.find_actual_by_pk(pk) if not check_right_access(stud_perf, stud): raise PermissionDenied perf_data = __get_performance_data(stud_perf) return layout.render(request, "performance_result_student.html", perf_data)
def select_student(request): """ View to select a student to visualize his/her results. !!! Should only be open for staff having the rights. """ if request.method == "POST": form = RegistrationIdForm(request.POST) if form.is_valid(): registration_id = form.cleaned_data['registration_id'] return redirect(student_programs, registration_id=registration_id) else: form = RegistrationIdForm() return layout.render(request, "admin/performance_select_student.html", {"form": form})
def delete_view(request, learning_unit_year_id, teaching_material_id, success_url): teach_material = get_object_or_404( TeachingMaterial, pk=teaching_material_id, learning_unit_year_id=learning_unit_year_id) if request.method == 'POST': delete_teaching_material(teach_material) display_success_messages(request, "The teaching material has been deleted") return redirect(success_url) return layout.render(request, "learning_unit/teaching_material/modal_delete.html", {})
def delete_all_learning_units_year(request, learning_unit_year_id): person = get_object_or_404(Person, user=request.user) learning_unit_year = mdl.learning_unit_year.get_by_id( learning_unit_year_id) if not can_delete_learning_unit_year(learning_unit_year, person): return HttpResponseForbidden() learning_unit = learning_unit_year.learning_unit messages_deletion = learning_unit_deletion.check_learning_unit_deletion( learning_unit) if not messages_deletion and request.method == 'POST': try: result = learning_unit_deletion.delete_learning_unit(learning_unit) messages.add_message( request, messages.SUCCESS, _("The learning unit %(acronym)s has been successfully deleted for all years." ) % {'acronym': learning_unit.acronym}) for message_deletion in sorted(result): messages.add_message(request, messages.SUCCESS, message_deletion) send_mail_after_the_learning_unit_year_deletion( [], learning_unit.acronym, None, result) except ProtectedError as e: messages.add_message(request, messages.ERROR, str(e)) return redirect('learning_units') else: if messages_deletion: context = { 'title': _('cannot_delete_learning_unit') % { 'learning_unit': learning_unit.acronym }, 'messages_deletion': sorted(messages_deletion.values()) } else: context = { 'title': _('msg_warning_delete_learning_unit') % learning_unit, 'learning_units_to_delete': learning_unit_year_mdl.search(learning_unit=learning_unit). order_by('academic_year__year') } return layout.render(request, "learning_unit/deletion.html", context)
def manager_offer_parameters_edit(request, pk): offer_prop = offer_proposition.find_by_id(pk) if offer_prop is None: return redirect('dissertations') if request.method == "POST": form = ManagerOfferPropositionForm(request.POST, instance=offer_prop) if form.is_valid(): form.save() return redirect('manager_offer_parameters') else: form = ManagerOfferPropositionForm(instance=offer_prop) return layout.render(request, "manager_offer_parameters_edit.html", { 'offer_proposition': offer_prop, 'form': form })
def manager_informations_detail_list_wait(request, pk): person = mdl.person.find_by_user(request.user) connected_adviser = adviser.search_by_person(person) offers = faculty_adviser.search_by_adviser(connected_adviser) adv = adviser.get_by_id(pk) if adv is None: return redirect('manager_informations') disserts_role = dissertation_role.search_by_adviser_and_role_and_waiting( adv, offers) return layout.render(request, "manager_informations_detail_list_wait.html", { 'disserts_role': disserts_role, 'adviser': adv })
def home(request): try: student = student_mdl.find_by_user(request.user) except MultipleObjectsReturned: logger.exception('User {} returned multiple students.'.format( request.user.username)) return dash_main_view.show_multiple_registration_id_error(request) if student: json_message = _make_registration_json_message(student.registration_id) attestation_statuses_json_dict = student_attestation_status.fetch_json_attestation_statuses( json_message) else: attestation_statuses_json_dict = None data = _make_attestation_data(attestation_statuses_json_dict, student) return layout.render(request, "attestation_home_student.html", data)
def scores_responsible_search(request): entities_manager = mdl_base.entity_manager.find_by_user(request.user) academic_year = mdl_base.academic_year.current_academic_year() _append_entity_version(entities_manager, academic_year) if request.GET: entities = [ entity_manager.entity for entity_manager in entities_manager ] entities_with_descendants = mdl_base.entity.find_descendants(entities) attributions = list( mdl_attr.attribution.search_scores_responsible( learning_unit_title=request.GET.get('learning_unit_title'), course_code=request.GET.get('course_code'), entities=entities_with_descendants, tutor=request.GET.get('tutor'), responsible=request.GET.get('scores_responsible'))) dict_attribution = get_attributions_list(attributions) return layout.render( request, 'scores_responsible.html', { "entities_manager": entities_manager, "academic_year": academic_year, "dict_attribution": dict_attribution, "learning_unit_title": request.GET.get('learning_unit_title'), "course_code": request.GET.get('course_code'), "tutor": request.GET.get('tutor'), "scores_responsible": request.GET.get('scores_responsible'), "init": "1" }) else: return layout.render( request, 'scores_responsible.html', { "entities_manager": entities_manager, "academic_year": academic_year, "init": "0" })
def update_view(request, learning_unit_year_id, teaching_material_id, success_url): teach_material = get_object_or_404( TeachingMaterial, pk=teaching_material_id, learning_unit_year_id=learning_unit_year_id) form = TeachingMaterialModelForm(request.POST or None, instance=teach_material) if form.is_valid(): return _save_and_redirect(request, form, teach_material.learning_unit_year, success_url) return layout.render(request, "learning_unit/teaching_material/modal_edit.html", {'form': form})
def proposition_dissertations_search(request): person = mdl.person.find_by_user(request.user) student = mdl.student.find_by_person(person) offers = mdl.offer.find_by_student(student) proposition_offers = proposition_offer.search(offers=offers, terms=request.GET['search'], active=True, visibility=True) date_now = timezone.now().date() return layout.render( request, 'proposition_dissertations_list.html', { 'date_now': date_now, 'proposition_offers': proposition_offers, 'student': student })
def _update_mini_training(request, education_group_year, root): # TODO :: IMPORTANT :: Fix urls patterns to get the GroupElementYear_id and the root_id in the url path ! # TODO :: IMPORTANT :: Need to upodate form to filter on list of parents, not only on the first direct parent form = MiniTrainingForm(request.POST or None, instance=education_group_year) if form.is_valid(): return _common_success_redirect(request, form.save(), root) return layout.render( request, "education_group/update_minitrainings.html", { "form_education_group_year": form.forms[forms.ModelForm], "education_group_year": education_group_year, "form_education_group": form.forms[EducationGroupModelForm] })
def mandate_edit(request): mandate_id = request.POST.get("mandate_id") mandate = assistant_mdl.assistant_mandate.find_mandate_by_id(mandate_id) supervisor = mandate.assistant.supervisor form = MandateForm(initial={'comment': mandate.comment, 'renewal_type': mandate.renewal_type, 'absences': mandate.absences, 'other_status': mandate.other_status, 'contract_duration': mandate.contract_duration, 'contract_duration_fte': mandate.contract_duration_fte }, prefix="mand", instance=mandate) formset = entity_inline_formset(instance=mandate, prefix="entity") return layout.render(request, 'mandate_form.html', {'mandate': mandate, 'form': form, 'formset': formset, 'assistant_mandate_state': assistant_mandate_state, 'supervisor': supervisor})
def dissertations(request): person = mdl.person.find_by_user(request.user) student = mdl.student.find_by_person(person) offers = mdl.offer.find_by_student(student) offer_propositions = offer_proposition.search_by_offers(offers) memories = dissertation.find_by_user(student) date_now = timezone.now().date() visibility = False for offer_pro in offer_propositions: if offer_pro.start_visibility_dissertation <= date_now <= offer_pro.end_visibility_dissertation: visibility = True return layout.render(request, 'dissertations_list.html', {'date_now': date_now, 'dissertations': memories, 'student': student, 'visibility': visibility})
def _save_from_entity_address(context, entity_version_id_selected, offer_year_id, request): email_encode = request.POST.get('email') form = score_sheet_address_entity.ScoreSheetAddressEntityForm(request.POST) if form.is_valid(): score_encoding_sheet.save_address_from_entity( context.get('offer_year'), entity_version_id_selected, request.POST.get('email')) messages.add_message(request, messages.SUCCESS, _('score_sheet_address_saved')) return HttpResponseRedirect( reverse("offer_score_encoding_tab", args=[offer_year_id])) else: incorrect_email_management(context, email_encode, offer_year_id) return layout.render(request, "offer/score_sheet_address_tab.html", context)
def navigation(request, navigate_direct_to_form): try: stud = mdl_base.student.find_by_user(request.user) except MultipleObjectsReturned: return dash_main_view.show_multiple_registration_id_error(request) current_academic_year = mdl_base.academic_year.starting_academic_year() student_programs = _get_student_programs(stud, current_academic_year) if student_programs: if navigate_direct_to_form and len(student_programs) == 1: return _get_exam_enrollment_form(student_programs[0], request, stud) else: return layout.render(request, 'offer_choice.html', {'programs': student_programs, 'student': stud}) else: messages.add_message(request, messages.WARNING, _('no_offer_enrollment_found').format(current_academic_year)) return response.HttpResponseRedirect(reverse('dashboard_home'))
def student_programs(request, registration_id): """ View to visualize a particular student list of academic programs. !!! Should only be open for staff having the rights. """ try: stud = Student.objects.get(registration_id=registration_id) except ObjectDoesNotExist: stud = None list_student_programs = fetch_student_programs_list(stud) return layout.render(request, "performance_home.html", { "student": stud, "programs": list_student_programs })
def _manage_dissertation_form(dissert, original_title, request): if request.method == "POST": form = DissertationTitleForm(request.POST, instance=dissert) if form.is_valid() and original_title != form.cleaned_data['title']: dissert = form.save() dissertation_update.add( request, dissert, dissert.status, justification=build_justification_with_title( dissert, original_title)) return redirect('dissertation_detail', pk=dissert.pk) else: form = DissertationTitleForm(instance=dissert) return layout.render(request, 'dissertation_title_form.html', {'form': form})
def display_results_by_acronym_and_year(request, acronym, academic_year): """ Display the reslt for a students , filter by acronym """ try: stud = student.find_by_user(request.user) except MultipleObjectsReturned: return dash_main_view.show_multiple_registration_id_error(request) cleaned_acronym = _clean_acronym(acronym) stud_perf = mdl_performance.student_performance.find_actual_by_student_and_offer_year( stud.registration_id, academic_year, cleaned_acronym) if not check_right_access(stud_perf, stud): raise PermissionDenied perf_data = __get_performance_data(stud_perf) return layout.render(request, "performance_result_student.html", perf_data)
def manager_dissertations_jury_edit(request, pk): dissert_role = dissertation_role.find_by_id(pk) redirect_if_none(dissert_role,'manager_dissertations_list') person = mdl.person.find_by_user(request.user) adv = adviser.search_by_person(person) if adviser_can_manage(dissert_role.dissertation,adv): if request.method == "POST": form = ManagerDissertationRoleForm(request.POST, instance=dissert_role) if form.is_valid(): form.save() return redirect('manager_dissertations_detail', pk=dissert_role.dissertation.pk) else: form = ManagerDissertationRoleForm(instance=dissert_role) return layout.render(request, 'manager_dissertations_jury_edit.html', {'form': form}) else: return redirect('manager_dissertations_list')
def create_education_group(request, category=None, parent_id=None): parent = get_object_or_404(EducationGroupYear, id=parent_id) if parent_id is not None else None forms_by_category = { education_group_categories.GROUP: GroupForm(request.POST or None, parent=parent), education_group_categories.TRAINING: TrainingForm(request.POST or None, parent=parent), education_group_categories.MINI_TRAINING: MiniTrainingForm(request.POST or None, parent=parent), } form_education_group_year = forms_by_category.get(category) if form_education_group_year.is_valid(): education_group_year = form_education_group_year.save() parent_id = parent.pk if parent else education_group_year.pk success_msg = create_success_message_for_creation_education_group_year( parent_id, education_group_year) display_success_messages(request, success_msg, extra_tags='safe') url = reverse("education_group_read", args=[parent_id, education_group_year.pk]) return redirect(url) templates_by_category = { education_group_categories.GROUP: "education_group/create_groups.html", education_group_categories.TRAINING: "education_group/create_trainings.html", education_group_categories.MINI_TRAINING: "education_group/create_mini_trainings.html", } return layout.render( request, templates_by_category.get(category), { "form_education_group_year": form_education_group_year.forms[forms.ModelForm], "form_education_group": form_education_group_year.forms[EducationGroupModelForm], "parent": parent })
def get_external_learning_unit_creation_form(request, academic_year): person = get_object_or_404(Person, user=request.user) academic_year = get_object_or_404(AcademicYear, pk=academic_year) external_form = ExternalLearningUnitBaseForm(person, academic_year, request.POST or None) if external_form.is_valid(): learning_unit_year = external_form.save() show_success_learning_unit_year_creation_message( request, learning_unit_year, 'learning_unit_successfuly_created') return redirect('learning_unit', learning_unit_year_id=learning_unit_year.pk) return layout.render(request, "learning_unit/simple/creation_external.html", external_form.get_context())
def update_learning_unit(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) form = LearningUnitModificationForm( request.POST or None, learning_unit_year_instance=learning_unit_year, person=person) if form.is_valid(): _save_form_and_display_messages(request, form) _check_credits(request, learning_unit_year.parent, form) return redirect("learning_unit", learning_unit_year_id=learning_unit_year.id) context = {"learning_unit_year": learning_unit_year, "form": form} return layout.render(request, 'learning_unit/modification.html', context)
def student_result(request, registration_id, anac, program_acronym): """ View to visualize a particular student program courses result. !!! Should only be open for staff having the rights. """ try: stud = Student.objects.get(registration_id=registration_id) except ObjectDoesNotExist: stud = None query_result = mdl.student_performance.select_where_registration_id_is( stud.registration_id) document = filter_by_anac_and_program_acronym(query_result, anac, program_acronym) return layout.render(request, "performance_result.html", {"results": document})
def settings_edit(request): """Use to edit app settings.""" global_settings = settings.get_settings() if global_settings: form = SettingsForm( initial={'starting_date': global_settings.starting_date, 'ending_date': global_settings.ending_date, 'assistants_starting_date': global_settings.assistants_starting_date, 'assistants_ending_date': global_settings.assistants_ending_date, 'assistants_contract_end_starting_date': global_settings.assistants_contract_end_starting_date, 'assistants_contract_end_ending_date': global_settings.assistants_contract_end_ending_date }, prefix="set", instance=global_settings) else: form = SettingsForm(prefix="set", instance=global_settings) year = academic_year.current_academic_year().year return layout.render(request, 'settings.html', {'year': year, 'form': form, })
def dissertation_detail(request, pk): memory = get_object_or_404(dissertation.Dissertation, pk=pk) person = mdl.person.find_by_user(request.user) student = mdl.student.find_by_person(person) if memory.author_is_logged_student(request): off = memory.offer_year_start.offer offer_pro = offer_proposition.search_by_offer(off) offer_propositions = proposition_offer.search_by_proposition_dissertation(memory.proposition_dissertation) count = dissertation.count_submit_by_user(student, off) files = dissertation_document_file.find_by_dissertation(memory) filename = "" for file in files: filename = file.document_file.file_name count_dissertation_role = dissertation_role.count_by_dissertation(memory) count_reader = dissertation_role.count_reader_by_dissertation(memory) count_proposition_role = proposition_role.count_by_dissertation(memory) proposition_roles = proposition_role.search_by_dissertation(memory) jury_visibility = offer_pro.start_jury_visibility <= timezone.now().date() <= offer_pro.end_jury_visibility check_edit = offer_pro.start_edit_title <= timezone.now().date() <= offer_pro.end_edit_title if count_dissertation_role == 0: if count_proposition_role == 0: dissertation_role.add('PROMOTEUR', memory.proposition_dissertation.author, memory) else: for role in proposition_roles: dissertation_role.add(role.status, role.adviser, memory) dissertation_roles = dissertation_role.search_by_dissertation(memory) return layout.render(request, 'dissertation_detail.html', {'check_edit': check_edit, 'count': count, 'count_reader': count_reader, 'count_dissertation_role': count_dissertation_role, 'dissertation': memory, 'dissertation_roles': dissertation_roles, 'jury_visibility': jury_visibility, 'manage_readers': offer_pro.student_can_manage_readers, 'filename': filename, 'offer_propositions': offer_propositions}) else: return redirect('dissertations')
def proposition_dissertation_detail(request, pk): subject = get_object_or_404(proposition_dissertation.PropositionDissertation, pk=pk) offer_propositions = proposition_offer.search_by_proposition_dissertation(subject) person = mdl.person.find_by_user(request.user) student = mdl.student.find_by_person(person) using = dissertation.count_by_proposition(subject) percent = using * 100 / subject.max_number_student if subject.max_number_student else 0 count_proposition_role = proposition_role.count_by_proposition(subject) files = proposition_document_file.find_by_proposition(subject) filename = "" for file in files: filename = file.document_file.file_name if count_proposition_role < 1: proposition_role.add('PROMOTEUR', subject.author, subject) proposition_roles = proposition_role.search_by_proposition(subject) return layout.render(request, 'proposition_dissertation_detail.html', {'percent': round(percent, 2), 'proposition_roles': proposition_roles, 'proposition_dissertation': subject, 'offer_propositions': offer_propositions, 'student': student, 'using': using, 'filename': filename})
def page_not_found(request): return layout.render(request, 'page_not_found.html', {})
def access_denied(request): return layout.render(request, 'access_denied.html', {})
def server_error(request): return layout.render(request, 'server_error.html', {})
def data(request): return layout.render(request, 'admin/data.html')
def score_encoding(request): return layout.render(request, "score_encoding.html", {})
def home(request): # Adapt layout depending on the type of user (student, professor) return layout.render(request, "dashboard.html")
def load_mandates(request): return layout.render(request, "load_mandates.html", {})
def logged_out(request): return layout.render(request, 'logged_out.html', {})