def _create_attribution_charge(academic_year,
attribution,
l_acronym,
volume_cm=None,
volume_tp=None):
from base.models.learning_unit_component import LearningUnitComponent
if volume_cm is not None:
l_unit_component = LearningUnitComponent.objects.filter(
learning_unit_year__acronym=l_acronym,
learning_unit_year__academic_year=academic_year,
learning_component_year__type=learning_component_year_type.
LECTURING).first()
AttributionChargeNewFactory(
attribution=attribution,
learning_component_year=l_unit_component.learning_component_year,
allocation_charge=volume_cm)
if volume_tp is not None:
l_unit_component = LearningUnitComponent.objects.filter(
learning_unit_year__acronym=l_acronym,
learning_unit_year__academic_year=academic_year,
learning_component_year__type=learning_component_year_type.
PRACTICAL_EXERCISES).first()
AttributionChargeNewFactory(
attribution=attribution,
learning_component_year=l_unit_component.learning_component_year,
allocation_charge=volume_tp)
class TestChargeRepartitionMixin:
@classmethod
def setUpTestData(cls):
cls.learning_unit_year = LearningUnitYearPartimFactory()
cls.lecturing_unit_component = LecturingLearningUnitComponentFactory(
learning_unit_year=cls.learning_unit_year)
cls.practical_unit_component = PracticalLearningUnitComponentFactory(
learning_unit_year=cls.learning_unit_year)
cls.full_learning_unit_year = LearningUnitYearFullFactory(
learning_container_year=cls.learning_unit_year.
learning_container_year,
academic_year=cls.learning_unit_year.academic_year)
cls.lecturing_unit_component_full = LecturingLearningUnitComponentFactory(
learning_unit_year=cls.full_learning_unit_year)
cls.practical_unit_component_full = PracticalLearningUnitComponentFactory(
learning_unit_year=cls.full_learning_unit_year)
cls.person = PersonWithPermissionsFactory('can_access_learningunit')
def setUp(self):
self.attribution = AttributionNewFactory(
learning_container_year=self.learning_unit_year.
learning_container_year)
attribution_id = self.attribution.id
self.charge_lecturing = AttributionChargeNewFactory(
attribution=self.attribution,
learning_component_year=self.lecturing_unit_component.
learning_component_year)
self.charge_practical = AttributionChargeNewFactory(
attribution=self.attribution,
learning_component_year=self.practical_unit_component.
learning_component_year)
self.attribution_full = self.attribution
self.attribution_full.id = None
self.attribution_full.save()
self.charge_lecturing_full = AttributionChargeNewFactory(
attribution=self.attribution_full,
learning_component_year=self.lecturing_unit_component_full.
learning_component_year)
self.charge_practical_full = AttributionChargeNewFactory(
attribution=self.attribution_full,
learning_component_year=self.practical_unit_component_full.
learning_component_year)
self.attribution = AttributionNew.objects.get(id=attribution_id)
self.client.force_login(self.person.user)
self.patcher = patch.object(RulesRequiredMixin,
"test_func",
return_value=True)
self.mocked_permission_function = self.patcher.start()
def tearDown(self):
self.patcher.stop()
def clean_partim_charges(self):
self.charge_practical.delete()
self.charge_lecturing.delete()
self.attribution.delete()
def setUp(self):
self.learning_unit_year = LearningUnitYearFullFactory(
learning_container_year = self.learning_container_year
)
self.lecturing_component = LecturingLearningComponentYearFactory(
learning_unit_year=self.learning_unit_year)
self.practical_component = PracticalLearningComponentYearFactory(
learning_unit_year=self.learning_unit_year)
self.attribution = AttributionNewFactory(
learning_container_year=self.learning_unit_year.learning_container_year
)
self.charge_lecturing = AttributionChargeNewFactory(
attribution=self.attribution,
learning_component_year=self.lecturing_component
)
self.charge_practical = AttributionChargeNewFactory(
attribution=self.attribution,
learning_component_year=self.practical_component
)
self.client.force_login(self.person.user)
self.url = reverse("update_attribution", args=[self.learning_unit_year.id, self.attribution.id])
self.patcher = patch.object(RulesRequiredMixin, "test_func", return_value=True)
self.mocked_permission_function = self.patcher.start()
def setUpTestData(cls):
cls.education_group_year = EducationGroupYearFactory()
cls.child_leaves = GroupElementYearChildLeafFactory.create_batch(
2, parent=cls.education_group_year, is_mandatory=True)
for node, acronym in zip(
cls.child_leaves,
["LCORS124" + str(i) for i in range(0, len(cls.child_leaves))]):
node.child_leaf.acronym = acronym
node.child_leaf.save()
cls.luy_children = [child.child_leaf for child in cls.child_leaves]
cls.workbook_contains = \
EducationGroupYearLearningUnitsContainedToExcel(cls.education_group_year, CustomXlsForm({}))._to_workbook()
cls.sheet_contains = cls.workbook_contains.worksheets[0]
generator_container = GenerateContainer(
cls.education_group_year.academic_year,
cls.education_group_year.academic_year)
cls.luy = generator_container.generated_container_years[
0].learning_unit_year_full
cls.lecturing_component = LecturingLearningComponentYearFactory(
learning_unit_year=cls.luy)
cls.practical_component = PracticalLearningComponentYearFactory(
learning_unit_year=cls.luy)
cls.person_1 = PersonFactory(last_name='Dupont',
first_name="Marcel",
email="*****@*****.**")
cls.person_2 = PersonFactory(last_name='Marseillais',
first_name="Pol",
email="*****@*****.**")
cls.tutor_1 = TutorFactory(person=cls.person_1)
cls.tutor_2 = TutorFactory(person=cls.person_2)
cls.attribution_1 = AttributionNewFactory(
tutor=cls.tutor_1,
learning_container_year=cls.luy.learning_container_year)
cls.charge_lecturing = AttributionChargeNewFactory(
attribution=cls.attribution_1,
learning_component_year=cls.lecturing_component)
cls.charge_practical = AttributionChargeNewFactory(
attribution=cls.attribution_1,
learning_component_year=cls.practical_component)
cls.attribution_2 = AttributionNewFactory(
tutor=cls.tutor_2,
learning_container_year=cls.luy.learning_container_year)
cls.charge_lecturing = AttributionChargeNewFactory(
attribution=cls.attribution_2,
learning_component_year=cls.lecturing_component)
cls.charge_practical = AttributionChargeNewFactory(
attribution=cls.attribution_2,
learning_component_year=cls.practical_component)
cls.gey = GroupElementYearChildLeafFactory(child_leaf=cls.luy)
def setUp(self):
self.person = PersonFactory(first_name="John", last_name="Doe")
self.tutor = TutorFactory(person=self.person)
self.attribution_new = AttributionNewFactory(tutor=self.tutor, function=function.PROFESSOR)
self.attribution_new_without_attribution_charge = AttributionNewFactory(tutor=self.tutor,
function=function.PROFESSOR)
self.learning_component_year_lecturing = LearningComponentYearFactory(type=component_type.LECTURING)
self.learning_component_year_practical = LearningComponentYearFactory(type=component_type.PRACTICAL_EXERCISES)
self.attribution_charge_new_lecturing = \
AttributionChargeNewFactory(attribution=self.attribution_new,
learning_component_year=self.learning_component_year_lecturing,
allocation_charge=10)
self.attribution_charge_new_practical = \
AttributionChargeNewFactory(attribution=self.attribution_new,
learning_component_year=self.learning_component_year_practical,
allocation_charge=20)
class AttributionChargeNewTest(TestCase):
def setUp(self):
self.person = PersonFactory(first_name="John", last_name="Doe")
self.tutor = TutorFactory(person=self.person)
self.attribution_new = AttributionNewFactory(tutor=self.tutor, function=function.PROFESSOR)
self.attribution_new_without_attribution_charge = AttributionNewFactory(tutor=self.tutor,
function=function.PROFESSOR)
self.learning_component_year_lecturing = LearningComponentYearFactory(type=component_type.LECTURING)
self.learning_component_year_practical = LearningComponentYearFactory(type=component_type.PRACTICAL_EXERCISES)
self.attribution_charge_new_lecturing = \
AttributionChargeNewFactory(attribution=self.attribution_new,
learning_component_year=self.learning_component_year_lecturing,
allocation_charge=10)
self.attribution_charge_new_practical = \
AttributionChargeNewFactory(attribution=self.attribution_new,
learning_component_year=self.learning_component_year_practical,
allocation_charge=20)
def test_search_with_attribution(self):
result = attribution_charge_new.search(attribution=self.attribution_new)
self.assertCountEqual(result, [self.attribution_charge_new_lecturing, self.attribution_charge_new_practical])
def test_search_with_learning_component_year(self):
result = attribution_charge_new.search(learning_component_year=self.learning_component_year_practical)
self.assertCountEqual(result, [self.attribution_charge_new_practical])
def test_search_with_learning_component_year_list(self):
learning_component_year_list = [self.learning_component_year_lecturing, self.learning_component_year_practical]
result = attribution_charge_new.search(learning_component_year=learning_component_year_list)
self.assertCountEqual(result, [self.attribution_charge_new_practical, self.attribution_charge_new_lecturing])
def test_str_function(self):
self.assertEqual(self.attribution_charge_new_lecturing.__str__(), "DOE, John - PROFESSOR")
def setUpTestData(cls):
cls.person = PersonWithPermissionsFactory('can_access_learningunit')
cls.luy_without_attribution = LearningUnitYearFullFactory()
cls.luy = LearningUnitYearFullFactory()
cls.lecturing_component = LecturingLearningComponentYearFactory(
learning_unit_year=cls.luy)
cls.practical_component = PracticalLearningComponentYearFactory(
learning_unit_year=cls.luy)
cls.attribution = AttributionNewFactory(
learning_container_year=cls.luy.learning_container_year)
cls.charge_lecturing = AttributionChargeNewFactory(
attribution=cls.attribution,
learning_component_year=cls.lecturing_component)
cls.charge_practical = AttributionChargeNewFactory(
attribution=cls.attribution,
learning_component_year=cls.practical_component)
def test_should_exclude_attributions_for_which_repartition_has_been_done(
self):
attribution = self.attribution_full
attribution.id = None
attribution.save()
charge_lecturing = AttributionChargeNewFactory(
attribution=attribution,
learning_component_year=self.lecturing_unit_component.
learning_component_year)
charge_practical = AttributionChargeNewFactory(
attribution=attribution,
learning_component_year=self.practical_unit_component.
learning_component_year)
response = self.client.get(self.url)
context = response.context
self.assertQuerysetEqual(context["attributions"], [])
def setUpTestData(cls):
cls.attribution_charge = AttributionChargeNewFactory()
cls.attribution = AttributionNew.objects.annotate(
first_name=F('tutor__person__first_name'),
middle_name=F('tutor__person__middle_name'),
last_name=F('tutor__person__last_name'),
email=F('tutor__person__email'),
global_id=F('tutor__person__global_id'),
).get(id=cls.attribution_charge.attribution_id)
cls.serializer = LearningUnitAttributionSerializer(cls.attribution)
def setUpTestData(cls):
cls.full_luy = LearningUnitYearFullFactory()
cls.partim_luy_1 = LearningUnitYearPartimFactory(
academic_year=cls.full_luy.academic_year,
learning_container_year=cls.full_luy.learning_container_year)
cls.partim_luy_2 = LearningUnitYearPartimFactory(
academic_year=cls.full_luy.academic_year,
learning_container_year=cls.full_luy.learning_container_year)
cls.attribution_full = AttributionNewFactory(
learning_container_year=cls.full_luy.learning_container_year)
cls.full_lecturing_component = LecturingLearningComponentYearFactory(
learning_unit_year=cls.full_luy)
cls.full_practical_component = PracticalLearningComponentYearFactory(
learning_unit_year=cls.full_luy)
cls.partim_1_lecturing_component = \
LecturingLearningComponentYearFactory(learning_unit_year=cls.partim_luy_1)
cls.partim_1_practical_component = \
PracticalLearningComponentYearFactory(learning_unit_year=cls.partim_luy_1)
cls.partim_2_lecturing_component = \
LecturingLearningComponentYearFactory(learning_unit_year=cls.partim_luy_2)
cls.partim_2_practical_component = \
PracticalLearningComponentYearFactory(learning_unit_year=cls.partim_luy_2)
cls.charge_lecturing = AttributionChargeNewFactory(
attribution=cls.attribution_full,
learning_component_year=cls.full_lecturing_component,
allocation_charge=20)
cls.charge_practical = AttributionChargeNewFactory(
attribution=cls.attribution_full,
learning_component_year=cls.full_practical_component,
allocation_charge=20)
cls.attribution_partim_1 = cls.attribution_full
cls.attribution_partim_1.id = None
cls.attribution_partim_1.save()
cls.attribution_partim_2 = cls.attribution_full
cls.attribution_partim_2.id = None
cls.attribution_partim_2.save()
def setUp(self):
self.academic_year = AcademicYearFactory(year=timezone.now().year)
self.l_unit_1 = LearningUnitYearFactory(
acronym="LBIR1212",
academic_year=self.academic_year,
subtype=learning_unit_year_subtypes.FULL)
component = LearningComponentYearFactory(
learning_unit_year=self.l_unit_1)
self.attribution_charge_news = [
AttributionChargeNewFactory(learning_component_year=component)
for _ in range(5)
]
def _create_attribution_charge(academic_year,
attribution,
l_acronym,
volume_cm=None,
volume_tp=None):
component_qs = LearningComponentYear.objects.filter(
learning_unit_year__acronym=l_acronym,
learning_unit_year__academic_year=academic_year)
if volume_cm is not None:
component = component_qs.filter(
type=learning_component_year_type.LECTURING).first()
AttributionChargeNewFactory(attribution=attribution,
learning_component_year=component,
allocation_charge=volume_cm)
if volume_tp is not None:
component = component_qs.filter(
type=learning_component_year_type.PRACTICAL_EXERCISES).first()
AttributionChargeNewFactory(attribution=attribution,
learning_component_year=component,
allocation_charge=volume_tp)
def setUpTestData(cls):
cls.academic_year = AcademicYearFactory(current=True)
cls.l_unit_1 = LearningUnitYearFactory(
acronym="LBIR1212",
academic_year=cls.academic_year,
subtype=learning_unit_year_subtypes.FULL)
component = LearningComponentYearFactory(
learning_unit_year=cls.l_unit_1)
cls.attribution_charge_news = [
AttributionChargeNewFactory(learning_component_year=component)
for _ in range(5)
]
def setUp(self):
self.attribution = AttributionNewFactory(
learning_container_year=self.learning_unit_year.
learning_container_year)
attribution_id = self.attribution.id
self.charge_lecturing = AttributionChargeNewFactory(
attribution=self.attribution,
learning_component_year=self.lecturing_component)
self.charge_practical = AttributionChargeNewFactory(
attribution=self.attribution,
learning_component_year=self.practical_component)
self.attribution_full = self.attribution
self.attribution_full.id = None
self.attribution_full.save()
self.charge_lecturing_full = AttributionChargeNewFactory(
attribution=self.attribution_full,
learning_component_year=self.lecturing_component_full)
self.charge_practical_full = AttributionChargeNewFactory(
attribution=self.attribution_full,
learning_component_year=self.practical_component_full)
self.attribution = AttributionNew.objects.get(id=attribution_id)
self.client.force_login(self.person.user)
self.patcher = patch.object(RulesRequiredMixin,
"test_func",
return_value=True)
self.mocked_permission_function = self.patcher.start()
self.addCleanup(self.patcher.stop)
def setUpTestData(cls):
cls.person = PersonWithPermissionsFactory('can_access_learningunit')
cls.learning_container_year = LearningContainerYearFactory(
container_type=LearningContainerYearType.COURSE.name
)
cls.learning_unit_year = LearningUnitYearFullFactory(
learning_container_year=cls.learning_container_year
)
cls.lecturing_component = LecturingLearningComponentYearFactory(
learning_unit_year=cls.learning_unit_year)
cls.practical_component = PracticalLearningComponentYearFactory(
learning_unit_year=cls.learning_unit_year)
cls.attribution = AttributionNewFactory(
learning_container_year=cls.learning_unit_year.learning_container_year
)
cls.charge_lecturing = AttributionChargeNewFactory(
attribution=cls.attribution,
learning_component_year=cls.lecturing_component
)
cls.charge_practical = AttributionChargeNewFactory(
attribution=cls.attribution,
learning_component_year=cls.practical_component
)
def setUp(self):
generator_container = GenerateContainer(datetime.date.today().year-2, datetime.date.today().year)
self.learning_unit_yr_1 = generator_container.generated_container_years[0].learning_unit_year_full
self.learning_unit_yr_1.entities = {
entity_container_year_link_type.REQUIREMENT_ENTITY: EntityVersionFactory(acronym=ACRONYM_REQUIREMENT),
entity_container_year_link_type.ALLOCATION_ENTITY: EntityVersionFactory(acronym=ACRONYM_ALLOCATION)
}
component_1 = LearningUnitComponentFactory(learning_unit_year=self.learning_unit_yr_1)
self.attribution_1 = AttributionChargeNewFactory(learning_component_year=component_1.learning_component_year)
self.learning_unit_yr_1.attribution_charge_news = attribution_charge_new. \
find_attribution_charge_new_by_learning_unit_year(self.learning_unit_yr_1)
self.user = UserFactory()
def test_delete_all_learning_units_year_case_error_have_attributionnew_with_charge(
self):
learning_unit_years = self.learning_unit_year_list
ly1 = learning_unit_years[1]
attrib_new_1 = AttributionNewFactory(
learning_container_year=ly1.learning_container_year)
learning_component_year_1 = LearningComponentYearFactory(
learning_unit_year=ly1)
AttributionChargeNewFactory(
attribution=attrib_new_1,
learning_component_year=learning_component_year_1)
request_factory = RequestFactory()
request = request_factory.post(
reverse(delete_all_learning_units_year, args=[ly1.id]))
request.user = self.user
setattr(request, 'session', 'session')
setattr(request, '_messages', FallbackStorage(request))
response = delete_all_learning_units_year(request, ly1.id)
# Get message from context
msg = [m.message for m in get_messages(request)]
msg_level = [m.level for m in get_messages(request)]
self.assertEqual(len(msg), 1)
self.assertIn(messages.ERROR, msg_level)
# Check error message
subtype = _('The partim') if ly1.is_partim() else _(
'The learning unit')
self.assertIn(
_("%(subtype)s %(acronym)s is assigned to %(tutor)s for the year %(year)s"
) % {
'subtype': subtype,
'acronym': ly1.acronym,
'tutor': attrib_new_1.tutor,
'year': ly1.academic_year
}, msg)
# Check that record is not deleted
self.assertTrue(LearningUnitYear.objects.filter(pk=ly1.pk).exists())
# Check redirection to identification
self.assertEqual(response.status_code, 302)
self.assertEqual(
response.url,
reverse('learning_unit', kwargs={'learning_unit_year_id': ly1.pk}))
def setUp(self):
self.charge_lecturing_1 = AttributionChargeNewFactory(
attribution=self.attribution_partim_1,
learning_component_year=self.partim_1_lecturing_component,
allocation_charge=10)
self.charge_practical_1 = AttributionChargeNewFactory(
attribution=self.attribution_partim_1,
learning_component_year=self.partim_1_practical_component,
allocation_charge=10)
self.charge_lecturing_2 = AttributionChargeNewFactory(
attribution=self.attribution_partim_2,
learning_component_year=self.partim_2_lecturing_component,
allocation_charge=10)
self.charge_practical_2 = AttributionChargeNewFactory(
attribution=self.attribution_partim_2,
learning_component_year=self.partim_2_practical_component,
allocation_charge=10)
def setUpTestData(cls):
tutor = TutorFactory(person=PersonFactory())
cls.attribution = AttributionNewFactory(
tutor=tutor,
substitute=PersonFactory()
)
cls.luy = LearningUnitYearFactory()
cls.attribution_charge = AttributionChargeNewFactory(
attribution=cls.attribution,
learning_component_year__learning_unit_year=cls.luy
)
cls.person = PersonFactory()
url_kwargs = {
'acronym': cls.luy.acronym,
'year': cls.luy.academic_year.year
}
cls.url = reverse('learning_unit_api_v1:learningunitattributions_read', kwargs=url_kwargs)
def setUp(self):
self.country = CountryFactory()
self.academic_yr = AcademicYearFactory(year=timezone.now().year)
self.start_date = self.academic_yr.start_date
self.end_date = self.academic_yr.end_date
self.list_learning_unit_container_year = self._create_list_containers(4)
self.list_learning_unit_year = self._create_list_learning_units_from_containers(
self.list_learning_unit_container_year)
self.list_entity_version = self._create_list_entities_version()
self._add_entities_to_containers(
self.list_entity_version,
self.list_learning_unit_container_year
)
self.tutor = TutorFactory()
self.attribution = AttributionNewFactory(tutor=self.tutor)
self.learning_component = LearningComponentYearFactory(learning_unit_year=self.list_learning_unit_year[0])
self.attribution_charge_new = \
AttributionChargeNewFactory(attribution=self.attribution,
learning_component_year=self.learning_component)
def step_impl(context, person, luys, year):
"""
:type context: behave.runner.Context
"""
ac_year = AcademicYear.objects.get(year=year[:4])
luys = LearningUnitYear.objects.filter(acronym__in=luys.split(','),
academic_year=ac_year)
for luy in luys:
# Use all possible factories. I have no idea which is the good one.
attribution = AttributionNewFactory(
learning_container_year=luy.learning_container_year,
tutor__person__last_name=person,
start_year=ac_year.year,
)
AttributionFactory(
learning_unit_year=luy,
tutor__person__last_name=person,
start_year=ac_year.year,
)
AttributionChargeNewFactory(
learning_component_year=luy.learningcomponentyear_set.first(),
attribution=attribution)
def test_get_data_part2(self):
learning_container_luy = LearningContainerYearFactory(
academic_year=self.current_academic_year)
luy = LearningUnitYearFactory(
academic_year=self.current_academic_year,
learning_container_year=learning_container_luy,
periodicity=learning_unit_year_periodicity.ANNUAL,
status=True,
language=None,
)
component_lecturing = LearningComponentYearFactory(
learning_container_year=learning_container_luy,
type=learning_component_year_type.LECTURING,
hourly_volume_total_annual=15,
hourly_volume_partial_q1=10,
hourly_volume_partial_q2=5,
planned_classes=1)
component_practical = LearningComponentYearFactory(
learning_container_year=learning_container_luy,
type=learning_component_year_type.PRACTICAL_EXERCISES,
hourly_volume_total_annual=15,
hourly_volume_partial_q1=10,
hourly_volume_partial_q2=5,
planned_classes=1)
LearningUnitComponentFactory(
learning_unit_year=luy,
learning_component_year=component_lecturing)
LearningUnitComponentFactory(
learning_unit_year=luy,
learning_component_year=component_practical)
a_tutor = TutorFactory()
an_attribution = AttributionNewFactory(tutor=a_tutor, start_year=2017)
attribution_charge_new_lecturing = AttributionChargeNewFactory(
learning_component_year=component_lecturing,
attribution=an_attribution,
allocation_charge=15.0)
attribution_charge_new_practical = AttributionChargeNewFactory(
learning_component_year=component_practical,
attribution=an_attribution,
allocation_charge=5.0)
luy.attribution_charge_news = attribution_charge_new.find_attribution_charge_new_by_learning_unit_year(
luy)
expected_common = [
xls_build.translate(luy.periodicity),
xls_build.translate(luy.status),
component_lecturing.hourly_volume_total_annual,
component_lecturing.hourly_volume_partial_q1,
component_lecturing.hourly_volume_partial_q2,
component_lecturing.planned_classes,
component_practical.hourly_volume_total_annual,
component_practical.hourly_volume_partial_q1,
component_practical.hourly_volume_partial_q2,
component_practical.planned_classes,
xls_build.translate(luy.quadrimester),
xls_build.translate(luy.session), "", ''
]
self.assertEqual(_get_data_part2(luy, False), expected_common)
self.assertEqual(
_get_data_part2(luy, True),
expected_attribution_data(attribution_charge_new_lecturing,
attribution_charge_new_practical,
expected_common, luy))
class TestGetChargeRepartitionWarningMessage(TestCase):
@classmethod
def setUpTestData(cls):
cls.full_luy = LearningUnitYearFullFactory()
cls.partim_luy_1 = LearningUnitYearPartimFactory(
academic_year=cls.full_luy.academic_year,
learning_container_year=cls.full_luy.learning_container_year)
cls.partim_luy_2 = LearningUnitYearPartimFactory(
academic_year=cls.full_luy.academic_year,
learning_container_year=cls.full_luy.learning_container_year)
cls.attribution_full = AttributionNewFactory(
learning_container_year=cls.full_luy.learning_container_year)
cls.full_lecturing_component = LecturingLearningComponentYearFactory(
learning_unit_year=cls.full_luy)
cls.full_practical_component = PracticalLearningComponentYearFactory(
learning_unit_year=cls.full_luy)
cls.partim_1_lecturing_component = \
LecturingLearningComponentYearFactory(learning_unit_year=cls.partim_luy_1)
cls.partim_1_practical_component = \
PracticalLearningComponentYearFactory(learning_unit_year=cls.partim_luy_1)
cls.partim_2_lecturing_component = \
LecturingLearningComponentYearFactory(learning_unit_year=cls.partim_luy_2)
cls.partim_2_practical_component = \
PracticalLearningComponentYearFactory(learning_unit_year=cls.partim_luy_2)
cls.charge_lecturing = AttributionChargeNewFactory(
attribution=cls.attribution_full,
learning_component_year=cls.full_lecturing_component,
allocation_charge=20)
cls.charge_practical = AttributionChargeNewFactory(
attribution=cls.attribution_full,
learning_component_year=cls.full_practical_component,
allocation_charge=20)
cls.attribution_partim_1 = cls.attribution_full
cls.attribution_partim_1.id = None
cls.attribution_partim_1.save()
cls.attribution_partim_2 = cls.attribution_full
cls.attribution_partim_2.id = None
cls.attribution_partim_2.save()
def setUp(self):
self.charge_lecturing_1 = AttributionChargeNewFactory(
attribution=self.attribution_partim_1,
learning_component_year=self.partim_1_lecturing_component,
allocation_charge=10)
self.charge_practical_1 = AttributionChargeNewFactory(
attribution=self.attribution_partim_1,
learning_component_year=self.partim_1_practical_component,
allocation_charge=10)
self.charge_lecturing_2 = AttributionChargeNewFactory(
attribution=self.attribution_partim_2,
learning_component_year=self.partim_2_lecturing_component,
allocation_charge=10)
self.charge_practical_2 = AttributionChargeNewFactory(
attribution=self.attribution_partim_2,
learning_component_year=self.partim_2_practical_component,
allocation_charge=10)
def test_should_not_give_warning_messages_when_volume_partim_inferior_or_equal_to_volume_parent(
self):
msgs = get_charge_repartition_warning_messages(
self.full_luy.learning_container_year)
self.assertEqual(msgs, [])
def test_should_not_fail_when_no_charges(self):
self.charge_lecturing_1.allocation_charge = None
self.charge_lecturing_1.save()
self.charge_lecturing_2.allocation_charge = None
self.charge_lecturing_2.save()
self.charge_practical_1.allocation_charge = None
self.charge_practical_1.save()
self.charge_practical_2.allocation_charge = None
self.charge_practical_2.save()
msgs = get_charge_repartition_warning_messages(
self.full_luy.learning_container_year)
self.assertEqual(msgs, [])
def test_should_give_warning_messages_when_volume_partim_superior_to_volume_parent(
self):
self.charge_lecturing_1.allocation_charge = 50
self.charge_lecturing_1.save()
msgs = get_charge_repartition_warning_messages(
self.full_luy.learning_container_year)
tutor_name = Person.get_str(
self.attribution_full.tutor.person.first_name,
self.attribution_full.tutor.person.middle_name,
self.attribution_full.tutor.person.last_name)
tutor_name_with_function = "{} ({})".format(
tutor_name, _(self.attribution_full.get_function_display()))
self.assertListEqual(msgs, [
_("The sum of volumes for the partims for professor %(tutor)s is superior to the "
"volume of full UE for this professor") % {
"tutor": tutor_name_with_function
}
])
class TestEditAttribution(TestCase):
@classmethod
def setUpTestData(cls):
cls.person = PersonWithPermissionsFactory('can_access_learningunit')
cls.learning_container_year = LearningContainerYearFactory(
container_type=LearningContainerYearType.COURSE.name
)
def setUp(self):
self.learning_unit_year = LearningUnitYearFullFactory(
learning_container_year = self.learning_container_year
)
self.lecturing_component = LecturingLearningComponentYearFactory(
learning_unit_year=self.learning_unit_year)
self.practical_component = PracticalLearningComponentYearFactory(
learning_unit_year=self.learning_unit_year)
self.attribution = AttributionNewFactory(
learning_container_year=self.learning_unit_year.learning_container_year
)
self.charge_lecturing = AttributionChargeNewFactory(
attribution=self.attribution,
learning_component_year=self.lecturing_component
)
self.charge_practical = AttributionChargeNewFactory(
attribution=self.attribution,
learning_component_year=self.practical_component
)
self.client.force_login(self.person.user)
self.url = reverse("update_attribution", args=[self.learning_unit_year.id, self.attribution.id])
self.patcher = patch.object(RulesRequiredMixin, "test_func", return_value=True)
self.mocked_permission_function = self.patcher.start()
def tearDown(self):
self.patcher.stop()
def test_login_required(self):
self.client.logout()
response = self.client.get(self.url)
self.assertRedirects(response, '/login/?next={}'.format(self.url))
def test_template_used_with_get(self):
response = self.client.get(self.url)
self.assertTrue(self.mocked_permission_function.called)
self.assertEqual(response.status_code, HttpResponse.status_code)
self.assertTemplateUsed(response, "learning_unit/attribution_inner.html")
def test_post(self):
data = {
'attribution_form-function': COORDINATOR,
'attribution_form-start_year': 2018,
'attribution_form-duration': 3,
'lecturing_form-allocation_charge': 50,
'practical_form-allocation_charge': 10
}
response = self.client.post(self.url, data=data)
self.attribution.refresh_from_db()
self.charge_lecturing.refresh_from_db()
self.charge_practical.refresh_from_db()
self.assertEqual(self.attribution.function, COORDINATOR)
self.assertEqual(self.attribution.start_year, 2018)
self.assertEqual(self.attribution.end_year, 2020)
self.assertEqual(self.charge_lecturing.allocation_charge, 50)
self.assertEqual(self.charge_practical.allocation_charge, 10)
self.assertRedirects(response,
reverse("learning_unit_attributions", args=[self.learning_unit_year.id]))
def test_post_partim(self):
self.learning_unit_year.subtype = PARTIM
self.learning_unit_year.save()
data = {
'attribution_form-function': COORDINATOR,
'lecturing_form-allocation_charge': 50,
'practical_form-allocation_charge': 10
}
response = self.client.post(self.url, data=data)
self.attribution.refresh_from_db()
self.charge_lecturing.refresh_from_db()
self.charge_practical.refresh_from_db()
self.assertEqual(self.charge_lecturing.allocation_charge, 50)
self.assertEqual(self.charge_practical.allocation_charge, 10)
self.assertRedirects(response,
reverse("learning_unit_attributions", args=[self.learning_unit_year.id]))
def test_get_data_part2(self):
learning_container_luy = LearningContainerYearFactory(academic_year=self.current_academic_year)
luy = LearningUnitYearFactory(academic_year=self.current_academic_year,
learning_container_year=learning_container_luy,
periodicity=learning_unit_year_periodicity.ANNUAL,
status=True,
language=None,
)
component_lecturing = LearningComponentYearFactory(
learning_unit_year=luy,
type=learning_component_year_type.LECTURING,
hourly_volume_total_annual=15,
hourly_volume_partial_q1=10,
hourly_volume_partial_q2=5,
planned_classes=1
)
component_practical = LearningComponentYearFactory(
learning_unit_year=luy,
type=learning_component_year_type.PRACTICAL_EXERCISES,
hourly_volume_total_annual=15,
hourly_volume_partial_q1=10,
hourly_volume_partial_q2=5,
planned_classes=1
)
a_tutor = TutorFactory()
an_attribution = AttributionNewFactory(
tutor=a_tutor,
start_year=2017
)
attribution_charge_new_lecturing = AttributionChargeNewFactory(learning_component_year=component_lecturing,
attribution=an_attribution,
allocation_charge=15.0)
attribution_charge_new_practical = AttributionChargeNewFactory(learning_component_year=component_practical,
attribution=an_attribution,
allocation_charge=5.0)
# Simulate annotate
luy = annotate_qs(LearningUnitYear.objects.filter(pk=luy.pk)).first()
luy.entity_requirement = EntityVersionFactory()
luy.attribution_charge_news = attribution_charge_new.find_attribution_charge_new_by_learning_unit_year_as_dict(
luy)
expected_common = [
str(_(luy.periodicity.title())),
str(_('yes')) if luy.status else str(_('no')),
component_lecturing.hourly_volume_total_annual,
component_lecturing.hourly_volume_partial_q1,
component_lecturing.hourly_volume_partial_q2,
component_lecturing.planned_classes,
component_practical.hourly_volume_total_annual,
component_practical.hourly_volume_partial_q1,
component_practical.hourly_volume_partial_q2,
component_practical.planned_classes,
luy.get_quadrimester_display() or '',
luy.get_session_display() or '',
"",
]
self.assertEqual(_get_data_part2(luy, False), expected_common)
self.assertEqual(
_get_data_part2(luy, True),
expected_attribution_data(
attribution_charge_new_lecturing, attribution_charge_new_practical,
expected_common,
luy
)
)
def test_check_related_partims_deletion(self):
l_container_year = LearningContainerYearFactory()
LearningUnitYearFactory(
acronym="LBIR1212",
learning_container_year=l_container_year,
academic_year=self.academic_year, subtype=learning_unit_year_subtypes.FULL,
learning_unit=self.learning_unit)
msg = deletion._check_related_partims_deletion(l_container_year)
self.assertEqual(len(msg.values()), 0)
l_unit_2 = LearningUnitYearFactory(acronym="LBIR1213", learning_container_year=l_container_year,
academic_year=self.academic_year, subtype=learning_unit_year_subtypes.PARTIM)
LearningUnitEnrollmentFactory(learning_unit_year=l_unit_2)
LearningUnitEnrollmentFactory(learning_unit_year=l_unit_2)
LearningUnitEnrollmentFactory(learning_unit_year=l_unit_2)
group_1 = GroupElementYearFactory(child_branch=None, child_leaf=l_unit_2)
group_2 = GroupElementYearFactory(child_branch=None, child_leaf=l_unit_2)
component = LearningComponentYearFactory(learning_unit_year=l_unit_2)
attribution_1 = AttributionNewFactory(learning_container_year=l_unit_2.learning_container_year)
attribution_2 = AttributionNewFactory(learning_container_year=l_unit_2.learning_container_year)
AttributionChargeNewFactory(learning_component_year=component,
attribution=attribution_1)
AttributionChargeNewFactory(learning_component_year=component,
attribution=attribution_1)
AttributionChargeNewFactory(learning_component_year=component,
attribution=attribution_2)
msg = deletion._check_related_partims_deletion(l_container_year)
msg = list(msg.values())
self.assertEqual(len(msg), 5)
self.assertIn(_("There is %(count)d enrollments in %(subtype)s %(acronym)s for the year %(year)s")
% {'subtype': _('The partim'),
'acronym': l_unit_2.acronym,
'year': l_unit_2.academic_year,
'count': 3},
msg)
msg_delete_tutor = _("%(subtype)s %(acronym)s is assigned to %(tutor)s for the year %(year)s")
self.assertIn(msg_delete_tutor % {'subtype': _('The partim'),
'acronym': l_unit_2.acronym,
'year': l_unit_2.academic_year,
'tutor': attribution_1.tutor},
msg)
self.assertIn(msg_delete_tutor % {'subtype': _('The partim'),
'acronym': l_unit_2.acronym,
'year': l_unit_2.academic_year,
'tutor': attribution_2.tutor},
msg)
msg_delete_offer_type = _('%(subtype)s %(acronym)s is included in the group %(group)s for the year %(year)s')
self.assertIn(msg_delete_offer_type
% {'subtype': _('The partim'),
'acronym': l_unit_2.acronym,
'group': group_1.parent.partial_acronym,
'year': l_unit_2.academic_year},
msg)
self.assertIn(msg_delete_offer_type
% {'subtype': _('The partim'),
'acronym': l_unit_2.acronym,
'group': group_2.parent.partial_acronym,
'year': l_unit_2.academic_year},
msg)
def setUpTestData(cls):
cls.academic_year = AcademicYearFactory(year=2017)
cls.learning_container_luy1 = LearningContainerYearFactory(
academic_year=cls.academic_year)
cls.learning_unit_yr_1 = LearningUnitYearFactory(
academic_year=cls.academic_year,
learning_container_year=cls.learning_container_luy1,
credits=50)
cls.learning_unit_yr_2 = LearningUnitYearFactory()
cls.proposal_creation_1 = ProposalLearningUnitFactory(
state=proposal_state.ProposalState.ACCEPTED.name,
type=proposal_type.ProposalType.CREATION.name,
)
cls.proposal_creation_2 = ProposalLearningUnitFactory(
state=proposal_state.ProposalState.ACCEPTED.name,
type=proposal_type.ProposalType.CREATION.name,
)
direct_parent_type = EducationGroupTypeFactory(
name='Bachelor', category=education_group_categories.TRAINING)
cls.an_education_group_parent = EducationGroupYearFactory(
academic_year=cls.academic_year,
education_group_type=direct_parent_type,
acronym=ROOT_ACRONYM)
cls.group_element_child = GroupElementYearFactory(
parent=cls.an_education_group_parent,
child_branch=None,
child_leaf=cls.learning_unit_yr_1)
cls.an_education_group = EducationGroupYearFactory(
academic_year=cls.academic_year,
acronym=PARENT_ACRONYM,
title=PARENT_TITLE,
partial_acronym=PARENT_PARTIAL_ACRONYM)
cls.group_element_child2 = GroupElementYearFactory(
parent=cls.an_education_group,
child_branch=cls.group_element_child.parent,
)
cls.old_academic_year = AcademicYearFactory(
year=datetime.date.today().year - 2)
cls.current_academic_year = AcademicYearFactory(
year=datetime.date.today().year)
generatorContainer = GenerateContainer(cls.old_academic_year,
cls.current_academic_year)
cls.learning_unit_year_with_entities = generatorContainer.generated_container_years[
0].learning_unit_year_full
entities = [
EntityVersionFactory(
start_date=datetime.datetime(1900, 1, 1),
end_date=None,
entity_type=entity_type.FACULTY,
entity__organization__type=organization_type.MAIN)
for _ in range(4)
]
cls.learning_unit_year_with_entities.entity_requirement = entities[0]
cls.learning_unit_year_with_entities.entity_allocation = entities[1]
cls.proposal_creation_3 = ProposalLearningUnitFactory(
learning_unit_year=cls.learning_unit_year_with_entities,
state=proposal_state.ProposalState.ACCEPTED.name,
type=proposal_type.ProposalType.CREATION.name,
)
cls.learning_container_luy = LearningContainerYearFactory(
academic_year=cls.academic_year)
cls.luy_with_attribution = LearningUnitYearFactory(
academic_year=cls.academic_year,
learning_container_year=cls.learning_container_luy,
periodicity=learning_unit_year_periodicity.ANNUAL,
status=True,
language=None,
)
cls.luy_with_attribution.entity_requirement = entities[0]
cls.luy_with_attribution.entity_allocation = entities[1]
cls.component_lecturing = LearningComponentYearFactory(
learning_unit_year=cls.luy_with_attribution,
type=learning_component_year_type.LECTURING,
hourly_volume_total_annual=15,
hourly_volume_partial_q1=10,
hourly_volume_partial_q2=5,
planned_classes=1)
cls.component_practical = LearningComponentYearFactory(
learning_unit_year=cls.luy_with_attribution,
type=learning_component_year_type.PRACTICAL_EXERCISES,
hourly_volume_total_annual=15,
hourly_volume_partial_q1=10,
hourly_volume_partial_q2=5,
planned_classes=1)
a_person_tutor_1 = PersonFactory(last_name='Dupuis',
first_name='Tom',
email="*****@*****.**")
cls.a_tutor_1 = TutorFactory(person=a_person_tutor_1)
cls.an_attribution_1 = AttributionNewFactory(tutor=cls.a_tutor_1,
start_year=2017,
function=COORDINATOR)
cls.attribution_charge_new_lecturing_1 = AttributionChargeNewFactory(
learning_component_year=cls.component_lecturing,
attribution=cls.an_attribution_1,
allocation_charge=15.0)
cls.attribution_charge_new_practical_1 = AttributionChargeNewFactory(
learning_component_year=cls.component_practical,
attribution=cls.an_attribution_1,
allocation_charge=5.0)
cls.a_tutor_2 = TutorFactory(
person=PersonFactory(last_name='Maréchal', first_name='Didier'))
cls.an_attribution_2 = AttributionNewFactory(tutor=cls.a_tutor_2,
start_year=2017)
cls.attribution_charge_new_lecturing_2 = AttributionChargeNewFactory(
learning_component_year=cls.component_lecturing,
attribution=cls.an_attribution_2,
allocation_charge=15.0)
cls.attribution_charge_new_practical_2 = AttributionChargeNewFactory(
learning_component_year=cls.component_practical,
attribution=cls.an_attribution_2,
allocation_charge=5.0)
cls.entity_requirement = EntityVersion.objects.filter(entity=OuterRef(
'learning_container_year__requirement_entity'), ).current(
OuterRef('academic_year__start_date')).values('acronym')[:1]
cls.entity_allocation = EntityVersion.objects.filter(entity=OuterRef(
'learning_container_year__allocation_entity'), ).current(
OuterRef('academic_year__start_date')).values('acronym')[:1]