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 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 _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', {})
