def learning_units_search(request, search_type):
service_course_search = search_type == SERVICE_COURSES_SEARCH
borrowed_course_search = search_type == BORROWED_COURSE
form = LearningUnitYearForm(
request.GET or None,
service_course_search=service_course_search,
borrowed_course_search=borrowed_course_search,
initial={'academic_year_id': starting_academic_year()}
)
found_learning_units = LearningUnitYear.objects.none()
try:
if form.is_valid():
found_learning_units = form.get_activity_learning_units()
check_if_display_message(request, found_learning_units)
except TooManyResultsException:
display_error_messages(request, 'too_many_results')
if request.POST.get('xls_status') == "xls":
return create_xls(request.user, found_learning_units, _get_filter(form, search_type))
if request.POST.get('xls_status') == "xls_comparison":
return create_xls_comparison(
request.user,
found_learning_units,
_get_filter(form, search_type),
request.POST.get('comparison_year')
)
if request.POST.get('xls_status') == "xls_with_parameters":
return create_xls_with_parameters(
request.user,
found_learning_units,
_get_filter(form, search_type),
{
WITH_GRP: request.POST.get('with_grp') == 'true',
WITH_ATTRIBUTIONS: request.POST.get('with_attributions') == 'true'
}
)
form_comparison = SelectComparisonYears(academic_year=get_academic_year_of_reference(found_learning_units))
context = {
'form': form,
'academic_years': get_last_academic_years(),
'container_types': learning_container_year_types.LEARNING_CONTAINER_YEAR_TYPES,
'types': learning_unit_year_subtypes.LEARNING_UNIT_YEAR_SUBTYPES,
'learning_units_count': len(found_learning_units)
if isinstance(found_learning_units, list) else
found_learning_units.count(),
'current_academic_year': starting_academic_year(),
'experimental_phase': True,
'search_type': search_type,
'is_faculty_manager': request.user.person.is_faculty_manager,
'form_comparison': form_comparison,
'page_obj': paginate_queryset(found_learning_units, request.GET),
}
return render(request, "learning_units.html", context)
def _get_data(request):
person = mdl.person.find_by_user(request.user)
tutor = mdl.tutor.find_by_person(person)
programs = mdl.program_manager.find_by_person(person).prefetch_related(
Prefetch(
'education_group__educationgroupyear_set',
queryset=EducationGroupYear.objects.filter(
academic_year=starting_academic_year()).select_related(
'academic_year'),
to_attr='current_egy')).order_by(
'education_group__educationgroupyear__acronym').distinct()
return {
'person':
person,
'addresses':
mdl.person_address.find_by_person(person),
'tutor':
tutor,
'attributions':
mdl_attr.attribution.search(tutor=tutor) if tutor else None,
'programs':
programs,
'supported_languages':
settings.LANGUAGES,
'default_language':
settings.LANGUAGE_CODE,
'summary_submission_opened':
base.business.learning_unit.is_summary_submission_opened()
}
def form_part5_edit(request, msg=None):
mandate = assistant_mandate.find_mandate_by_assistant_for_academic_year(
academic_assistant.find_by_person(request.user.person),
academic_year.starting_academic_year())
assistant = mandate.assistant
form = AssistantFormPart5(initial={
'faculty_representation': mandate.faculty_representation,
'institute_representation': mandate.institute_representation,
'sector_representation': mandate.sector_representation,
'governing_body_representation': mandate.governing_body_representation,
'corsci_representation': mandate.corsci_representation,
'students_service': mandate.students_service,
'infrastructure_mgmt_service': mandate.infrastructure_mgmt_service,
'events_organisation_service': mandate.events_organisation_service,
'publishing_field_service': mandate.publishing_field_service,
'scientific_jury_service': mandate.scientific_jury_service,
'formations': mandate.formations
},
prefix='mand')
return render(request, "assistant_form_part5.html", {
'assistant': assistant,
'mandate': mandate,
'msg': msg,
'form': form
})
def test_learning_units_summary_list(self, mock_render):
request_factory = RequestFactory()
now = datetime.datetime.now()
EntityVersionFactory(entity=self.an_entity,
start_date=now,
end_date=datetime.datetime(now.year + 1, 9, 15),
entity_type='INSTITUTE')
request = request_factory.get(
self.url, data={'academic_year_id': starting_academic_year().id})
request.user = self.faculty_user
lu = self._create_learning_unit_year_for_entity(self.an_entity)
person_lu = PersonFactory()
tutor_lu_1 = TutorFactory(person=person_lu)
self.attribution_lu = AttributionFactory(learning_unit_year=lu,
tutor=tutor_lu_1,
summary_responsible=True)
self._create_entity_calendar(self.an_entity)
self.client.force_login(self.faculty_user)
learning_units_summary_list(request)
self.assertTrue(mock_render.called)
request, template, context = mock_render.call_args[0]
self.assertEqual(template, 'learning_units.html')
self.assertEqual(context['search_type'], SUMMARY_LIST)
self.assertEqual(len(context['learning_units_with_errors']), 1)
self.assertTrue(context['is_faculty_manager'])
def test_update_with_parent_when_existing_group_element_year(
self, mock_find_authorized_types):
parent = EducationGroupYearFactory(
academic_year=self.expected_educ_group_year.academic_year,
education_group__end_year=None)
entity_version = MainEntityVersionFactory()
initial_educ_group_year = MiniTrainingFactory(
management_entity=entity_version.entity,
academic_year=self.expected_educ_group_year.academic_year,
education_group__start_year=starting_academic_year())
GroupElementYearFactory(parent=parent,
child_branch=initial_educ_group_year)
initial_count = GroupElementYear.objects.all().count()
form = self.form_class(data=self.post_data,
instance=initial_educ_group_year,
parent=parent,
user=self.user)
self.assertTrue(form.is_valid(), form.errors)
updated_education_group_year = form.save()
# Assert existing GroupElementYear is reused.
self.assertEqual(initial_count, GroupElementYear.objects.all().count())
self._assert_all_fields_correctly_saved(updated_education_group_year)
self.assertTrue(form.forms[ModelForm].fields["academic_year"].disabled)
def reviewer_action(request):
reviewers_formset = formset_factory(ReviewersFormset)(request.POST,
request.FILES)
if reviewers_formset.is_valid():
for reviewer_form in reviewers_formset:
action = reviewer_form.cleaned_data.get('action')
if action == 'DELETE':
reviewer_delete(request, reviewer_form.cleaned_data.get('id'))
elif action == 'REPLACE':
year = academic_year.starting_academic_year().year
reviewer_id = reviewer_form.cleaned_data.get('id')
this_reviewer = reviewer.find_by_id(reviewer_id)
entity = entity_version.get_last_version(this_reviewer.entity)
form = ReviewerReplacementForm(initial={
'person': this_reviewer.person,
'id': this_reviewer.id
},
prefix="rev",
instance=this_reviewer)
return render(
request, "manager_replace_reviewer.html", {
'reviewer': this_reviewer,
'entity': entity,
'year': year,
'form': form
})
return HttpResponseRedirect(reverse('reviewers_list'))
def test_learning_units_summary_list(self):
now = datetime.datetime.now()
EntityVersionFactory(entity=self.an_entity,
start_date=now,
end_date=datetime.datetime(now.year + 1, 9, 15),
entity_type='INSTITUTE')
lu = self._create_learning_unit_year_for_entity(
self.an_entity, "LBIR1100")
person_lu = PersonFactory()
tutor_lu_1 = TutorFactory(person=person_lu)
self.attribution_lu = AttributionFactory(learning_unit_year=lu,
tutor=tutor_lu_1,
summary_responsible=True)
self._create_entity_calendar(self.an_entity)
self.client.force_login(self.faculty_user)
response = self.client.get(
self.url, data={'academic_year_id': starting_academic_year().id})
self.assertTemplateUsed(response, 'learning_units.html')
context = response.context
self.assertEqual(context['search_type'], SUMMARY_LIST)
self.assertEqual(context['learning_units_count'], 1)
self.assertTrue(context['is_faculty_manager'])
def __init__(self, instance, person=None):
"""
The instance must be a training in the current academic year with an end year greater than
the next academic year.
During the initialization, we'll also check if the current instance has a content to postpone.
"""
if not isinstance(instance, EducationGroupYear):
raise NotPostponeError(
_('You are not allowed to copy the content of this kind of education group.'
))
self.instance = instance
self.current_year = starting_academic_year()
self.next_academic_year = self.instance.academic_year.next()
self.check_instance(person)
self.result = []
self.warnings = []
self.instance_n1 = self.get_instance_n1(self.instance)
self.postponed_luy = []
self.postponed_options = {}
self.postponed_finalities = []
self.number_links_created = 0
self.number_elements_created = 0
def __init__(self, data=None, queryset=None, *, request=None, prefix=None):
translated_text_qs = TranslatedText.objects.filter(
entity=LEARNING_UNIT_YEAR,
text_label__label__in=CMS_LABEL_PEDAGOGY,
changed__isnull=False,
reference=OuterRef('pk')).order_by("-changed")
queryset = LearningUnitYear.objects.all().annotate(
full_title=Case(
When(Q(learning_container_year__common_title__isnull=True)
| Q(learning_container_year__common_title__exact=''),
then='specific_title'),
When(Q(specific_title__isnull=True)
| Q(specific_title__exact=''),
then='learning_container_year__common_title'),
default=Concat('learning_container_year__common_title',
Value(' - '), 'specific_title'),
output_field=CharField(),
),
last_translated_text_changed=Subquery(
translated_text_qs.values('changed')[:1]),
)
super(LearningUnitDescriptionFicheFilter, self).__init__(
data=data,
queryset=queryset,
request=request,
prefix=prefix,
)
self.form.fields['academic_year'].initial = starting_academic_year()
self.form.fields['with_entity_subordinated'].initial = True
def test_current_academic_year(self):
current_academic_yr = academic_year.current_academic_year()
starting_academic_yr = academic_year.starting_academic_year()
if starting_academic_yr != current_academic_yr:
self.assertEqual(current_academic_yr.year, now.year - 1)
else:
self.assertEqual(current_academic_yr.year, now.year)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.queryset = self.get_queryset()
self.form.fields["academic_year"].initial = starting_academic_year()
if self.data.get('country'):
self._init_dropdown_list()
def reviewer_add(request):
year = academic_year.starting_academic_year().year
if request.POST:
form = ReviewerForm(data=request.POST)
this_person = request.POST.get('person_id')
if form.is_valid() and this_person:
this_person = person.find_by_id(this_person)
new_reviewer = form.save(commit=False)
if reviewer.find_by_entity_and_role(new_reviewer.entity,
new_reviewer.role):
msg = _(
"A reviewer having the same role for this entity already exists"
)
form.add_error(None, msg)
if not form.has_error(field=NON_FIELD_ERRORS):
new_reviewer.person = this_person
new_reviewer.save()
return redirect('reviewers_list')
else:
msg = _(
"Please enter the last name and first name of the person you are looking for and select the "
"corresponding choice in the drop-down list")
form.add_error(None, msg)
else:
form = ReviewerForm(initial={'year': year})
return render(request, "manager_add_reviewer.html", {
'form': form,
'year': year
})
def save_message_history(request, type):
message = Message.objects.create(
sender=manager.Manager.objects.get(person=request.user.person),
date=timezone.now(),
type=type,
academic_year=academic_year.starting_academic_year())
message.save()
def get_context_data(self, **kwargs):
context = super(StructuresListView, self).get_context_data(**kwargs)
context['year'] = academic_year.starting_academic_year().year
context['current_reviewer'] = self.reviewers[0]
context['entity'] = entity_version.get_last_version(context['current_reviewer'].entity)
context['is_supervisor'] = is_supervisor(self.request.user.person)
return context
def is_academic_year_in_range_to_create_partim(learning_unit_year, person):
current_acy = starting_academic_year()
luy_acy = learning_unit_year.academic_year
max_range = MAX_ACADEMIC_YEAR_FACULTY if person.is_faculty_manager(
) else MAX_ACADEMIC_YEAR_CENTRAL
return current_acy.year <= luy_acy.year <= current_acy.year + max_range
def can_update_by_faculty_manager(self):
if not self.learning_container_year:
return False
starting_year = starting_academic_year().year
year = self.academic_year.year
return starting_year <= year <= starting_year + MAX_ACADEMIC_YEAR_FACULTY
def test_learning_units_summary_list_by_client_xls_empty(self):
# Generate data
now = datetime.datetime.now()
EntityVersionFactory(entity=self.an_entity,
start_date=now,
end_date=datetime.datetime(now.year+1, 9, 15),
entity_type='INSTITUTE')
luy = self._create_learning_unit_year_for_entity(self.an_entity, "LBIR1100")
self._create_entity_calendar(self.an_entity)
TeachingMaterialFactory(learning_unit_year=luy, title="Magic wand", mandatory=False)
TeachingMaterialFactory(learning_unit_year=luy, title="Broomsticks", mandatory=False)
luy_without_mandatory_teaching_material = self._create_learning_unit_year_for_entity(self.an_entity, "LBIR1101")
TeachingMaterialFactory(learning_unit_year=luy_without_mandatory_teaching_material, title="cauldron", mandatory=False)
# Test the view
self.client.force_login(self.faculty_user)
response = self.client.get(self.url, data={
'academic_year_id': starting_academic_year().id,
'xls_status': 'xls_teaching_material'
})
# OK, the server will stay in the page
self.assertEqual(response.status_code, 200)
# A warning message should be generated
messages = list(get_messages(response.wsgi_request))
self.assertEqual(len(messages), 1)
self.assertEqual(str(messages[0]), _("the list to generate is empty.").capitalize())
def _is_faculty_manager_eligible(self):
if self.education_group_year.academic_year.year < starting_academic_year(
).year:
raise PermissionDenied(
_("The faculty manager cannot modify general information which are lower than N"
))
return True
def add_reviewer_for_structure(request):
current_entity = entity.find_by_id(request.POST.get("entity"))
year = academic_year.starting_academic_year().year
current_reviewer = reviewer_eligible_to_delegate(
reviewer.find_by_person(request.user.person),
current_entity
)
if not current_reviewer:
return redirect('assistants_home')
form = ReviewerDelegationForm(data=request.POST)
if form.is_valid() and request.POST.get('person_id'):
new_reviewer = form.save(commit=False)
new_reviewer.person = person.find_by_id(request.POST.get('person_id'))
new_reviewer.save()
send_message(
person=new_reviewer.person,
html_template_ref='assistant_reviewers_startup_html',
txt_template_ref='assistant_reviewers_startup_txt'
)
return redirect('reviewer_delegation')
role = current_reviewer.role + '_ASSISTANT'
form = ReviewerDelegationForm(initial={'entity': current_entity, 'year': year, 'role': role})
return render(request, "reviewer_add_reviewer.html", {
'form': form,
'year': year,
'entity': current_entity,
'reviewer': current_reviewer
})
def export_declined_mandates(request):
current_academic_year = academic_year.starting_academic_year()
return render(
request, 'export_declined_mandates.html', {
'form':
ExportDeclineMandateForm(
initial={'academic_year': current_academic_year})
})
def count_by_proposition(proposition):
starting_academic_year = academic_year.starting_academic_year()
return Dissertation.objects.filter(proposition_dissertation=proposition) \
.filter(active=True) \
.filter(education_group_year__academic_year=starting_academic_year) \
.exclude(status=dissertation_status.DRAFT) \
.exclude(status=dissertation_status.DIR_KO) \
.count()
def test_starting_equalto_current(self):
start_date = timezone.now() - datetime.timedelta(days=5)
end_date = start_date + datetime.timedelta(days=220)
academic_yr = AcademicYearFactory(year=start_date.year,
start_date=start_date,
end_date=end_date)
starting_academic_year = academic_year.starting_academic_year()
self.assertEqual(starting_academic_year.year, academic_yr.year)
def count_by_proposition(prop_dissert):
current_academic_year = academic_year.starting_academic_year()
return Dissertation.objects.filter(proposition_dissertation=prop_dissert)\
.filter(active=True)\
.filter(offer_year_start__academic_year=current_academic_year)\
.exclude(status='DRAFT') \
.exclude(status='DIR_KO') \
.count()
def _restrict_academic_years_choice_for_proposal_creation_suppression(
self, proposal_type):
if proposal_type in (ProposalType.CREATION.name,
ProposalType.SUPPRESSION):
if self.person.is_faculty_manager and proposal_type == ProposalType.CREATION.name:
starting_academic_year = academic_year.starting_academic_year(
).next()
else:
starting_academic_year = academic_year.starting_academic_year()
end_year_range = MAX_ACADEMIC_YEAR_CENTRAL - 1 if self.person.is_faculty_manager \
else MAX_ACADEMIC_YEAR_CENTRAL
self.fields[
"academic_year"].queryset = academic_year.find_academic_years(
start_year=starting_academic_year.year,
end_year=starting_academic_year.year + end_year_range)
def setUpTestData(cls):
AcademicYearFactory(year=(now.year - 1),
start_date=datetime.datetime(now.year - 1, now.month, 15),
end_date=datetime.datetime(now.year, now.month, 28))
AcademicYearFactory(year=now.year,
start_date=datetime.datetime(now.year, now.month, 1),
end_date=datetime.datetime(now.year + 1, now.month, 28))
cls.current_academic_yr = academic_year.current_academic_year()
cls.starting_academic_yr = academic_year.starting_academic_year()
def get_initial(self):
if self.request.session.get('selected_academic_year'):
selected_academic_year = academic_year.find_academic_year_by_id(
self.request.session.get('selected_academic_year'))
else:
selected_academic_year = academic_year.starting_academic_year()
self.request.session[
'selected_academic_year'] = selected_academic_year.id
return {'academic_year': selected_academic_year}
def find_by_entity_and_reference(entity_id, reference, academic_year=None):
try:
return EntityCalendar.objects.filter(
entity_id=entity_id,
academic_calendar__academic_year=academic_year or starting_academic_year(),
academic_calendar__reference=reference
).select_related('entity', 'academic_calendar__academic_year').get()
except ObjectDoesNotExist:
return None
def _restrict_academic_years_choice(self):
starting_academic_year = academic_year.starting_academic_year()
end_year_range = MAX_ACADEMIC_YEAR_FACULTY if self.person.is_faculty_manager(
) else MAX_ACADEMIC_YEAR_CENTRAL
self.fields[
"academic_year"].queryset = academic_year.find_academic_years(
start_year=starting_academic_year.year,
end_year=starting_academic_year.year + end_year_range)
def test_find_academic_years(self):
today = datetime.date.today()
academic_yrs = academic_year.find_academic_years(start_date=today, end_date=today)
current_academic_yr = academic_year.current_academic_year()
starting_academic_yr = academic_year.starting_academic_year()
nb_of_academic_yrs = academic_yrs.count()
if starting_academic_yr != current_academic_yr:
self.assertEqual(nb_of_academic_yrs, 2)
else:
self.assertEqual(nb_of_academic_yrs, 1)
def _is_person_eligible_to_edit_proposal_based_on_state(proposal, person):
if person.is_central_manager():
return True
if proposal.state != ProposalState.FACULTY.name:
return False
if (proposal.type == ProposalType.MODIFICATION.name
and proposal.learning_unit_year.academic_year.year !=
starting_academic_year().year + 1):
return False
return True
def _restrict_academic_years_choice(self, postposal, proposal_type):
if postposal:
starting_academic_year = academic_year.starting_academic_year()
end_year_range = MAX_ACADEMIC_YEAR_FACULTY if self.person.is_faculty_manager \
else MAX_ACADEMIC_YEAR_CENTRAL
self.fields["academic_year"].queryset = AcademicYear.objects.min_max_years(
starting_academic_year.year, starting_academic_year.year + end_year_range
)
else:
self._restrict_academic_years_choice_for_proposal_creation_suppression(proposal_type)
def _restrict_academic_years_choice_for_proposal_creation_suppression(self, proposal_type):
if proposal_type in (ProposalType.CREATION.name, ProposalType.SUPPRESSION):
if self.person.is_faculty_manager and proposal_type == ProposalType.CREATION.name:
starting_academic_year = academic_year.current_academic_year().next()
else:
starting_academic_year = academic_year.starting_academic_year()
end_year_range = MAX_ACADEMIC_YEAR_CENTRAL - 1 if self.person.is_faculty_manager \
else MAX_ACADEMIC_YEAR_CENTRAL
self.fields["academic_year"].queryset = academic_year.find_academic_years(
start_year=starting_academic_year.year,
end_year=starting_academic_year.year + end_year_range
)
def _is_person_eligible_to_edit_proposal_based_on_state(proposal, person, raise_exception=False):
if person.is_central_manager:
return True
if proposal.state != ProposalState.FACULTY.name:
can_raise_exception(
raise_exception,
False,
MSG_NOT_PROPOSAL_STATE_FACULTY
)
return False
if proposal.type == ProposalType.MODIFICATION.name and \
proposal.learning_unit_year.academic_year.year != starting_academic_year().year + 1:
can_raise_exception(
raise_exception,
False,
MSG_PROPOSAL_IS_ON_AN_OTHER_YEAR
)
return False
return True
def __init__(self, instance):
"""
The instance must be a training in the current academic year with an end year greater than
the next academic year.
During the initialization, we'll also check if the current instance has a content to postpone.
"""
if not isinstance(instance, EducationGroupYear):
raise NotPostponeError(_('You are not allowed to copy the content of this kind of education group.'))
self.instance = instance
self.current_year = starting_academic_year()
self.next_academic_year = self.current_year.next()
self.check_instance()
self.result = []
self.warnings = []
self.instance_n1 = self.get_instance_n1(self.instance)
self.postponed_luy = []
self.postponed_options = {}
self.postponed_finalities = []
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields['academic_year'].initial = academic_year.starting_academic_year()
def is_academic_year_in_range_to_create_partim(learning_unit_year, person, raise_exception=False):
current_acy = starting_academic_year()
luy_acy = learning_unit_year.academic_year
max_range = MAX_ACADEMIC_YEAR_FACULTY if person.is_faculty_manager else MAX_ACADEMIC_YEAR_CENTRAL
return current_acy.year <= luy_acy.year <= current_acy.year + max_range
