def test_get_partims_related(self):
        from base.views.learning_unit import _get_partims_related
        current_year = datetime.date.today().year
        academic_year = AcademicYearFactory(year=current_year)
        l_container_year = LearningContainerYearFactory(
            academic_year=academic_year)
        l_container_year_2 = LearningContainerYearFactory(
            academic_year=academic_year)
        # Create learning unit year attached to learning container year
        learning_unit_year_1 = LearningUnitYearFactory(
            academic_year=academic_year,
            learning_container_year=l_container_year,
            subtype=learning_unit_year_subtypes.FULL)
        LearningUnitYearFactory(academic_year=academic_year,
                                learning_container_year=l_container_year,
                                subtype=learning_unit_year_subtypes.PARTIM)
        LearningUnitYearFactory(academic_year=academic_year,
                                learning_container_year=l_container_year,
                                subtype=learning_unit_year_subtypes.PARTIM)
        learning_unit_year_2 = LearningUnitYearFactory(
            academic_year=academic_year,
            learning_container_year=l_container_year_2,
            subtype=learning_unit_year_subtypes.FULL)
        LearningUnitYearFactory(academic_year=academic_year,
                                learning_container_year=None)

        all_partims_container_year_1 = _get_partims_related(
            learning_unit_year_1)
        self.assertEqual(len(all_partims_container_year_1), 2)
        all_partims_container_year_2 = _get_partims_related(
            learning_unit_year_2)
        self.assertEqual(len(all_partims_container_year_2), 0)
    def setUp(self):
        self.academic_year = AcademicYearFactory(year=2017)
        external_id = tutor_application_osis.LEARNING_CONTAINER_YEAR_PREFIX_EXTERNAL_ID + '35654987_2017'
        self.lbir1200 = LearningContainerYearFactory(
            academic_year=self.academic_year,
            acronym="LBIR1200",
            external_id=external_id)
        self.lagro2630 = LearningContainerYearFactory(
            academic_year=self.academic_year, acronym="LAGRO2630")
        self.bio = LearningContainerYearFactory(
            academic_year=self.academic_year, acronym="BIO5213")

        # Creation Person/Tutor
        Group.objects.create(name="tutors")
        person = PersonFactory(global_id="98363454")
        external_id = tutor_application_osis.TUTOR_PREFIX_EXTERNAL_ID + '2089590559'
        self.tutor = TutorFactory(external_id=external_id, person=person)

        # Create two tutor applications
        applications = [
            _get_application_example(self.lbir1200, '30.5', '40.5'),
            _get_application_example(self.lagro2630, '12.5', '10.5'),
            _get_application_example(self.bio, '10.5', '9.5')
        ]
        self.attribution_new = AttributionNewFactory(
            global_id=person.global_id, applications=applications)
Exemple #3
0
    def test_find_entities_grouped_by_linktype(self):
        requirement_entity = EntityFactory()
        allocation_entity = EntityFactory()
        additional_requirement_entity_1 = EntityFactory()
        additional_requirement_entity_2 = EntityFactory()

        a_learning_container_year = LearningContainerYearFactory(
            requirement_entity=requirement_entity,
            allocation_entity=allocation_entity,
            additional_entity_1=additional_requirement_entity_1,
            additional_entity_2=additional_requirement_entity_2,
        )
        entities_by_linktype = a_learning_container_year.get_map_entity_by_type(
        )

        expected_result = {
            entity_container_year_link_type.REQUIREMENT_ENTITY:
            requirement_entity,
            entity_container_year_link_type.ALLOCATION_ENTITY:
            allocation_entity,
            entity_container_year_link_type.ADDITIONAL_REQUIREMENT_ENTITY_1:
            additional_requirement_entity_1,
            entity_container_year_link_type.ADDITIONAL_REQUIREMENT_ENTITY_2:
            additional_requirement_entity_2
        }

        self.assertDictEqual(entities_by_linktype, expected_result)
Exemple #4
0
    def setUp(self):
        today = date.today()
        self.academic_year = AcademicYearFactory(year=today.year, start_date=today)

        # Creation Container / UE and components related
        self.l_container = LearningContainerYearFactory(academic_year=self.academic_year, acronym="LBIR1210",
                                                        in_charge=True)
        _create_learning_unit_year_with_components(academic_year=self.academic_year, l_container=self.l_container,
                                                   acronym="LBIR1210",subtype=learning_unit_year_subtypes.FULL)
        _create_learning_unit_year_with_components(academic_year=self.academic_year, l_container=self.l_container,
                                                   acronym="LBIR1210A", subtype=learning_unit_year_subtypes.PARTIM)
        _create_learning_unit_year_with_components(academic_year=self.academic_year, l_container=self.l_container,
                                                   acronym="LBIR1210B", subtype=learning_unit_year_subtypes.PARTIM)

        # Creation Tutors
        self.tutor_1 = TutorFactory(person=PersonFactory(first_name="Tom", last_name="Dupont", global_id='00012345'))
        self.tutor_2 = TutorFactory(person=PersonFactory(first_name="Paul", last_name="Durant", global_id='08923545'))

        # Creation Attribution and Attributions Charges - Tutor 1 - Holder
        attribution_tutor_1 = AttributionNewFactory(learning_container_year=self.l_container, tutor=self.tutor_1,
                                                    function=function.HOLDER)
        _create_attribution_charge(self.academic_year, attribution_tutor_1, "LBIR1210", Decimal(15.5), Decimal(10))
        _create_attribution_charge(self.academic_year, attribution_tutor_1, "LBIR1210A", None, Decimal(5))

        # Creation Attribution and Attributions Charges - Tutor 2 - Co-holder
        attribution_tutor_2 = AttributionNewFactory(learning_container_year=self.l_container, tutor=self.tutor_2,
                                                    function=function.CO_HOLDER)
        _create_attribution_charge(self.academic_year, attribution_tutor_2, "LBIR1210B", Decimal(7.5))
Exemple #5
0
    def setUp(self):
        today = datetime.date.today()
        self.academic_yr = AcademicYearFactory(
            start_date=today,
            end_date=today.replace(year=today.year + 1),
            year=today.year)
        self.academic_yr_1 = AcademicYearFactory.build(
            start_date=today.replace(year=today.year + 1),
            end_date=today.replace(year=today.year + 2),
            year=today.year + 1)
        super(AcademicYear, self.academic_yr_1).save()
        self.academic_year_6 = AcademicYearFactory.build(
            start_date=today.replace(year=today.year + 6),
            end_date=today.replace(year=today.year + 7),
            year=today.year + 6)
        super(AcademicYear, self.academic_year_6).save()

        self.lunit_container_yr = LearningContainerYearFactory(
            academic_year=self.academic_yr)
        lu = LearningUnitFactory(end_year=self.academic_yr.year)
        self.luy = LearningUnitYearFactory(
            academic_year=self.academic_yr,
            learning_container_year=self.lunit_container_yr,
            subtype=FULL,
            learning_unit=lu)
Exemple #6
0
 def test_get_entity_by_type(self):
     learning_cont_yr = LearningContainerYearFactory(
         academic_year=self.academic_year,
         additional_entity_1=EntityFactory())
     result = learning_cont_yr.get_entity_from_type(
         entity_container_year_link_type.ADDITIONAL_REQUIREMENT_ENTITY_1)
     self.assertEqual(result, learning_cont_yr.additional_entity_1)
     result = learning_cont_yr.get_entity_from_type(
         entity_container_year_link_type.ADDITIONAL_REQUIREMENT_ENTITY_2)
     self.assertIsNone(result)
Exemple #7
0
    def test_property_in_charge(self):
        self.assertFalse(self.learning_unit_year.in_charge)

        a_container_year = LearningContainerYearFactory(acronym=self.learning_unit_year.acronym,
                                                        academic_year=self.academic_year)
        self.learning_unit_year.learning_container_year = a_container_year

        self.assertFalse(self.learning_unit_year.in_charge)

        a_container_year.in_charge = True

        self.assertTrue(self.learning_unit_year.in_charge)
Exemple #8
0
    def create_learning_unit_years_and_dependencies(self):
        acronym = "LDROI1004"
        l1 = LearningUnitFactory(
            start_year=settings.YEAR_LIMIT_LUE_MODIFICATION)

        learning_unit_years = []
        for year in range(4):
            ac_year = AcademicYearFactory(
                year=settings.YEAR_LIMIT_LUE_MODIFICATION + year)
            l_containeryear = LearningContainerYearFactory(
                academic_year=ac_year)
            EntityContainerYearFactory(
                learning_container_year=l_containeryear,
                entity=self.entity_version.entity,
                type=entity_container_year_link_type.REQUIREMENT_ENTITY)
            learning_unit_year = LearningUnitYearFactory(
                acronym=acronym,
                learning_unit=l1,
                academic_year=ac_year,
                learning_container_year=l_containeryear)
            learning_unit_years.append(learning_unit_year)

        learning_unit_years[1].subtype = learning_unit_year_subtypes.FULL
        learning_unit_years[1].save()
        lcomponent = LearningComponentYearFactory()
        LearningClassYearFactory(learning_component_year=lcomponent)
        LearningClassYearFactory(learning_component_year=lcomponent)
        return learning_unit_years
    def test_learning_unit_usage_two_usages(self):
        learning_container_yr = LearningContainerYearFactory(
            academic_year=self.current_academic_year, acronym='LBIOL')

        learning_unit_yr_1 = LearningUnitYearFactory(
            academic_year=self.current_academic_year,
            acronym='LBIOLA',
            quadrimester='Q1',
            learning_container_year=learning_container_yr)
        learning_unit_yr_2 = LearningUnitYearFactory(
            academic_year=self.current_academic_year,
            acronym='LBIOLB',
            learning_container_year=learning_container_yr)

        learning_component_yr = LearningComponentYearFactory(
            learning_container_year=learning_container_yr)

        LearningUnitComponentFactory(
            learning_unit_year=learning_unit_yr_1,
            learning_component_year=learning_component_yr)
        LearningUnitComponentFactory(
            learning_unit_year=learning_unit_yr_2,
            learning_component_year=learning_component_yr)

        self.assertEqual(
            learning_unit_business._learning_unit_usage(learning_component_yr),
            'LBIOLA (Q1), LBIOLB (?)')
Exemple #10
0
    def test_delete_partim_from_full(self):
        l_container_year = LearningContainerYearFactory(
            academic_year=self.academic_year)
        l_unit_year = LearningUnitYearFactory(
            subtype=learning_unit_year_subtypes.FULL,
            learning_container_year=l_container_year,
            learning_unit=LearningUnitFactory(start_year=1900),
            academic_year=l_container_year.academic_year)

        l_unit_partim_1 = LearningUnitYearFactory(
            subtype=learning_unit_year_subtypes.PARTIM,
            learning_container_year=l_container_year,
            learning_unit=LearningUnitFactory(start_year=1900),
            academic_year=l_container_year.academic_year)
        l_unit_partim_2 = LearningUnitYearFactory(
            subtype=learning_unit_year_subtypes.PARTIM,
            learning_container_year=l_container_year,
            learning_unit=LearningUnitFactory(start_year=1900),
            academic_year=l_container_year.academic_year)

        deletion.delete_from_given_learning_unit_year(l_unit_year)

        with self.assertRaises(ObjectDoesNotExist):
            LearningUnitYear.objects.get(id=l_unit_partim_1.id)

        with self.assertRaises(ObjectDoesNotExist):
            LearningUnitYear.objects.get(id=l_unit_partim_2.id)
Exemple #11
0
    def test_check_learning_unit_year_deletion(self):
        l_container_year = LearningContainerYearFactory(
            acronym="LBIR1212", academic_year=self.academic_year)
        l_unit_1 = LearningUnitYearFactory(
            acronym="LBIR1212",
            learning_container_year=l_container_year,
            academic_year=self.academic_year,
            subtype=learning_unit_year_subtypes.FULL)
        msg = deletion.check_learning_unit_year_deletion(l_unit_1)

        msg = list(msg.values())
        self.assertEqual(msg, [])

        l_unit_2 = LearningUnitYearFactory(
            acronym="LBIR1212A",
            learning_container_year=l_container_year,
            academic_year=self.academic_year,
            subtype=learning_unit_year_subtypes.PARTIM)
        LearningUnitYearFactory(acronym="LBIR1212B",
                                learning_container_year=l_container_year,
                                academic_year=self.academic_year,
                                subtype=learning_unit_year_subtypes.PARTIM)

        LearningUnitEnrollmentFactory(learning_unit_year=l_unit_1)
        LearningUnitEnrollmentFactory(learning_unit_year=l_unit_2)

        msg = deletion.check_learning_unit_year_deletion(l_unit_1)

        msg = list(msg.values())
        self.assertEqual(len(msg), 2)
Exemple #12
0
    def setUpTestData(cls):
        cls.person = PersonFactory()
        cls.user = cls.person.user
        cls.tutor = TutorFactory(person=cls.person)
        cls.current_ac_year = create_current_academic_year()
        ac_year_in_future = GenerateAcademicYear(
            start_year=cls.current_ac_year.year + 1,
            end_year=cls.current_ac_year.year + 5)
        cls.academic_calendar = AcademicCalendarFactory(
            academic_year=cls.current_ac_year,
            reference=academic_calendar_type.SUMMARY_COURSE_SUBMISSION)

        # Create multiple attribution in different academic years
        for ac_year in [cls.current_ac_year
                        ] + ac_year_in_future.academic_years:
            learning_container_year = LearningContainerYearFactory(
                academic_year=ac_year)
            learning_unit_year = LearningUnitYearFactory(
                summary_locked=False,
                academic_year=ac_year,
                learning_container_year=learning_container_year)
            AttributionFactory(
                tutor=cls.tutor,
                summary_responsible=True,
                learning_unit_year=learning_unit_year,
            )
        cls.url = reverse(list_my_attributions_summary_editable)
Exemple #13
0
    def setUpTestData(cls):
        cls.full_learning_unit_year = LearningUnitYearFactory(subtype=learning_unit_year_subtypes.FULL)
        cls.partim_learning_unit_year = LearningUnitYearFactory(
            subtype=learning_unit_year_subtypes.PARTIM,
            learning_container_year=cls.full_learning_unit_year.learning_container_year)

        cls.learning_container_year = LearningContainerYearFactory()
Exemple #14
0
    def create_learning_unit_years_and_dependencies(self):
        l1 = LearningUnitFactory()

        learning_unit_years = []
        for year in range(4):
            ac_year = AcademicYearFactory(year=2000 + year)
            l_containeryear = LearningContainerYearFactory(
                academic_year=ac_year)
            EntityContainerYearFactory(
                learning_container_year=l_containeryear,
                entity=self.entity_version.entity,
                type=entity_container_year_link_type.REQUIREMENT_ENTITY)
            learning_unit_year = LearningUnitYearFactory(
                learning_unit=l1,
                academic_year=ac_year,
                learning_container_year=l_containeryear)
            learning_unit_years.append(learning_unit_year)

        learning_unit_years[1].subtype = learning_unit_year_subtypes.FULL
        learning_unit_years[1].save()
        lcomponent = LearningComponentYearFactory()
        LearningClassYearFactory(learning_component_year=lcomponent)
        LearningClassYearFactory(learning_component_year=lcomponent)
        LearningUnitComponentFactory(learning_unit_year=learning_unit_years[1],
                                     learning_component_year=lcomponent)
        return learning_unit_years
Exemple #15
0
    def setUp(self):
        Group.objects.get_or_create(name='tutors')
        self.person = PersonFactory()
        self.tutor = TutorFactory(person=self.person)

        attribution_permission = Permission.objects.get(
            codename='can_access_attribution')
        self.person.user.user_permissions.add(attribution_permission)

        today = datetime.datetime.today()
        self.academic_year = AcademicYearFactory(
            year=today.year,
            start_date=today - datetime.timedelta(days=5),
            end_date=today + datetime.timedelta(days=5))
        self.learning_unit_year = LearningUnitYearFactory(
            academic_year=self.academic_year)
        self.learning_unit_year.learning_container_year = LearningContainerYearFactory(
            academic_year=self.learning_unit_year.academic_year,
            in_charge=True)
        self.learning_unit_year.save()
        self.attribution = AttributionFactory(
            function=function.CO_HOLDER,
            learning_unit_year=self.learning_unit_year,
            tutor=self.tutor,
            external_id=ATTRIBUTION_EXTERNAL_ID)

        self.url = reverse('attribution_home')
        self.client.force_login(self.person.user)
    def setUp(self):
        today = date.today()
        self.academic_year = AcademicYearFactory(year=today.year, start_date=today)

        # Creation Container / UE and components related
        self.l_container = LearningContainerYearFactory(academic_year=self.academic_year, acronym="LBIR1210",
                                                        in_charge=True)
        self.learning_unit_yr = _create_learning_unit_year_with_components(
            academic_year=self.academic_year,
            l_container=self.l_container,
            acronym="LBIR1210",
            subtype=learning_unit_year_subtypes.FULL
        )

        _create_learning_unit_year_with_components(academic_year=self.academic_year, l_container=self.l_container,
                                                   acronym="LBIR1210A", subtype=learning_unit_year_subtypes.PARTIM)
        _create_learning_unit_year_with_components(academic_year=self.academic_year, l_container=self.l_container,
                                                   acronym="LBIR1210B", subtype=learning_unit_year_subtypes.PARTIM)

        # Creation Tutors
        self.tutor_1 = TutorFactory(person=PersonFactory(first_name="Tom", last_name="Dupont", global_id='00012345'))
        self.tutor_2 = TutorFactory(person=PersonFactory(first_name="Paul", last_name="Durant", global_id='08923545'))

        # Creation Attribution and Attributions Charges - Tutor 1 - Holder
        attribution_tutor_1 = AttributionNewFactory(learning_container_year=self.l_container, tutor=self.tutor_1,
                                                    function=function.HOLDER)
        _create_attribution_charge(self.academic_year, attribution_tutor_1, "LBIR1210", Decimal(15.5), Decimal(10))
        _create_attribution_charge(self.academic_year, attribution_tutor_1, "LBIR1210A", None, Decimal(5))

        # Creation Attribution and Attributions Charges - Tutor 2 - Co-holder
        attribution_tutor_2 = AttributionNewFactory(learning_container_year=self.l_container, tutor=self.tutor_2,
                                                    function=function.CO_HOLDER)
        _create_attribution_charge(self.academic_year, attribution_tutor_2, "LBIR1210B", Decimal(7.5))
    def setUp(self):
        current_academic_year = create_current_academic_year()
        an_organization = OrganizationFactory(type=organization_type.MAIN)
        learning_container_year = LearningContainerYearFactory(
            academic_year=current_academic_year,
            container_type=learning_container_year_types.COURSE,
            requirement_entity=EntityFactory())
        self.learning_unit_year = LearningUnitYearFakerFactory(
            credits=5,
            subtype=learning_unit_year_subtypes.FULL,
            academic_year=current_academic_year,
            learning_container_year=learning_container_year,
            campus=CampusFactory(organization=an_organization,
                                 is_administration=True))

        today = datetime.date.today()

        an_entity = EntityFactory(organization=an_organization)
        self.entity_version = EntityVersionFactory(
            entity=an_entity,
            entity_type=entity_type.SCHOOL,
            start_date=today,
            end_date=today.replace(year=today.year + 1))
        self.learning_component_year_lecturing = LearningComponentYearFactory(
            type=learning_component_year_type.LECTURING,
            acronym="PM",
            learning_unit_year=self.learning_unit_year)
        self.learning_component_year_practical = LearningComponentYearFactory(
            type=learning_component_year_type.PRACTICAL_EXERCISES,
            acronym="PP",
            learning_unit_year=self.learning_unit_year)
Exemple #18
0
    def _setup_learning_container_year(self, learning_container):
        self.requirement_entity_container_year = self.entities[0]
        self.allocation_entity_container_year = self.entities[1]
        self.additionnal_1_entity_container_year = self.entities[2]
        self.addtionnal_2_entity_container_year = self.entities[3]

        self.list_repartition_volume_entities = [
            self.requirement_entity_container_year,
            self.additionnal_1_entity_container_year,
            self.addtionnal_2_entity_container_year
        ]

        self.learning_container_year = LearningContainerYearFactory(
            learning_container=learning_container,
            academic_year=self.academic_year,
            container_type=learning_container_year_types.COURSE,
            acronym="LDROI1200",
            common_title="Droit international",
            common_title_english="Droit international english",
            requirement_entity=self.requirement_entity_container_year,
            allocation_entity=self.allocation_entity_container_year,
            additional_entity_1=self.additionnal_1_entity_container_year,
            additional_entity_2=self.addtionnal_2_entity_container_year,
        )
        self.learning_container = self.learning_container_year.learning_container
Exemple #19
0
 def setUp(self):
     self.person = PersonFactory()
     self.tutor = TutorFactory(person=self.person)
     self.learning_container_year = LearningContainerYearFactory()
     self.attribution_new = AttributionNewFactory(learning_container_year=self.learning_container_year,
                                                  start_year=2018, end_year=2020, tutor=self.tutor,
                                                  score_responsible=True)
Exemple #20
0
 def test_find_entities_no_values(self):
     l_container_year = LearningContainerYearFactory(
         academic_year=self.academic_years[2015], requirement_entity=None)
     # No link between an entity/learning_container_year, so no result
     no_entity = base.models.learning_container_year.find_last_entity_version_grouped_by_linktypes(
         learning_container_year=l_container_year)
     self.assertFalse(no_entity)
Exemple #21
0
    def test_with_post_and_webservice_is_available(self, mock_fetch):
        today = datetime.datetime.today()
        an_academic_year = AcademicYearFactory(
            year=today.year,
            start_date=today - datetime.timedelta(days=5),
            end_date=today + datetime.timedelta(days=5))
        a_learning_container_year = LearningContainerYearFactory(
            academic_year=an_academic_year)
        a_learning_unit_year = LearningUnitYearFactory(
            academic_year=an_academic_year,
            learning_container_year=a_learning_container_year)
        AttributionFactory(learning_unit_year=a_learning_unit_year,
                           tutor=self.tutor)

        key = '{}{}'.format(LEARNING_UNIT_ACRONYM_ID,
                            a_learning_unit_year.acronym)
        response = self.client.post(self.url, data={key: ""})

        filename = "Liste_Insc_Exam.xls"
        self.assertEqual(response.status_code, OK)
        self.assertTrue(mock_fetch.called)
        self.assertEqual(
            response['Content-Type'],
            'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
        )
        self.assertEqual(response['Content-Disposition'],
                         'attachment; filename="{}"'.format(filename))
        self.assertEqual(response.content.decode(), str(return_sample_xls()))
Exemple #22
0
    def test_with_post_but_webservice_unavailable(self, mock_fetch):
        today = datetime.datetime.today()
        an_academic_year = AcademicYearFactory(
            year=today.year,
            start_date=today - datetime.timedelta(days=5),
            end_date=today + datetime.timedelta(days=5))
        learning_container_year = LearningContainerYearFactory(
            academic_year=an_academic_year)
        a_learning_unit_year = LearningUnitYearFactory(
            academic_year=an_academic_year,
            learning_container_year=learning_container_year)
        AttributionFactory(learning_unit_year=a_learning_unit_year,
                           tutor=self.tutor)

        key = '{}{}'.format(LEARNING_UNIT_ACRONYM_ID,
                            a_learning_unit_year.acronym)
        response = self.client.post(self.url, data={key: ""})

        self.assertTrue(mock_fetch.called)

        self.assertEqual(response.status_code, OK)
        self.assertTemplateUsed(response, 'list/students_exam.html')

        self.assertEqual(response.context['person'], self.tutor.person)
        self.assertEqual(response.context['my_learning_units'],
                         [a_learning_unit_year])
        self.assertEqual(response.context['msg_error'], _('No data found'))
Exemple #23
0
    def test_find_latest_requirment_entity(self):
        work_on_year = 2016

        # Change version in order to have multiple version during the year
        self.entity_versions[work_on_year].end_date = datetime.datetime(
            work_on_year, 3, 30)
        self.entity_versions[work_on_year].save()
        lastest_entity_version = EntityVersionFactory(
            entity=self.entity,
            parent=None,
            acronym="Entity V_{}_3".format(work_on_year),
            start_date=datetime.datetime(work_on_year, 8, 1),
            end_date=None)
        EntityVersionFactory(entity=self.entity,
                             parent=None,
                             acronym="Entity V_{}_2".format(work_on_year),
                             start_date=datetime.datetime(work_on_year, 4, 1),
                             end_date=datetime.datetime(work_on_year, 7, 30))

        l_container_year = LearningContainerYearFactory(
            academic_year=self.academic_years[work_on_year])
        # Create a link between entity and container
        # Requirement entity
        EntityContainerYearFactory(
            entity=self.entity,
            learning_container_year=l_container_year,
            type=entity_container_year_link_type.REQUIREMENT_ENTITY)

        # Find requirement entity
        requirement_entity_found = entity_container_year.find_requirement_entity(
            learning_container_year=l_container_year)
        self.assertEqual(lastest_entity_version, requirement_entity_found)
Exemple #24
0
    def test_cannot_delete_learning_unit_year_with_administrative_manager_role(self):
        manager = AdministrativeManagerFactory()
        entity_version = EntityVersionFactory(entity_type=entity_type.FACULTY, acronym="SST",
                                              start_date=datetime.date(year=1990, month=1, day=1),
                                              end_date=None)
        PersonEntityFactory(person=manager, entity=entity_version.entity, with_child=True)

        # Creation UE
        learning_unit = LearningUnitFactory()
        l_containeryear = LearningContainerYearFactory(academic_year=self.academic_year,
                                                       container_type=learning_container_year_types.COURSE,
                                                       requirement_entity=entity_version.entity)
        learning_unit_year = LearningUnitYearFactory(learning_unit=learning_unit,
                                                     academic_year=self.academic_year,
                                                     learning_container_year=l_containeryear,
                                                     subtype=learning_unit_year_subtypes.FULL)

        # Cannot remove FULL COURSE
        self.assertFalse(
            base.business.learning_units.perms.is_eligible_to_delete_learning_unit_year(
                learning_unit_year,
                manager
            )
        )

        # Can remove PARTIM COURSE
        learning_unit_year.subtype = learning_unit_year_subtypes.PARTIM
        learning_unit_year.save()
        self.assertFalse(
            base.business.learning_units.perms.is_eligible_to_delete_learning_unit_year(
                learning_unit_year,
                manager
            )
        )
Exemple #25
0
    def setUpTestData(cls):
        cls.academic_year = create_current_academic_year()
        cls.learning_unit = LearningUnitFactory(start_year__year=1900)

        cls.l_container_year = LearningContainerYearFactory(acronym="LBIR1212", academic_year=cls.academic_year)

        cls.user = UserFactory()
    def test_get_requirement_entities_volumes(self):
        academic_year = AcademicYearFactory(year=2016)
        learning_container_year = LearningContainerYearFactory(
            academic_year=academic_year)
        learning_component_year = LearningComponentYearFactory(
            learning_container_year=learning_container_year)
        entity_types_list = [
            entity_types.REQUIREMENT_ENTITY,
            entity_types.ADDITIONAL_REQUIREMENT_ENTITY_1,
            entity_types.ADDITIONAL_REQUIREMENT_ENTITY_2
        ]
        entity_containers_year = [
            EntityContainerYearFactory(
                type=entity_types_list[x],
                learning_container_year=learning_container_year)
            for x in range(3)
        ]
        components = [
            EntityComponentYearFactory(
                entity_container_year=entity_containers_year[x],
                learning_component_year=learning_component_year,
                hourly_volume_total=x + 5) for x in range(3)
        ]
        wanted_response = {
            "REQUIREMENT_ENTITY": 5,
            "ADDITIONAL_REQUIREMENT_ENTITY_1": 6,
            "ADDITIONAL_REQUIREMENT_ENTITY_2": 7,
        }

        self.assertDictEqual(
            learning_unit_year_with_context._get_requirement_entities_volumes(
                components), wanted_response)
Exemple #27
0
    def test_delete_cms_data(self):
        """In this test, we will ensure that CMS data linked to the learning unit year is correctly deleted"""
        learning_container_year = LearningContainerYearFactory(academic_year=self.academic_year)
        learning_unit_year_to_delete = LearningUnitYearFactory(learning_container_year=learning_container_year,
                                                               subtype=learning_unit_year_subtypes.FULL,
                                                               academic_year=learning_container_year.academic_year)
        # Create CMS data - TAB Specification
        cms_specification_label = TextLabelFactory(entity=entity_name.LEARNING_UNIT_YEAR,
                                                   label=CMS_LABEL_SPECIFICATIONS[0])
        TranslatedTextFactory(entity=entity_name.LEARNING_UNIT_YEAR, reference=learning_unit_year_to_delete.pk,
                              text_label=cms_specification_label, text='Specification of learning unit year')
        # Create CMS data - TAB Pedagogy
        cms_pedagogy_label = TextLabelFactory(entity=entity_name.LEARNING_UNIT_YEAR,
                                              label=CMS_LABEL_PEDAGOGY[0])
        TranslatedTextFactory(entity=entity_name.LEARNING_UNIT_YEAR, reference=learning_unit_year_to_delete.pk,
                              text_label=cms_pedagogy_label, text='Pedagogy of learning unit year')
        # Create CMS data - TAB Summary
        cms_summary_label = TextLabelFactory(entity=entity_name.LEARNING_UNIT_YEAR,
                                             label=CMS_LABEL_SUMMARY[0])
        TranslatedTextFactory(entity=entity_name.LEARNING_UNIT_YEAR, reference=learning_unit_year_to_delete.pk,
                              text_label=cms_summary_label, text='Summary of learning unit year')

        # Before delete, we should have 3 data in CMS
        self.assertEqual(3, TranslatedText.objects.all().count())

        deletion._delete_cms_data(learning_unit_year_to_delete)

        # After deletion, we should have no data in CMS
        self.assertFalse(TranslatedText.objects.all().count())
    def setUp(self):
        today = datetime.date.today()
        self.current_academic_year = AcademicYearFactory(
            start_date=today,
            end_date=today.replace(year=today.year + 1),
            year=today.year)
        self.learning_container_yr = LearningContainerYearFactory(
            academic_year=self.current_academic_year)
        self.organization = OrganizationFactory(type=organization_type.MAIN)
        self.country = CountryFactory()
        self.entity = EntityFactory(country=self.country,
                                    organization=self.organization)
        self.entity_container_yr = EntityContainerYearFactory(
            learning_container_year=self.learning_container_yr,
            type=entity_container_year_link_type.REQUIREMENT_ENTITY,
            entity=self.entity)
        self.learning_component_yr = LearningComponentYearFactory(
            learning_container_year=self.learning_container_yr,
            hourly_volume_partial=-1,
            planned_classes=1)
        self.entity_component_yr = EntityComponentYearFactory(
            learning_component_year=self.learning_component_yr,
            entity_container_year=self.entity_container_yr,
            hourly_volume_total=None)

        self.entity_components_yr = [
            self.entity_component_yr,
        ]
Exemple #29
0
    def setUp(self):
        self.academic_year = create_current_academic_year()
        self.next_academic_year = AcademicYearFactory(
            year=self.academic_year.year + 1)

        self.learning_container_year = LearningContainerYearFactory(
            academic_year=self.academic_year,
            common_title='common title',
        )
        self.learning_unit_year = _create_learning_unit_year_with_components(
            self.learning_container_year,
            create_lecturing_component=True,
            create_pratical_component=True)

        an_entity = EntityFactory()
        self.entity_version = EntityVersionFactory(entity=an_entity,
                                                   parent=None,
                                                   end_date=None,
                                                   acronym="DRT")
        self.allocation_entity = _create_entity_container_with_entity_components(
            self.learning_unit_year,
            entity_container_year_link_type.ALLOCATION_ENTITY, an_entity)
        self.requirement_entity = _create_entity_container_with_entity_components(
            self.learning_unit_year,
            entity_container_year_link_type.REQUIREMENT_ENTITY,
            an_entity,
            repartition_lecturing=30,
            repartition_practical_exercises=10)
        self.add_requirement_entity_1 = _create_entity_container_with_entity_components(
            self.learning_unit_year,
            entity_container_year_link_type.ADDITIONAL_REQUIREMENT_ENTITY_1,
            an_entity,
            repartition_lecturing=10,
            repartition_practical_exercises=5)
 def _create_list_containers(self, number_of_containers):
     list_lu_container_year = [
         LearningContainerYearFactory(acronym="LC%d" % container,
                                      academic_year=self.academic_yr)
         for container in range(number_of_containers)
     ]
     return list_lu_container_year
    def test_consistency_report_error_displayed(self):
        next_academic_year = AcademicYearFactory(
            year=self.learning_unit_year.academic_year.year + 1)
        next_learning_container_year = LearningContainerYearFactory(
            academic_year=next_academic_year,
            container_type=learning_container_year_types.COURSE)
        LearningUnitYearFactory(
            learning_container_year=next_learning_container_year,
            learning_unit=self.learning_unit_year.learning_unit,
            acronym="LOSIS4512",
            academic_year=next_academic_year,
            subtype=learning_unit_year_subtypes.FULL,
            credits=26)

        form_data = self._get_valid_form_data()
        response = self.client.post(self.url, data=form_data)

        expected_redirection = reverse("learning_unit",
                                       args=[self.learning_unit_year.id])
        self.assertRedirects(response,
                             expected_redirection,
                             fetch_redirect_response=False)

        messages = [
            str(message) for message in get_messages(response.wsgi_request)
        ]
        self.assertIn(
            _('The learning unit has been updated until %(year)s.') %
            {'year': self.learning_unit_year.academic_year}, list(messages))
class AttributionJsonTest(TestCase):
    def setUp(self):
        today = date.today()
        self.academic_year = AcademicYearFactory(year=today.year, start_date=today)

        # Creation Container / UE and components related
        self.l_container = LearningContainerYearFactory(academic_year=self.academic_year, acronym="LBIR1210",
                                                        in_charge=True)
        self.learning_unit_yr = _create_learning_unit_year_with_components(
            academic_year=self.academic_year,
            l_container=self.l_container,
            acronym="LBIR1210",
            subtype=learning_unit_year_subtypes.FULL
        )

        _create_learning_unit_year_with_components(academic_year=self.academic_year, l_container=self.l_container,
                                                   acronym="LBIR1210A", subtype=learning_unit_year_subtypes.PARTIM)
        _create_learning_unit_year_with_components(academic_year=self.academic_year, l_container=self.l_container,
                                                   acronym="LBIR1210B", subtype=learning_unit_year_subtypes.PARTIM)

        # Creation Tutors
        self.tutor_1 = TutorFactory(person=PersonFactory(first_name="Tom", last_name="Dupont", global_id='00012345'))
        self.tutor_2 = TutorFactory(person=PersonFactory(first_name="Paul", last_name="Durant", global_id='08923545'))

        # Creation Attribution and Attributions Charges - Tutor 1 - Holder
        attribution_tutor_1 = AttributionNewFactory(learning_container_year=self.l_container, tutor=self.tutor_1,
                                                    function=function.HOLDER)
        _create_attribution_charge(self.academic_year, attribution_tutor_1, "LBIR1210", Decimal(15.5), Decimal(10))
        _create_attribution_charge(self.academic_year, attribution_tutor_1, "LBIR1210A", None, Decimal(5))

        # Creation Attribution and Attributions Charges - Tutor 2 - Co-holder
        attribution_tutor_2 = AttributionNewFactory(learning_container_year=self.l_container, tutor=self.tutor_2,
                                                    function=function.CO_HOLDER)
        _create_attribution_charge(self.academic_year, attribution_tutor_2, "LBIR1210B", Decimal(7.5))

    def test_build_attributions_json(self):
        attrib_list = attribution_json._compute_list()
        self.assertIsInstance(attrib_list, list)
        self.assertEqual(len(attrib_list), 2)

        attrib_tutor_1 = next(
            (attrib for attrib in attrib_list if attrib['global_id'] == self.tutor_1.person.global_id),
            None)
        self.assertTrue(attrib_tutor_1)
        self.assertEqual(len(attrib_tutor_1['attributions']), 2)

        #Check if attribution is correct
        attrib_tutor_2 = next(
            (attrib for attrib in attrib_list if attrib['global_id'] == self.tutor_2.person.global_id),
            None)
        self.assertTrue(attrib_tutor_2)
        self.assertEqual(len(attrib_tutor_2['attributions']), 1)
        self.assertEqual(attrib_tutor_2['attributions'][0]['acronym'], "LBIR1210B")
        self.assertEqual(attrib_tutor_2['attributions'][0]['function'], function.CO_HOLDER)
        self.assertEqual(attrib_tutor_2['attributions'][0][learning_component_year_type.LECTURING], "7.5")
        self.assertRaises(KeyError, lambda: attrib_tutor_2['attributions'][0][learning_component_year_type.PRACTICAL_EXERCISES + '_CHARGE'])

    def test_learning_unit_in_charge_false(self):
        self.l_container.in_charge = False
        self.l_container.save()

        attrib_list = attribution_json._compute_list()
        self.assertIsInstance(attrib_list, list)
        self.assertEqual(len(attrib_list), 2)

        attrib_tutor_1 = next(
            (attrib for attrib in attrib_list if attrib['global_id'] == self.tutor_1.person.global_id),
            None)
        self.assertTrue(attrib_tutor_1)
        self.assertEqual(len(attrib_tutor_1['attributions']), 0)

    def test_two_attribution_function_to_same_learning_unit(self):
        new_attrib = AttributionNewFactory(learning_container_year=self.l_container, tutor=self.tutor_1,
                                           function=function.COORDINATOR)
        _create_attribution_charge(self.academic_year, new_attrib, "LBIR1210", Decimal(0), Decimal(0))
        attrib_list = attribution_json._compute_list()
        self.assertIsInstance(attrib_list, list)
        self.assertEqual(len(attrib_list), 2)

        attrib_tutor_1 = next(
                 (attrib for attrib in attrib_list if attrib['global_id'] == self.tutor_1.person.global_id),
                  None
        )
        self.assertEqual(len(attrib_tutor_1['attributions']), 3)

    def test_with_specific_global_id(self):
        global_id = self.tutor_2.person.global_id
        attrib_list = attribution_json._compute_list(global_ids=[global_id])
        self.assertIsInstance(attrib_list, list)
        self.assertEqual(len(attrib_list), 1)

        attrib_tutor_2 = next(
            (attrib for attrib in attrib_list if attrib['global_id'] == global_id),
            None
        )
        self.assertEqual(len(attrib_tutor_2['attributions']), 1)

    def test_with_multiple_global_id(self):
        global_id = self.tutor_2.person.global_id
        global_id_with_no_attributions = "4598989898"
        attrib_list = attribution_json._compute_list(global_ids=[global_id, global_id_with_no_attributions])
        self.assertIsInstance(attrib_list, list)
        self.assertEqual(len(attrib_list), 2)

        attribution_data = next(
            (attrib for attrib in attrib_list if attrib['global_id'] == global_id_with_no_attributions),
            None
        )
        self.assertFalse(attribution_data['attributions'])

    def test_get_title_next_luyr(self):
        self.assertIsNone(attribution_json._get_title_next_luyr(self.learning_unit_yr))

        next_academic_year = AcademicYearFactory(year=self.academic_year.year+1)
        self.assertIsNone(attribution_json._get_title_next_luyr(self.learning_unit_yr))

        next_luy = LearningUnitYearFactory(learning_unit=self.learning_unit_yr.learning_unit,
                                           academic_year=next_academic_year)
        self.assertEqual(attribution_json._get_title_next_luyr(self.learning_unit_yr), next_luy.complete_title)