Пример #1
0
    def setUp(self):

        self.mandate = AssistantMandateFactory(
            state=assistant_mandate_state.DONE)
        self.entity_version1 = EntityVersionFactory(
            entity_type=entity_type.INSTITUTE, end_date=None)
        self.mandate_entity1 = MandateEntityFactory(
            assistant_mandate=self.mandate, entity=self.entity_version1.entity)
        self.entity_version2 = EntityVersionFactory(
            entity_type=entity_type.FACULTY, end_date=None)
        self.mandate_entity2 = MandateEntityFactory(
            assistant_mandate=self.mandate, entity=self.entity_version2.entity)
        self.entity_version3 = EntityVersionFactory(
            entity_type=entity_type.SECTOR, end_date=None)
        self.mandate_entity3 = MandateEntityFactory(
            assistant_mandate=self.mandate, entity=self.entity_version3.entity)
        self.reviewer1 = reviewer.ReviewerFactory(
            role=reviewer_role.RESEARCH, entity=self.entity_version1.entity)
        self.review1 = review.ReviewFactory(reviewer=self.reviewer1,
                                            status=review_status.DONE,
                                            mandate=self.mandate)
        self.reviewer2 = reviewer.ReviewerFactory(
            role=reviewer_role.SUPERVISION, entity=self.entity_version2.entity)
        self.review2 = review.ReviewFactory(reviewer=self.reviewer2,
                                            status=review_status.DONE,
                                            mandate=self.mandate)
        self.reviewer3 = reviewer.ReviewerFactory(
            role=reviewer_role.VICE_RECTOR_ASSISTANT,
            entity=self.entity_version3.entity)
        self.review2 = review.ReviewFactory(reviewer=self.reviewer3,
                                            status=review_status.DONE,
                                            mandate=self.mandate)
        self.client = Client()
        self.client.force_login(self.reviewer1.person.user)
    def setUp(self):

        self.maxDiff = None
        self.assistant_mandate = AssistantMandateFactory()
        self.entity1 = EntityFactory()
        self.entity_version1 = EntityVersionFactory(
            entity=self.entity1, entity_type=entity_type.SECTOR)
        self.entity2 = EntityFactory()
        self.entity_version2 = EntityVersionFactory(
            entity=self.entity2, entity_type=entity_type.FACULTY)
        self.entity3 = EntityFactory()
        self.entity_version3 = EntityVersionFactory(
            entity=self.entity3, entity_type=entity_type.INSTITUTE)
        self.entity4 = EntityFactory()
        self.entity_version4 = EntityVersionFactory(
            entity=self.entity4,
            parent=self.entity3,
            entity_type=entity_type.SCHOOL)

        self.mandate_entity1 = MandateEntityFactory(
            assistant_mandate=self.assistant_mandate, entity=self.entity1)
        self.mandate_entity2 = MandateEntityFactory(
            assistant_mandate=self.assistant_mandate, entity=self.entity2)
        self.mandate_entity3 = MandateEntityFactory(
            assistant_mandate=self.assistant_mandate, entity=self.entity3)
    def setUpTestData(cls):
        cls.settings = SettingsFactory()

        cls.previous_academic_year, cls.current_academic_year, _ = AcademicYearFactory.produce(
        )
        cls.phd_supervisor = PersonFactory()
        cls.assistant = AcademicAssistantFactory(supervisor=cls.phd_supervisor)
        cls.assistant_mandate = AssistantMandateFactory(
            academic_year=cls.current_academic_year,
            assistant=cls.assistant,
            state=assistant_mandate_state.PHD_SUPERVISOR)
        cls.assistant2 = AcademicAssistantFactory(supervisor=None)
        cls.assistant_mandate2 = AssistantMandateFactory(
            academic_year=cls.current_academic_year,
            assistant=cls.assistant2,
            state=assistant_mandate_state.RESEARCH,
        )
        cls.review = ReviewFactory(reviewer=None,
                                   mandate=cls.assistant_mandate,
                                   status=review_status.IN_PROGRESS)
        cls.entity_version = EntityVersionFactory(
            entity_type=entity_type.INSTITUTE, end_date=None)
        cls.mandate_entity = MandateEntityFactory(
            assistant_mandate=cls.assistant_mandate,
            entity=cls.entity_version.entity)
        cls.mandate_entity2 = MandateEntityFactory(
            assistant_mandate=cls.assistant_mandate2,
            entity=cls.entity_version.entity)

        cls.reviewer = ReviewerFactory(role=reviewer_role.RESEARCH,
                                       entity=cls.entity_version.entity,
                                       person=cls.phd_supervisor)
Пример #4
0
    def setUp(self):

        self.factory = RequestFactory()
        self.client = Client()
        self.settings = SettingsFactory()
        today = datetime.date.today()
        self.current_academic_year = AcademicYearFactory(
            start_date=today,
            end_date=today.replace(year=today.year + 1),
            year=today.year)
        self.current_academic_year.save()
        self.phd_supervisor = PersonFactory()
        self.assistant = AcademicAssistantFactory(
            supervisor=self.phd_supervisor)

        self.assistant_mandate = AssistantMandateFactory(
            academic_year=self.current_academic_year,
            assistant=self.assistant,
            state=assistant_mandate_state.RESEARCH)
        self.assistant_mandate2 = AssistantMandateFactory(
            academic_year=self.current_academic_year,
            assistant=self.assistant,
            state=assistant_mandate_state.RESEARCH)
        self.phd_supervisor_review = ReviewFactory(
            reviewer=None,
            mandate=self.assistant_mandate,
            status=review_status.DONE)
        self.entity_version = EntityVersionFactory(
            entity_type=entity_type.INSTITUTE)
        self.entity_mandate = MandateEntityFactory(
            assistant_mandate=self.assistant_mandate,
            entity=self.entity_version.entity)
        self.entity_mandate2 = MandateEntityFactory(
            assistant_mandate=self.assistant_mandate2,
            entity=self.entity_version.entity)
        self.reviewer = ReviewerFactory(role=reviewer_role.RESEARCH,
                                        entity=self.entity_version.entity)
        self.review = ReviewFactory(reviewer=self.reviewer,
                                    mandate=self.assistant_mandate,
                                    status=review_status.IN_PROGRESS)
        self.entity_version2 = EntityVersionFactory(
            entity_type=entity_type.FACULTY)
        self.entity_mandate2 = MandateEntityFactory(
            assistant_mandate=self.assistant_mandate,
            entity=self.entity_version2.entity)
        self.reviewer2 = ReviewerFactory(role=reviewer_role.SUPERVISION,
                                         entity=self.entity_version2.entity)
        self.entity_version3 = EntityVersionFactory(
            entity_type=entity_type.SECTOR)
        self.entity_mandate3 = MandateEntityFactory(
            assistant_mandate=self.assistant_mandate,
            entity=self.entity_version3.entity)
        self.reviewer3 = ReviewerFactory(role=reviewer_role.VICE_RECTOR,
                                         entity=self.entity_version3.entity)
    def setUp(self):
        self.factory = RequestFactory()
        self.client = Client()
        self.manager = ManagerFactory()
        self.settings = SettingsFactory()
        self.client.force_login(self.manager.person.user)
        self.assistant = AcademicAssistantFactory()
        self.assistant_mandate = AssistantMandateFactory(
            state=assistant_mandate_state.TRTS,
            assistant=self.assistant,
            assistant_type=assistant_type.ASSISTANT)
        self.assistant2 = AcademicAssistantFactory()
        self.assistant_mandate2 = AssistantMandateFactory(
            state=assistant_mandate_state.SUPERVISION,
            assistant=self.assistant2,
            assistant_type=assistant_type.TEACHING_ASSISTANT)
        self.entity1 = EntityFactory()
        self.entity_version1 = EntityVersionFactory(
            entity=self.entity1, entity_type=entity_type.SECTOR)
        self.entity2 = EntityFactory()
        self.entity_version2 = EntityVersionFactory(
            entity=self.entity2, entity_type=entity_type.FACULTY)
        self.entity3 = EntityFactory()
        self.entity_version3 = EntityVersionFactory(
            entity=self.entity3, entity_type=entity_type.INSTITUTE)
        self.entity4 = EntityFactory()
        self.entity_version4 = EntityVersionFactory(
            entity=self.entity4,
            parent=self.entity2,
            entity_type=entity_type.SCHOOL)

        self.mandate_entity1 = MandateEntityFactory(
            assistant_mandate=self.assistant_mandate, entity=self.entity1)
        self.mandate_entity2 = MandateEntityFactory(
            assistant_mandate=self.assistant_mandate, entity=self.entity2)
        self.mandate_entity3 = MandateEntityFactory(
            assistant_mandate=self.assistant_mandate, entity=self.entity3)

        self.mandate_entity4 = MandateEntityFactory(
            assistant_mandate=self.assistant_mandate2, entity=self.entity1)
        self.mandate_entity5 = MandateEntityFactory(
            assistant_mandate=self.assistant_mandate2, entity=self.entity2)

        self.reviewer1 = ReviewerFactory(entity=self.entity3,
                                         role=reviewer_role.RESEARCH)
        self.reviewer2 = ReviewerFactory(entity=self.entity2,
                                         role=reviewer_role.SUPERVISION)
        self.reviewer3 = ReviewerFactory(entity=self.entity1,
                                         role=reviewer_role.VICE_RECTOR)
        self.reviewer4 = ReviewerFactory(entity=None,
                                         role=reviewer_role.PHD_SUPERVISOR)
Пример #6
0
 def setUpTestData(cls):
     cls.assistant_mandate = AssistantMandateFactory()
     cls.entity3 = EntityVersionFactory(
         entity_type=entity_type.SECTOR).entity
     cls.entity = EntityVersionFactory(entity_type=entity_type.FACULTY,
                                       parent=cls.entity3).entity
     cls.entity2 = EntityVersionFactory(entity_type=entity_type.SCHOOL,
                                        parent=cls.entity).entity
     cls.mandate_entity = MandateEntityFactory(
         assistant_mandate=cls.assistant_mandate, entity=cls.entity)
     cls.mandate_entity2 = MandateEntityFactory(
         assistant_mandate=cls.assistant_mandate, entity=cls.entity2)
     cls.mandate_entity3 = MandateEntityFactory(
         assistant_mandate=cls.assistant_mandate, entity=cls.entity3)
Пример #7
0
 def setUp(self):
     self.assistant_mandate = AssistantMandateFactory()
     self.entity3 = EntityVersionFactory(
         entity_type=entity_type.SECTOR).entity
     self.entity = EntityVersionFactory(entity_type=entity_type.FACULTY,
                                        parent=self.entity3).entity
     self.entity2 = EntityVersionFactory(entity_type=entity_type.SCHOOL,
                                         parent=self.entity).entity
     self.mandate_entity = MandateEntityFactory(
         assistant_mandate=self.assistant_mandate, entity=self.entity)
     self.mandate_entity2 = MandateEntityFactory(
         assistant_mandate=self.assistant_mandate, entity=self.entity2)
     self.mandate_entity3 = MandateEntityFactory(
         assistant_mandate=self.assistant_mandate, entity=self.entity3)
Пример #8
0
 def setUpTestData(cls):
     cls.mandate = AssistantMandateFactory(
         state=assistant_mandate_state.DONE)
     cls.entity_version1 = EntityVersionFactory(
         entity_type=entity_type.INSTITUTE, end_date=None)
     cls.mandate_entity1 = MandateEntityFactory(
         assistant_mandate=cls.mandate, entity=cls.entity_version1.entity)
     cls.entity_version2 = EntityVersionFactory(
         entity_type=entity_type.FACULTY, end_date=None)
     cls.mandate_entity2 = MandateEntityFactory(
         assistant_mandate=cls.mandate, entity=cls.entity_version2.entity)
     cls.entity_version3 = EntityVersionFactory(
         entity_type=entity_type.SECTOR, end_date=None)
     cls.mandate_entity3 = MandateEntityFactory(
         assistant_mandate=cls.mandate, entity=cls.entity_version3.entity)
    def setUpTestData(cls):
        cls.manager = ManagerFactory()
        cls.settings = SettingsFactory()
        cls.assistant = AcademicAssistantFactory()
        cls.assistant_mandate = AssistantMandateFactory(
            state=assistant_mandate_state.TRTS,
            assistant=cls.assistant,
            assistant_type=assistant_type.ASSISTANT)
        cls.assistant2 = AcademicAssistantFactory()
        cls.assistant_mandate2 = AssistantMandateFactory(
            state=assistant_mandate_state.SUPERVISION,
            assistant=cls.assistant2,
            assistant_type=assistant_type.TEACHING_ASSISTANT)
        cls.entity1 = EntityFactory()
        cls.entity_version1 = EntityVersionFactory(
            entity=cls.entity1, entity_type=entity_type.SECTOR)
        cls.entity2 = EntityFactory()
        cls.entity_version2 = EntityVersionFactory(
            entity=cls.entity2, entity_type=entity_type.FACULTY)
        cls.entity3 = EntityFactory()
        cls.entity_version3 = EntityVersionFactory(
            entity=cls.entity3, entity_type=entity_type.INSTITUTE)
        cls.entity4 = EntityFactory()
        cls.entity_version4 = EntityVersionFactory(
            entity=cls.entity4,
            parent=cls.entity2,
            entity_type=entity_type.SCHOOL)

        cls.mandate_entity1 = MandateEntityFactory(
            assistant_mandate=cls.assistant_mandate, entity=cls.entity1)
        cls.mandate_entity2 = MandateEntityFactory(
            assistant_mandate=cls.assistant_mandate, entity=cls.entity2)
        cls.mandate_entity3 = MandateEntityFactory(
            assistant_mandate=cls.assistant_mandate, entity=cls.entity3)

        cls.mandate_entity4 = MandateEntityFactory(
            assistant_mandate=cls.assistant_mandate2, entity=cls.entity1)
        cls.mandate_entity5 = MandateEntityFactory(
            assistant_mandate=cls.assistant_mandate2, entity=cls.entity2)

        cls.reviewer1 = ReviewerFactory(entity=cls.entity3,
                                        role=reviewer_role.RESEARCH)
        cls.reviewer2 = ReviewerFactory(entity=cls.entity2,
                                        role=reviewer_role.SUPERVISION)
        cls.reviewer3 = ReviewerFactory(entity=cls.entity1,
                                        role=reviewer_role.VICE_RECTOR)
        cls.reviewer4 = ReviewerFactory(entity=None,
                                        role=reviewer_role.PHD_SUPERVISOR)
    def setUpTestData(cls):
        cls.settings = SettingsFactory()
        today = datetime.date.today()
        cls.current_academic_year = AcademicYearFactory(start_date=today,
                                                        end_date=today.replace(year=today.year + 1),
                                                        year=today.year)
        cls.current_academic_year.save()
        cls.phd_supervisor = PersonFactory()
        cls.assistant = AcademicAssistantFactory(supervisor=cls.phd_supervisor)

        cls.assistant_mandate2 = AssistantMandateFactory(
            academic_year=cls.current_academic_year,
            assistant=cls.assistant,
            state=assistant_mandate_state.RESEARCH
        )
        cls.entity_version = EntityVersionFactory(entity_type=entity_type.INSTITUTE)
        cls.entity_version2 = EntityVersionFactory(entity_type=entity_type.FACULTY)
        cls.entity_version3 = EntityVersionFactory(entity_type=entity_type.SECTOR)
        cls.reviewer = ReviewerFactory(
            role=reviewer_role.RESEARCH,
            entity=cls.entity_version.entity
        )
        cls.reviewer2 = ReviewerFactory(
            role=reviewer_role.SUPERVISION,
            entity=cls.entity_version2.entity
        )
        cls.reviewer3 = ReviewerFactory(
            role=reviewer_role.VICE_RECTOR,
            entity=cls.entity_version3.entity
        )
        MandateEntityFactory(
            assistant_mandate=cls.assistant_mandate2,
            entity=cls.entity_version.entity
        )
Пример #11
0
 def setUp(self):
     self.maxDiff = None
     self.factory = RequestFactory()
     self.assistant = AcademicAssistantFactory(
         phd_inscription_date=datetime.date(2015, 10, 2),
         thesis_title='Data fitting on manifolds',
         confirmation_test_date=datetime.date(2017, 9, 25),
         remark=
         "Deux co-promoteurs (l'application ne m'autorise à n'en renseigner qu'un)"
     )
     self.mandate = AssistantMandateFactory(
         assistant=self.assistant,
         assistant_type=assistant_type.ASSISTANT,
         sap_id='1120019',
         entry_date=datetime.date(2012, 9, 15),
         end_date=datetime.date(2018, 9, 14),
         contract_duration='6 ans',
         contract_duration_fte='6 ans',
         fulltime_equivalent=1,
         other_status=None,
         renewal_type=assistant_mandate_renewal.NORMAL,
         justification=None,
         external_contract='',
         external_functions='',
     )
     self.entity_version = EntityVersionFactory()
     self.mandate_entity = MandateEntityFactory(
         assistant_mandate=self.mandate, entity=self.entity_version.entity)
     self.reviewer = ReviewerFactory(entity=self.mandate_entity.entity)
     self.styles = getSampleStyleSheet()
     self.review1 = ReviewFactory(mandate=self.mandate,
                                  reviewer=self.reviewer)
    def setUp(self):
        self.factory = RequestFactory()
        self.client = Client()
        self.settings = SettingsFactory()
        today = datetime.date.today()
        self.current_academic_year = AcademicYearFactory(
            start_date=today,
            end_date=today.replace(year=today.year + 1),
            year=today.year)
        self.phd_supervisor = PersonFactory()

        self.assistant = AcademicAssistantFactory(
            supervisor=self.phd_supervisor)
        self.assistant_mandate = AssistantMandateFactory(
            academic_year=self.current_academic_year, assistant=self.assistant)
        self.assistant_mandate.state = assistant_mandate_state.PHD_SUPERVISOR
        self.assistant_mandate.save()
        self.review = ReviewFactory(reviewer=None,
                                    mandate=self.assistant_mandate,
                                    status=review_status.IN_PROGRESS)
        self.entity_version = EntityVersionFactory(
            entity_type=entity_type.INSTITUTE)
        self.mandate_entity = MandateEntityFactory(
            assistant_mandate=self.assistant_mandate,
            entity=self.entity_version.entity)
    def setUpTestData(cls):
        cls.settings = SettingsFactory()

        cls.current_academic_year = AcademicYearFactory(current=True)
        cls.assistant_mandate = AssistantMandateFactory(
            academic_year=cls.current_academic_year,
            state=assistant_mandate_state.PHD_SUPERVISOR)
        cls.review = ReviewFactory(reviewer=None,
                                   mandate=cls.assistant_mandate,
                                   status=review_status.IN_PROGRESS)

        cls.institute = EntityVersionFactory(entity_type=entity_type.INSTITUTE,
                                             end_date=None)
        cls.institute_child = EntityVersionFactory(parent=cls.institute.entity,
                                                   end_date=None)
        cls.school = EntityVersionFactory(entity_type=entity_type.SCHOOL,
                                          end_date=None)
        cls.sector = EntityVersionFactory(entity_type=entity_type.SECTOR)
        cls.faculty = EntityVersionFactory(entity_type=entity_type.FACULTY)

        cls.mandate_entity = MandateEntityFactory(
            assistant_mandate=cls.assistant_mandate,
            entity=cls.institute.entity)
        cls.research_reviewer = ReviewerFactory(role=reviewer_role.RESEARCH,
                                                entity=cls.institute.entity)
        cls.research_assistant_reviewer = ReviewerFactory(
            role=reviewer_role.RESEARCH_ASSISTANT,
            entity=cls.institute_child.entity)
        cls.vice_sector_reviewer = ReviewerFactory(
            role=reviewer_role.VICE_RECTOR, entity=cls.school.entity)
        cls.supervision_reviewer = ReviewerFactory(
            role=reviewer_role.SUPERVISION, entity=cls.faculty.entity)

        cls.delegate = PersonFactory()
        cls.delegate2 = PersonFactory()
    def setUp(self):
        self.mandate = AssistantMandateFactory(
            assistant=self.assistant,
            assistant_type=assistant_type.ASSISTANT,
            sap_id='1120019',
            entry_date=datetime.date(self.current_academic_year.year - 6, 9,
                                     15),
            end_date=datetime.date(self.current_academic_year.year, 9, 24),
            contract_duration='6 ans',
            contract_duration_fte='6 ans',
            fulltime_equivalent=1,
            other_status=None,
            renewal_type=assistant_mandate_renewal.NORMAL,
            justification=None,
            external_contract='',
            external_functions='',
            state=assistant_mandate_state.TO_DO)

        self.mandate2 = AssistantMandateFactory(
            state=assistant_mandate_state.DECLINED,
            academic_year=self.current_academic_year)
        self.mandate3 = AssistantMandateFactory(
            state=assistant_mandate_state.DECLINED,
            academic_year=self.current_academic_year)
        self.tutoring_learning_unit_year = TutoringLearningUnitYearFactory(
            mandate=self.mandate)
        self.review3 = ReviewFactory(mandate=self.mandate, reviewer=None)
        self.entity_version = EntityVersionFactory()
        self.mandate_entity = MandateEntityFactory(
            assistant_mandate=self.mandate, entity=self.entity_version.entity)
        self.entity_version2 = EntityVersionFactory(
            entity_type=entity_type.FACULTY, end_date=None)
        self.mandate_entity2 = MandateEntityFactory(
            assistant_mandate=self.mandate, entity=self.entity_version2.entity)
        self.reviewer = ReviewerFactory(role=reviewer_role.SUPERVISION,
                                        entity=self.mandate_entity.entity)

        self.reviewer2 = ReviewerFactory(entity=self.mandate_entity2.entity)
        self.review1 = ReviewFactory(mandate=self.mandate,
                                     reviewer=self.reviewer)
        self.review2 = ReviewFactory(mandate=self.mandate,
                                     reviewer=self.reviewer2,
                                     status=review_status.IN_PROGRESS)
        self.review3 = ReviewFactory(mandate=self.mandate, reviewer=None)
 def setUp(self):
     self.assistant_mandate = AssistantMandateFactory(
         academic_year=self.current_academic_year,
         assistant=self.assistant,
         state=assistant_mandate_state.RESEARCH
     )
     self.phd_supervisor_review = ReviewFactory(
         reviewer=None,
         mandate=self.assistant_mandate,
         status=review_status.DONE
     )
     self.entity_mandate = MandateEntityFactory(assistant_mandate=self.assistant_mandate,
                                                entity=self.entity_version.entity)
     self.review = ReviewFactory(reviewer=self.reviewer, mandate=self.assistant_mandate,
                                 status=review_status.IN_PROGRESS)
     self.entity_mandate2 = MandateEntityFactory(
         assistant_mandate=self.assistant_mandate,
         entity=self.entity_version2.entity
     )
     self.entity_mandate3 = MandateEntityFactory(
         assistant_mandate=self.assistant_mandate,
         entity=self.entity_version3.entity
     )
    def setUpTestData(cls):
        cls.maxDiff = None
        cls.assistant_mandate = AssistantMandateFactory()
        cls.entity1 = EntityFactory()
        cls.entity_version1 = EntityVersionFactory(
            entity=cls.entity1, entity_type=entity_type.SECTOR)
        cls.entity2 = EntityFactory()
        cls.entity_version2 = EntityVersionFactory(
            entity=cls.entity2, entity_type=entity_type.FACULTY)
        cls.entity3 = EntityFactory()
        cls.entity_version3 = EntityVersionFactory(
            entity=cls.entity3, entity_type=entity_type.INSTITUTE)
        cls.entity4 = EntityFactory()
        cls.entity_version4 = EntityVersionFactory(
            entity=cls.entity4,
            parent=cls.entity3,
            entity_type=entity_type.SCHOOL)

        cls.mandate_entity1 = MandateEntityFactory(
            assistant_mandate=cls.assistant_mandate, entity=cls.entity1)
        cls.mandate_entity2 = MandateEntityFactory(
            assistant_mandate=cls.assistant_mandate, entity=cls.entity2)
        cls.mandate_entity3 = MandateEntityFactory(
            assistant_mandate=cls.assistant_mandate, entity=cls.entity3)
Пример #17
0
    def setUpTestData(cls):
        cls.settings = SettingsFactory()
        today = datetime.date.today()
        cls.current_academic_year = AcademicYearFactory(start_date=today,
                                                        end_date=today.replace(year=today.year + 1),
                                                        year=today.year)
        cls.phd_supervisor = PersonFactory()
        cls.assistant = AcademicAssistantFactory(supervisor=cls.phd_supervisor)
        cls.assistant_mandate = AssistantMandateFactory(academic_year=cls.current_academic_year,
                                                        assistant=cls.assistant)
        cls.assistant_mandate.state = assistant_mandate_state.PHD_SUPERVISOR
        cls.assistant_mandate.save()
        cls.review = ReviewFactory(reviewer=None, mandate=cls.assistant_mandate,
                                   status=review_status.IN_PROGRESS)
        cls.entity = EntityFactory()
        cls.entity_version = EntityVersionFactory(entity=cls.entity, entity_type=entity_type.INSTITUTE)
        cls.mandate_entity = MandateEntityFactory(assistant_mandate=cls.assistant_mandate, entity=cls.entity)

        cls.reviewer = ReviewerFactory(role=reviewer_role.RESEARCH,
                                       entity=cls.entity_version.entity)
    def setUp(self):
        self.client = Client()
        self.settings = SettingsFactory()
        self.manager = ManagerFactory()
        self.factory = RequestFactory()
        self.supervisor = PersonFactory()
        self.assistant = AcademicAssistantFactory(
            phd_inscription_date=datetime.date(2015, 10, 2),
            thesis_title='Data fitting on manifolds',
            confirmation_test_date=datetime.date(2017, 9, 25),
            remark=
            "Deux co-promoteurs (l'application ne m'autorise à n'en renseigner qu'un)",
            supervisor=self.supervisor)
        self.mandate = AssistantMandateFactory(
            assistant=self.assistant,
            assistant_type=assistant_type.ASSISTANT,
            sap_id='1120019',
            entry_date=datetime.date(2012, 9, 15),
            end_date=datetime.date(2018, 9, 14),
            contract_duration='6 ans',
            contract_duration_fte='6 ans',
            fulltime_equivalent=1,
            other_status=None,
            renewal_type=assistant_mandate_renewal.NORMAL,
            justification=None,
            external_contract='',
            external_functions='',
        )
        self.tutoring_learning_unit_year = TutoringLearningUnitYearFactory(
            mandate=self.mandate)
        self.review3 = ReviewFactory(mandate=self.mandate, reviewer=None)
        self.entity_version = EntityVersionFactory()
        self.mandate_entity = MandateEntityFactory(
            assistant_mandate=self.mandate, entity=self.entity_version.entity)
        self.entity_version2 = EntityVersionFactory(
            entity_type=entity_type.FACULTY, end_date=None)
        self.mandate_entity2 = MandateEntityFactory(
            assistant_mandate=self.mandate, entity=self.entity_version2.entity)
        self.reviewer = ReviewerFactory(role=reviewer_role.SUPERVISION,
                                        entity=self.mandate_entity.entity)

        self.reviewer2 = ReviewerFactory(entity=self.mandate_entity2.entity)
        self.styles = getSampleStyleSheet()
        self.styles.add(
            ParagraphStyle(
                name='Tiny',
                fontSize=6,
                font='Helvetica',
                leading=8,
                leftIndent=0,
                rightIndent=0,
                firstLineIndent=0,
                alignment=TA_LEFT,
                spaceBefore=0,
                spaceAfter=0,
                splitLongWords=1,
            ))
        self.review1 = ReviewFactory(mandate=self.mandate,
                                     reviewer=self.reviewer)
        self.review2 = ReviewFactory(mandate=self.mandate,
                                     reviewer=self.reviewer2,
                                     status=review_status.IN_PROGRESS)
        self.review3 = ReviewFactory(mandate=self.mandate, reviewer=None)
        self.reviewer3 = ReviewerFactory()