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_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 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_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 _manage_draft_or_ko_dissertation_form(dissert, education_groups, request):
if request.method == "POST":
form = DissertationEditForm(request.POST, instance=dissert)
if form.is_valid():
dissert = form.save()
dissertation_update.add(
request,
dissert,
dissert.status,
justification="student edited the dissertation")
return redirect('dissertation_detail', pk=dissert.pk)
else:
form.fields[
"education_group_year"].queryset = education_group_year.find_by_education_groups(
education_groups)
form.fields[
"proposition_dissertation"].queryset = proposition_dissertation.find_by_education_groups(
education_groups)
else:
form = DissertationEditForm(instance=dissert)
form.fields[
"education_group_year"].queryset = education_group_year.find_by_education_groups(
education_groups)
form.fields[
"proposition_dissertation"].queryset = proposition_dissertation.find_by_education_groups(
education_groups)
return layout.render(request, 'dissertation_edit_form.html', {
'form': form,
'defend_periode_choices': dissertation.DEFEND_PERIODE
})
def manager_dissertations_edit(request, pk):
dissert = dissertation.find_by_id(pk)
if dissert is None:
return redirect('manager_dissertations_list')
person = mdl.person.find_by_user(request.user)
adv = adviser.search_by_person(person)
if adviser_can_manage(dissert,adv):
offers = faculty_adviser.search_by_adviser(adv)
if request.method == "POST":
form = ManagerDissertationEditForm(request.POST, instance=dissert)
if form.is_valid():
dissert = form.save()
justification = "manager_edit_dissertation"
dissertation_update.add(request, dissert, dissert.status, justification=justification)
return redirect('manager_dissertations_detail', pk=dissert.pk)
else:
form.fields["proposition_dissertation"].queryset = proposition_dissertation.search_by_offers(offers)
form.fields["author"].queryset = mdl.student.find_by_offer(offers)
form.fields["offer_year_start"].queryset = mdl.offer_year.find_by_offer(offers)
else:
form = ManagerDissertationEditForm(instance=dissert)
form.fields["proposition_dissertation"].queryset = proposition_dissertation.search_by_offers(offers)
form.fields["author"].queryset = mdl.student.find_by_offer(offers)
form.fields["offer_year_start"].queryset = mdl.offer_year.find_by_offer(offers)
return layout.render(request, 'manager_dissertations_edit.html',
{'form': form,
'dissert': dissert,
'defend_periode_choices': dissertation.DEFEND_PERIODE_CHOICES})
else:
return redirect('manager_dissertations_list')
def manager_dissertations_jury_new(request, pk):
dissert = dissertation.find_by_id(pk)
if dissert is None:
return redirect('manager_dissertations_list')
count_dissertation_role = dissertation_role.count_by_dissertation(dissert)
person = mdl.person.find_by_user(request.user)
adv = adviser.search_by_person(person)
if adviser_can_manage(dissert,adv):
if count_dissertation_role < 4 and dissert.status != 'DRAFT':
if request.method == "POST":
form = ManagerDissertationRoleForm(request.POST)
if form.is_valid():
data = form.cleaned_data
status = data['status']
adv = data['adviser']
diss = data['dissertation']
justification = "%s %s %s" % ("manager_add_jury", str(status), str(adv))
dissertation_update.add(request, dissert, dissert.status, justification=justification)
dissertation_role.add(status, adv, diss)
return redirect('manager_dissertations_detail', pk=dissert.pk)
else:
form = ManagerDissertationRoleForm(initial={'dissertation': dissert})
else:
form = ManagerDissertationRoleForm(initial={'dissertation': dissert})
return layout.render(request, 'manager_dissertations_jury_edit.html', {'form': form, 'dissert': dissert})
else:
return redirect('manager_dissertations_detail', pk=dissert.pk)
else:
return redirect('manager_dissertations_list')
def manager_dissertations_jury_new_ajax(request):
pk_dissert = request.POST.get("pk_dissertation", '')
status_choice = request.POST.get("status_choice", '')
id_adviser_of_dissert_role = request.POST.get("adviser_pk", '')
if not id_adviser_of_dissert_role or not status_choice or not pk_dissert:
return HttpResponse(status=ERROR_405_BAD_REQUEST)
else:
dissert = dissertation.find_by_id(pk_dissert)
adviser_of_dissert_role = adviser.get_by_id(
int(id_adviser_of_dissert_role))
count_dissertation_role = dissertation_role.count_by_dissertation(
dissert)
person = mdl.person.find_by_user(request.user)
adv_manager = adviser.search_by_person(person)
if adviser_can_manage(dissert, adv_manager) and count_dissertation_role < 4 and dissert.status != 'DRAFT' \
and adviser_of_dissert_role is not None and dissert is not None:
justification = "%s %s %s" % ("manager_add_jury", status_choice,
adviser_of_dissert_role)
dissertation_update.add(request,
dissert,
dissert.status,
justification=justification)
dissertation_role.add(status_choice, adviser_of_dissert_role,
dissert)
return HttpResponse(status=HTTP_OK)
else:
return HttpResponse(status=ERROR_403_NOT_FORBIDDEN)
def dissertations_to_dir_ko(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):
old_status = dissert.status
new_status = dissertation.get_next_status(dissert, "refuse")
status_dict = dict(dissertation.STATUS_CHOICES)
new_status_display = status_dict[new_status]
if request.method == "POST":
form = ManagerDissertationUpdateForm(request.POST)
if form.is_valid():
dissert.refuse()
data = form.cleaned_data
justification = data['justification']
dissertation_update.add(request, dissert, old_status, justification=justification)
return redirect('dissertations_detail', pk=pk)
else:
form = ManagerDissertationUpdateForm()
return layout.render(request, 'dissertations_add_justification.html',
{'form': form, 'dissert': dissert, 'new_status_display': new_status_display})
else:
return redirect('dissertations_detail', pk=pk)
def manager_dissertations_to_dir_ok(request, pk):
dissert = dissertation.find_by_id(pk)
redirect_if_none(dissert, 'manager_dissertations_list')
person = mdl.person.find_by_user(request.user)
adv = adviser.search_by_person(person)
if (adviser_can_manage(dissert, adv)):
old_status = dissert.status
new_status = dissertation.get_next_status(dissert, "accept")
status_dict = dict(dissertation.STATUS_CHOICES)
new_status_display = status_dict[new_status]
if request.method == "POST":
form = ManagerDissertationUpdateForm(request.POST)
if form.is_valid():
dissert.manager_accept()
data = form.cleaned_data
justification = data['justification']
dissertation_update.add(request, dissert, old_status, justification=justification)
return redirect('manager_dissertations_detail', pk=pk)
else:
form = ManagerDissertationUpdateForm()
return layout.render(request, 'manager_dissertations_add_justification.html',
{'form': form, 'dissert': dissert, 'new_status_display': new_status_display})
else:
return redirect('manager_dissertations_list')
def manager_dissertations_jury_new_ajax(request):
pk_dissert = request.POST.get("pk_dissertation", '')
status_choice = request.POST.get("status_choice", '')
id_adviser_of_dissert_role = request.POST.get("adviser_pk", '')
if not id_adviser_of_dissert_role or not status_choice or not pk_dissert:
return HttpResponse(status=status.HTTP_405_METHOD_NOT_ALLOWED)
else:
dissert = dissertation.find_by_id(pk_dissert)
adviser_of_dissert_role = adviser.get_by_id(
int(id_adviser_of_dissert_role))
count_dissertation_role = dissertation_role.count_by_dissertation(
dissert)
person = mdl.person.find_by_user(request.user)
adv_manager = adviser.search_by_person(person)
if adviser_can_manage(dissert, adv_manager) \
and count_dissertation_role < MAX_DISSERTATION_ROLE_FOR_ONE_DISSERTATION and dissert.status != 'DRAFT' \
and adviser_of_dissert_role is not None and dissert is not None:
justification = "%s %s %s" % (_("Manager add jury"), status_choice,
adviser_of_dissert_role)
dissertation_update.add(request,
dissert,
dissert.status,
justification=justification)
dissertation_role.add(status_choice, adviser_of_dissert_role,
dissert)
return HttpResponse(status=status.HTTP_200_OK)
else:
return HttpResponse(status=status.HTTP_403_FORBIDDEN)
def dissertations_jury_new(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)
offer_prop = offer_proposition.get_by_dissertation(dissert)
if offer_prop is not None and teacher_is_promotor(adv, dissert):
count_dissertation_role = dissertation_role.count_by_dissertation(dissert)
if count_dissertation_role < 4 and offer_prop.adviser_can_suggest_reader:
if request.method == "POST":
form = ManagerDissertationRoleForm(request.POST)
if form.is_valid():
data = form.cleaned_data
status = data['status']
adv = data['adviser']
diss = data['dissertation']
justification = "%s %s %s" % ("teacher_add_jury", str(status), str(adv))
dissertation_update.add(request, dissert, dissert.status, justification=justification)
dissertation_role.add(status, adv, diss)
return redirect('dissertations_detail', pk=dissert.pk)
else:
form = ManagerDissertationRoleForm(initial={'dissertation': dissert})
else:
form = ManagerDissertationRoleForm(initial={'dissertation': dissert})
return layout.render(request, 'dissertations_jury_edit.html', {'form': form, 'dissert': dissert})
return redirect('dissertations_detail', pk=dissert.pk)
def manager_dissertations_to_dir_submit(request, pk):
dissert = dissertation.find_by_id(pk)
if dissert is None:
return redirect('manager_dissertations_list')
old_status = dissert.status
new_status_display_str = new_status_display(dissert, "go_forward")
if request.method == "POST":
form = ManagerDissertationUpdateForm(request.POST)
if form.is_valid():
dissert.go_forward()
data = form.cleaned_data
justification = data['justification']
dissertation_update.add(request,
dissert,
old_status,
justification=justification)
return redirect('manager_dissertations_detail', pk=pk)
else:
form = ManagerDissertationUpdateForm()
return render(
request, 'manager_dissertations_add_justification.html', {
'form': form,
'dissert': dissert,
'new_status_display': new_status_display_str
})
def manager_dissertations_delete(request, pk):
dissert = dissertation.find_by_id(pk)
dissert.deactivate()
dissertation_update.add(request,
dissert,
dissert.status,
justification=_("Delete dissertation"))
return redirect('manager_dissertations_list')
def _justification_dissert_role_delete_change(request, dissert, dissert_role, intitule):
if dissert.status != 'DRAFT' and _role_can_be_deleted(dissert, dissert_role):
justification = "%s %s" % (intitule, dissert_role)
dissertation_update.add(request, dissert, dissert.status, justification=justification)
dissert_role.delete()
return True
else:
return False
def manager_dissertations_to_dir_submit_list(request, pk):
dissert = dissertation.find_by_id(pk)
if dissert is None:
return redirect('manager_dissertations_list')
old_status = dissert.status
dissert.go_forward()
dissertation_update.add(request, dissert, old_status)
return redirect('manager_dissertations_wait_recep_list')
def manager_dissertations_accept_eval_list(request, pk):
dissert = dissertation.find_by_id(pk)
if dissert is None:
return redirect('manager_dissertations_list')
old_status = dissert.status
dissert.manager_accept()
dissertation_update.add(request, dissert, old_status)
return redirect('manager_dissertations_wait_eval_list')
def dissertation_delete(request, pk):
memory = get_object_or_404(dissertation.Dissertation, pk=pk)
if memory.author_is_logged_student(request):
memory.deactivate()
dissertation_update.add(request,
memory,
memory.status,
justification="student_set_active_false")
return redirect('dissertations')
def form_valid(self, form):
result = super().form_valid(form)
justification = "{} {}".format("Student added reader",
form.cleaned_data['adviser'])
dissert = self.dissertation
dissertation_update.add(self.request,
dissert,
dissert.status,
justification=justification)
return result
def manager_dissertations_go_forward_from_list(request, pk, choice):
dissert = dissertation.get_object_or_none(Dissertation, pk=pk)
old_status = dissert.status
if choice == 'ok':
dissert.manager_accept()
elif choice == 'ko':
dissert.refuse()
else:
dissert.go_forward()
dissertation_update.add(request, dissert, old_status)
return redirect('manager_dissertations_search')
def dissertations_delete(request, pk):
dissert = dissertation.find_by_id(pk)
redirect_if_none(dissert, 'dissertations_list')
person = mdl.person.find_by_user(request.user)
adv = adviser.search_by_person(person)
if teacher_is_promotor(adv, dissert):
dissert.deactivate()
dissertation_update.add(request, dissert, dissert.status, justification="teacher_set_active_false ")
return redirect('dissertations_list')
else:
return redirect('dissertations_detail', pk=pk)
def manager_dissertations_delete(request, pk):
dissert = dissertation.find_by_id(pk)
redirect_if_none(dissert,'manager_dissertations_list')
person = mdl.person.find_by_user(request.user)
adv = adviser.search_by_person(person)
if (adviser_can_manage(dissert, adv)):
dissert.deactivate()
dissertation_update.add(request, dissert, dissert.status, justification="manager_set_active_false")
return redirect('manager_dissertations_list')
else:
return redirect('manager_dissertations_list')
def dissertation_reader_delete(request, pk):
role = get_object_or_404(dissertation_role.DissertationRole, pk=pk)
memory = role.dissertation
if memory.author_is_logged_student(request):
offer_pro = offer_proposition.search_by_offer(memory.offer_year_start.offer)
if offer_pro.student_can_manage_readers and memory.status == 'DRAFT':
justification = "%s %s" % ("student_delete_reader", str(role))
dissertation_update.add(request, memory, memory.status, justification=justification)
role.delete()
return redirect('dissertation_detail', pk=memory.pk)
else:
return redirect('dissertations')
def manager_dissertations_accept_eval_list(request, pk):
dissert = dissertation.find_by_id(pk)
redirect_if_none(dissert, 'manager_dissertations_list')
person = mdl.person.find_by_user(request.user)
adv = adviser.search_by_person(person)
if (adviser_can_manage(dissert, adv)):
old_status = dissert.status
dissert.manager_accept()
dissertation_update.add(request, dissert, old_status)
return redirect('manager_dissertations_wait_eval_list')
else:
return redirect('manager_dissertations_wait_eval_list')
def dissertation_new(request, pk):
person = request.user.person
student = person.student_set.first()
this_academic_year = academic_year.starting_academic_year()
offer_enrollements = OfferEnrollment.objects.filter(
student=student,
education_group_year__academic_year=this_academic_year,
enrollment_state__in=[
offer_enrollment_state.SUBSCRIBED, offer_enrollment_state.PROVISORY
]).select_related('education_group_year',
'education_group_year__education_group')
offer_propositions = OfferProposition.objects.filter(education_group__in=[
offer_enrollment.education_group_year.education_group
for offer_enrollment in offer_enrollements
])
date_now = timezone.now().date()
if any(o.start_visibility_dissertation <= date_now <=
o.end_visibility_dissertation for o in offer_propositions):
initial = {'active': True, 'author': student}
if pk:
prop_diss = get_object_or_404(PropositionDissertation, pk=pk)
initial['proposition_dissertation'] = prop_diss.pk
form = DissertationForm(request.POST or None, initial=initial)
if form.is_valid():
memory = form.save()
dissertation_update.add(
request,
memory,
memory.status,
justification="Student created the dissertation : {}".format(
memory.title))
return redirect('dissertation_detail', pk=memory.pk)
form.fields[
"education_group_year"].queryset = EducationGroupYear.objects.filter(
offerenrollment__student=student,
education_group__in=[
offer_prop.education_group
for offer_prop in offer_propositions
]).order_by("academic_year__year", "acronym")
form.fields["proposition_dissertation"].queryset = \
proposition_dissertation.find_by_education_groups(
[offer_enroll.education_group_year.education_group for offer_enroll in offer_enrollements]
)
return render(request, 'dissertation_form.html', {
'form': form,
'defend_periode_choices': dissertation.DEFEND_PERIODE
})
else:
return redirect('dissertations')
def manager_dissertations_role_delete(request, pk):
dissert_role = dissertation_role.find_by_id(pk)
redirect_if_none(dissert_role, 'manager_dissertations_list')
dissert = dissert_role.dissertation
person = mdl.person.find_by_user(request.user)
adv = adviser.search_by_person(person)
if (adviser_can_manage(dissert, adv)):
if dissert.status != 'DRAFT' and role_can_be_deleted(dissert, dissert_role):
justification = "%s %s" % ("manager_delete_jury", str(dissert_role))
dissertation_update.add(request, dissert, dissert.status, justification=justification)
dissert_role.delete()
return redirect('manager_dissertations_detail', pk=dissert.pk)
else:
return redirect('manager_dissertations_list')
def dissertations_role_delete(request, pk):
dissert_role = dissertation_role.find_by_id(pk)
redirect_if_none(dissert_role,'dissertations_list')
dissert = dissert_role.dissertation
person = mdl.person.find_by_user(request.user)
adv = adviser.search_by_person(person)
offer_prop = offer_proposition.get_by_dissertation(dissert)
if offer_prop is not None and teacher_is_promotor(adv, dissert):
if offer_prop.adviser_can_suggest_reader and role_can_be_deleted(dissert, dissert_role):
justification = "%s %s" % ("teacher_delete_jury", str(dissert_role))
dissertation_update.add(request, dissert, dissert.status, justification=justification)
dissert_role.delete()
return redirect('dissertations_detail', pk=dissert.pk)
def manager_dissertations_to_dir_submit_list(request, pk):
dissert = dissertation.find_by_id(pk)
if dissert is None:
return redirect('manager_dissertations_list')
person = mdl.person.find_by_user(request.user)
adv = adviser.search_by_person(person)
if (adviser_can_manage(dissert, adv)):
old_status = dissert.status
dissert.go_forward()
dissertation_update.add(request, dissert, old_status)
return redirect('manager_dissertations_wait_recep_list')
else:
return redirect('manager_dissertations_list')
def save(self, commit=True):
data = self.cleaned_data
status = data['status']
adv = data['adviser']
diss = data['dissertation']
justification = self._get_justification()
dissertation_update.add(self.request,
diss,
status,
justification=justification)
if status == dissertation_role_status.PROMOTEUR:
instance, created = DissertationRole.objects.update_or_create(
dissertation=diss, status=status, defaults={'adviser': adv})
else:
instance = super().save(commit)
return instance
def dissertation_reader_delete(request, pk):
role = get_object_or_404(dissertation_role.DissertationRole, pk=pk)
memory = role.dissertation
if memory.author_is_logged_student(request):
offer_pro = offer_proposition.search_by_offer(
memory.offer_year_start.offer)
if offer_pro.student_can_manage_readers and memory.status == 'DRAFT':
justification = "%s %s" % ("student_delete_reader", str(role))
dissertation_update.add(request,
memory,
memory.status,
justification=justification)
role.delete()
return redirect('dissertation_detail', pk=memory.pk)
else:
return redirect('dissertations')
def dissertation_reader_delete(request, pk):
role = get_object_or_404(dissertation_role.DissertationRole, pk=pk)
dissert = role.dissertation
if dissert.author_is_logged_student(request):
offer_pro = offer_proposition.get_by_education_group(
dissert.education_group_year.education_group)
if offer_pro.student_can_manage_readers and dissert.status == 'DRAFT':
justification = "Student deleted reader {}".format(role)
dissertation_update.add(request,
dissert,
dissert.status,
justification=justification)
role.delete()
return redirect('dissertation_detail', pk=dissert.pk)
else:
return redirect('dissertations')
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 delete(self, request, *args, **kwargs):
self.dissertation_documents = self.get_object()
if self.dissertation_documents and self.dissertation.author_is_logged_student(
request):
for dissertation_document in self.dissertation_documents:
justification = "{} {}".format(
_("The student has deleted the file :"),
dissertation_document.document_file.file_name)
dissertation_update.add(request,
self.dissertation,
self.dissertation.status,
justification=justification)
dissertation_document.delete()
return self._ajax_response() or HttpResponseRedirect(
self.get_success_url())
return self._ajax_response() or HttpResponseRedirect(
self.get_error_url())
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 dissertation_delete(request, pk):
memory = get_object_or_404(dissertation.Dissertation, pk=pk)
if memory.author_is_logged_student(request):
memory.deactivate()
dissertation_update.add(request, memory, memory.status, justification="student_set_active_false")
return redirect('dissertations')
