def setUpTestData(cls):
cls.academic_year = create_current_academic_year()
cls.academic_calendar = AcademicCalendarFactory(title="Submission of score encoding - 1",
academic_year__current=True,
reference=academic_calendar_type.SCORES_EXAM_SUBMISSION)
cls.session_exam_calendar = SessionExamCalendarFactory(academic_calendar=cls.academic_calendar,
number_session=number_session.ONE)
learning_unit_yr = LearningUnitYearFactory(learning_container_year__academic_year__current=True)
cls.session_exam = SessionExamFactory(number_session=number_session.ONE, learning_unit_year=learning_unit_yr)
def setUp(self):
group, created = Group.objects.get_or_create(name='entity_managers')
content_type = ContentType.objects.get_for_model(EntityManager)
perm, created = Permission.objects.get_or_create(codename='is_entity_manager', content_type=content_type)
group.permissions.add(perm)
self.person = PersonFactory()
self.user = self.person.user
self.tutor = TutorFactory(person=self.person)
self.current_academic_year = create_current_academic_year()
self.next_academic_year = AcademicYearFactory(
year=self.current_academic_year.year + 1
)
# Old structure model [To remove]
self.structure = structure.StructureFactory()
self.structure_children = structure.StructureFactory(part_of=self.structure)
# New structure model
entities_hierarchy = create_entities_hierarchy()
self.root_entity = entities_hierarchy.get('root_entity')
self.child_one_entity = entities_hierarchy.get('child_one_entity')
self.child_two_entity = entities_hierarchy.get('child_two_entity')
self.entity_manager = EntityManagerFactory(
person=self.person,
structure=self.structure,
entity=self.root_entity)
# Create two learning_unit_year with context (Container + EntityContainerYear)
self.learning_unit_year = create_learning_unit_with_context(
academic_year=self.next_academic_year,
structure=self.structure,
entity=self.child_one_entity,
acronym="LBIR1210"
)
self.learning_unit_year_children = create_learning_unit_with_context(
academic_year=self.next_academic_year,
structure=self.structure_children,
entity=self.child_two_entity,
acronym="LBIR1211"
)
self.attribution = test_attribution.create_attribution(
tutor=self.tutor,
learning_unit_year=self.learning_unit_year,
summary_responsible=True)
self.attribution_children = test_attribution.create_attribution(
tutor=self.tutor,
learning_unit_year=self.learning_unit_year_children,
summary_responsible=True)
def setUpTestData(cls):
# Create entity version and entity manager
cls.entity_version = EntityVersionFactory(entity_type=entity_type.SECTOR)
cls.entity_manager_person = PersonFactory()
EntityManagerFactory(entity=cls.entity_version.entity, person=cls.entity_manager_person)
cls.current_academic_year = create_current_academic_year()
# Create multiple attribution
for nb in range(0, 10):
attribution = AttributionFactory(
learning_unit_year__acronym='LBIR120{}'.format(nb),
learning_unit_year__academic_year=cls.current_academic_year,
learning_unit_year__learning_container_year__academic_year=cls.current_academic_year,
)
# Link course to entity
EntityContainerYearFactory(
learning_container_year=attribution.learning_unit_year.learning_container_year,
entity=cls.entity_version.entity,
type=entity_container_year_link_type.REQUIREMENT_ENTITY,
)
def setUpTestData(cls):
cls.academic_year = create_current_academic_year()
cls.luys_not_in_education_group = [
LearningUnitYearFactory(
academic_year=cls.academic_year,
learning_container_year__academic_year=cls.academic_year)
for _ in range(3)
]
cls.luys_with_same_entity_as_education_group = [
generate_learning_unit_year_with_associated_education_group(
cls.academic_year)
]
cls.luys_in_same_faculty_as_education_group = [
generate_learning_unit_year_with_associated_education_group(
cls.academic_year, same_entity=False) for _ in range(3)
]
cls.luys_in_different_faculty_than_education_group = [
generate_learning_unit_year_with_associated_education_group(
cls.academic_year, same_faculty=False) for _ in range(3)
]
def setUp(self):
self.user = UserFactory()
self.client.force_login(self.user)
self.person = PersonFactory(user=self.user)
self.user.user_permissions.add(Permission.objects.get(codename="can_access_education_group"))
self.academic_year = create_current_academic_year()
self.education_group_yr = EducationGroupYearFactory(
acronym='ARKE2A', academic_year=self.academic_year,
education_group_type=EducationGroupTypeFactory(category=education_group_categories.TRAINING),
management_entity=EntityFactory()
)
self.root_id = self.education_group_yr.id
self.country_be = CountryFactory()
self.organization_address = OrganizationAddressFactory(country=self.country_be)
self.organization = self.organization_address.organization
self.education_group_organization = EducationGroupOrganizationFactory(
organization=self.organization,
education_group_year=self.education_group_yr,
diploma=diploma_coorganization.UNIQUE,
all_students=True,
)
def setUpTestData(cls):
continuing_education_group_type = EducationGroupTypeFactory(
name=education_group_types.TrainingType.AGGREGATION.name, )
current_acad_year = create_current_academic_year()
cls.next_acad_year = AcademicYearFactory(year=current_acad_year.year +
1)
cls.previous_acad_year = AcademicYearFactory(
year=current_acad_year.year - 1)
cls.formation_AAAA = EducationGroupYearFactory(
acronym="AAAA",
partial_acronym="AAAA",
academic_year=current_acad_year,
education_group_type=continuing_education_group_type)
cls.formation_BBBB = EducationGroupYearFactory(
acronym="BBBB",
partial_acronym="BBBB",
academic_year=cls.next_acad_year,
education_group_type=continuing_education_group_type)
cls.formation_ABBB = EducationGroupYearFactory(
acronym="ABBB",
partial_acronym="ABBB",
academic_year=cls.next_acad_year,
education_group_type=continuing_education_group_type)
cls.current_academic_formation = EducationGroupYearFactory(
acronym="DDDD",
partial_acronym="DDDD",
academic_year=current_acad_year,
education_group_type=continuing_education_group_type)
cls.manager = ContinuingEducationManagerFactory()
cls.training_manager = ContinuingEducationTrainingManagerFactory()
cls.entity_version = EntityVersionFactory(
entity=cls.formation_AAAA.management_entity, )
cls.continuing_education_training = ContinuingEducationTrainingFactory(
education_group=cls.formation_AAAA.education_group)
def setUpTestData(cls):
# Create entity version and entity manager
cls.entity_version = EntityVersionFactory(
entity_type=entity_type.SECTOR)
cls.entity_manager_person = PersonFactory()
EntityManagerFactory(entity=cls.entity_version.entity,
person=cls.entity_manager_person)
cls.current_academic_year = create_current_academic_year()
# Create multiple attribution
for nb in range(0, 10):
attribution = AttributionFactory(
learning_unit_year__acronym='LBIR120{}'.format(nb),
learning_unit_year__academic_year=cls.current_academic_year,
learning_unit_year__learning_container_year__academic_year=cls.
current_academic_year,
)
# Link course to entity
EntityContainerYearFactory(
learning_container_year=attribution.learning_unit_year.
learning_container_year,
entity=cls.entity_version.entity,
type=entity_container_year_link_type.REQUIREMENT_ENTITY,
)
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,
)
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))
self.entity_container_year = EntityContainerYearFactory(
learning_container_year=self.learning_unit_year.
learning_container_year,
type=entity_container_year_link_type.REQUIREMENT_ENTITY)
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="TP",
learning_container_year=learning_container_year)
self.learning_component_year_practical = LearningComponentYearFactory(
type=learning_component_year_type.PRACTICAL_EXERCISES,
acronym="PP",
learning_container_year=learning_container_year)
def setUp(self):
academic_year = create_current_academic_year()
self.learning_unit = LearningUnitFactory(start_year=1900)
l_container_year = LearningContainerYearFactory(
acronym="LBIR1212", academic_year=academic_year)
self.l_unit_yr_1 = LearningUnitYearFactory(
acronym="LBIR1212",
learning_container_year=l_container_year,
academic_year=academic_year,
subtype=learning_unit_year_subtypes.FULL,
credits=10)
entity_requirement_ver = EntityVersionFactory(
acronym=ACRONYM_REQUIREMENT, entity=EntityFactory())
self.l_unit_yr_1.entity_requirement = entity_requirement_ver.acronym
entity_allocation_ver = EntityVersionFactory(
acronym=ACRONYM_ALLOCATION, entity=EntityFactory())
self.l_unit_yr_1.entity_allocation = entity_allocation_ver.acronym
entity_vr = EntityVersionFactory(acronym='ESPO')
self.proposal_1 = ProposalLearningUnitFactory(
learning_unit_year=self.l_unit_yr_1, entity=entity_vr.entity)
self.user = UserFactory()
self._set_entities()
def setUp(self):
self.initial_language = LanguageFactory(code='FR')
self.initial_campus = CampusFactory(
name='Louvain-la-Neuve', organization__type=organization_type.MAIN)
self.current_academic_year = create_current_academic_year()
self.person = PersonFactory()
self.post_data = get_valid_form_data(self.current_academic_year,
person=self.person)
# Creation of a LearningContainerYear and all related models
self.learn_unit_structure = GenerateContainer(
self.current_academic_year.year, self.current_academic_year.year)
self.learning_unit_year = LearningUnitYear.objects.get(
learning_unit=self.learn_unit_structure.learning_unit_full,
academic_year=self.current_academic_year)
self.acs = GenerateAcademicYear(
start_year=self.current_academic_year.year - 3,
end_year=self.current_academic_year.year + 7).academic_years
del self.acs[3]
for ac in self.acs:
LearningUnitYearFactory(
academic_year=ac,
learning_unit=self.learning_unit_year.learning_unit)
self.acs.insert(3, self.current_academic_year)
def setUp(self):
self.a_superuser = SuperUserFactory()
self.person = PersonFactory(user=self.a_superuser,
language=LANGUAGE_CODE_FR)
self.client.force_login(self.a_superuser)
academic_year = create_current_academic_year()
self.summary_course_submission_calendar = AcademicCalendarFactory(
academic_year=academic_year,
start_date=academic_year.start_date,
end_date=academic_year.end_date,
reference=academic_calendar_type.SUMMARY_COURSE_SUBMISSION)
self.tutor = TutorFactory(person=self.person)
# FIXME CHANGE LEARNINGUNITYEARFACTORY FOR AVOID MULTI ACADEMIC YEAR
self.learning_container_year = LearningContainerYearFactory(
academic_year=academic_year)
self.learning_unit_year = LearningUnitYearFakerFactory(
academic_year=academic_year,
learning_container_year=self.learning_container_year)
self.attribution = AttributionFactory(
learning_unit_year=self.learning_unit_year,
summary_responsible=True,
tutor=self.tutor)
def setUpTestData(cls):
cls.user = UserFactory()
cls.citizenship = CountryFactory(iso_code='FR')
CountryFactory(iso_code='NL')
cls.person = ContinuingEducationPersonFactory(
birth_country=cls.citizenship)
cls.address = AddressFactory()
cls.academic_year = create_current_academic_year()
cls.url = reverse('continuing_education_api_v1:admission-list',
kwargs={'uuid': cls.person.uuid})
for state in [SUBMITTED, ACCEPTED, REJECTED, DRAFT]:
education_group = EducationGroupFactory()
EducationGroupYearFactory(education_group=education_group,
academic_year=cls.academic_year)
cls.formation = ContinuingEducationTrainingFactory(
education_group=education_group)
cls.admission = AdmissionFactory(citizenship=cls.citizenship,
person_information=cls.person,
address=cls.address,
state=state,
formation=cls.formation)
def setUp(self):
self.language_fr = LanguageFactory(code="FR")
self.user = UserFactory()
self.person = PersonFactory(user=self.user)
self.person_entity = PersonEntityFactory(person=self.person)
self.academic_year = create_current_academic_year()
self.learning_unit_year = LearningUnitYearFactory(
academic_year=self.academic_year,
subtype=learning_unit_year_subtypes.FULL,
learning_container_year__requirement_entity=self.person_entity.
entity,
)
self.client.force_login(self.user)
self.achievement_fr = LearningAchievementFactory(
language=self.language_fr,
learning_unit_year=self.learning_unit_year,
order=0)
self.reverse_learning_unit_yr = reverse(
'learning_unit', args=[self.learning_unit_year.id])
flag, created = Flag.objects.get_or_create(
name='learning_achievement_update')
flag.users.add(self.user)
def setUpTestData(cls):
cls.academic_year = create_current_academic_year()
cls.education_group = EducationGroupFactory()
education_group_year = EducationGroupYearFactory(
education_group=cls.education_group,
academic_year=cls.academic_year
)
cls.formation = ContinuingEducationTrainingFactory(
education_group=cls.education_group
)
cls.manager = ContinuingEducationManagerFactory()
EntityVersionFactory(
entity=education_group_year.management_entity
)
cls.admission = AdmissionFactory(
academic_year=cls.academic_year,
formation=cls.formation,
state=random.choice(admission_state_choices.STATE_CHOICES)[0]
)
cls.admission_submitted = AdmissionFactory(
academic_year=cls.academic_year,
formation=cls.formation,
state=SUBMITTED
)
def setUpTestData(cls):
cls.academic_year = create_current_academic_year()
cls.education_group = EducationGroupFactory()
EducationGroupYearFactory(
education_group=cls.education_group,
academic_year=cls.academic_year
)
cls.formation = ContinuingEducationTrainingFactory(education_group=cls.education_group)
cls.faculty_manager = ContinuingEducationTrainingManagerFactory(training=cls.formation)
cls.continuing_education_manager = ContinuingEducationManagerFactory()
EntityVersionFactory(
entity=cls.formation.management_entity
)
cls.registration_submitted = AdmissionFactory(
formation=cls.formation,
state=REGISTRATION_SUBMITTED,
academic_year=cls.academic_year
)
cls.registration_validated = AdmissionFactory(
formation=cls.formation,
state=VALIDATED,
academic_year=cls.academic_year
)
cls.student_worker = ContinuingEducationStudentWorkerFactory()
def setUp(self):
self.current_academic_year = create_current_academic_year()
self.next_academic_year = AcademicYearFactory(year=self.current_academic_year.year + 1)
self.person = CentralManagerFactory()
self.person.user.user_permissions.add(Permission.objects.get(codename="change_educationgroup"))
self.person.user.user_permissions.add(Permission.objects.get(codename="can_access_education_group"))
self.client.force_login(self.person.user)
self.education_group = EducationGroupFactory(end_year=self.next_academic_year.year)
self.education_group_year = TrainingFactory(academic_year=self.current_academic_year,
education_group=self.education_group)
self.next_education_group_year = TrainingFactory(
academic_year=self.next_academic_year,
education_group=self.education_group,
management_entity=self.education_group_year.management_entity
)
PersonEntityFactory(person=self.person, entity=self.education_group_year.management_entity)
self.group_element_year = GroupElementYearFactory(
parent=self.education_group_year,
child_branch__academic_year=self.education_group_year.academic_year
)
self.url = reverse(
"postpone_education_group",
kwargs={
"root_id": self.next_education_group_year.pk,
"education_group_year_id": self.next_education_group_year.pk,
}
)
self.redirect_url = reverse("education_group_read",
args=[self.next_education_group_year.pk, self.next_education_group_year.pk])
def setUp(self):
self.academic_year = create_current_academic_year()
self.learning_unit = LearningUnitFactory(start_year=1900)
l_container_year = LearningContainerYearFactory(
acronym="LBIR1212", academic_year=self.academic_year)
self.l_unit_yr_1 = LearningUnitYearFactory(
acronym="LBIR1212",
learning_container_year=l_container_year,
academic_year=self.academic_year,
subtype=learning_unit_year_subtypes.FULL)
self.l_unit_yr_1.entities = {
entity_container_year_link_type.REQUIREMENT_ENTITY:
EntityVersionFactory(acronym=ACRONYM_REQUIREMENT,
entity=EntityFactory()),
entity_container_year_link_type.ALLOCATION_ENTITY:
EntityVersionFactory(acronym=ACRONYM_ALLOCATION,
entity=EntityFactory())
}
entity_vr = EntityVersionFactory(acronym='ESPO')
self.proposal_1 = ProposalLearningUnitFactory(
learning_unit_year=self.l_unit_yr_1, entity=entity_vr.entity)
self.user = UserFactory()
def setUp(self):
# Create several academic year
self.current_academic_year = create_current_academic_year()
self.generated_ac_years = GenerateAcademicYear(
self.current_academic_year.year + 1,
self.current_academic_year.year + 10)
# Create small entities
self.entity = EntityFactory(organization__type=organization_type.MAIN)
self.entity_version = EntityVersionFactory(
entity=self.entity, entity_type=entity_type.SECTOR)
self.education_group_year = EducationGroupYearFactory(
management_entity=self.entity,
administration_entity=self.entity,
academic_year=self.current_academic_year)
# Create a group language
EducationGroupLanguageFactory(
education_group_year=self.education_group_year)
# Create two secondary domains
EducationGroupYearDomainFactory(
education_group_year=self.education_group_year)
EducationGroupYearDomainFactory(
education_group_year=self.education_group_year)
def setUp(self):
self.academic_year = create_current_academic_year()
self.learning_unit_year = LearningUnitYearFactory(
academic_year=self.academic_year,
subtype=learning_unit_year_subtypes.FULL)
self.language_fr = LanguageFactory(code="FR")
self.user = UserFactory()
self.person = PersonFactory(user=self.user)
self.person_entity = PersonEntityFactory(person=self.person)
EntityContainerYearFactory(
learning_container_year=self.learning_unit_year.
learning_container_year,
entity=self.person_entity.entity,
type=entity_container_year_link_type.REQUIREMENT_ENTITY)
self.client.force_login(self.user)
self.achievement_fr = LearningAchievementFactory(
language=self.language_fr,
learning_unit_year=self.learning_unit_year,
order=0)
self.reverse_learning_unit_yr = reverse(
'learning_unit', args=[self.learning_unit_year.id])
def setUp(self):
self.person = PersonFactory()
self.academic_year = create_current_academic_year()
self.language = LanguageFactory(code='FR')
def setUp(self):
self.academic_year = create_current_academic_year()
self.learning_unit = LearningUnitFactory(start_year=1900)
def setUpTestData(cls):
today = datetime.date.today()
an_academic_year = create_current_academic_year()
learning_container_year = LearningContainerYearFactory(
academic_year=an_academic_year,
container_type=learning_container_year_types.COURSE,
type_declaration_vacant=vacant_declaration_type.DO_NOT_ASSIGN,
)
cls.learning_unit_year = LearningUnitYearFactory(
learning_container_year=learning_container_year,
acronym="LOSIS4512",
academic_year=an_academic_year,
subtype=learning_unit_year_subtypes.FULL,
attribution_procedure=attribution_procedure.INTERNAL_TEAM,
credits=15,
campus=CampusFactory(organization=OrganizationFactory(
type=organization_type.MAIN)),
internship_subtype=None,
)
cls.partim_learning_unit = LearningUnitYearFactory(
learning_container_year=learning_container_year,
acronym="LOSIS4512A",
academic_year=an_academic_year,
subtype=learning_unit_year_subtypes.PARTIM,
credits=10,
campus=CampusFactory(organization=OrganizationFactory(
type=organization_type.MAIN)))
cls.requirement_entity_container = EntityContainerYearFactory(
learning_container_year=learning_container_year,
type=entity_container_year_link_type.REQUIREMENT_ENTITY)
cls.requirement_entity_container.entity.organization.type = organization_type.MAIN
cls.requirement_entity_container.entity.organization.save()
cls.requirement_entity = EntityVersionFactory(
entity=cls.requirement_entity_container.entity,
entity_type=entity_type.SCHOOL,
start_date=today.replace(year=1900),
end_date=None)
cls.allocation_entity_container = EntityContainerYearFactory(
learning_container_year=learning_container_year,
type=entity_container_year_link_type.ALLOCATION_ENTITY)
cls.allocation_entity = EntityVersionFactory(
entity=cls.allocation_entity_container.entity,
start_date=today.replace(year=1900),
end_date=None)
cls.additional_entity_container_1 = EntityContainerYearFactory(
learning_container_year=learning_container_year,
type=entity_container_year_link_type.
ADDITIONAL_REQUIREMENT_ENTITY_1)
cls.additional_entity_1 = EntityVersionFactory(
entity=cls.additional_entity_container_1.entity,
start_date=today.replace(year=1900),
end_date=None)
cls.additional_entity_container_2 = EntityContainerYearFactory(
learning_container_year=learning_container_year,
type=entity_container_year_link_type.
ADDITIONAL_REQUIREMENT_ENTITY_2)
cls.additional_entity_2 = EntityVersionFactory(
entity=cls.additional_entity_container_2.entity,
start_date=today.replace(year=1900),
end_date=None)
cls.person = PersonEntityFactory(
entity=cls.requirement_entity_container.entity).person
cls.user = cls.person.user
cls.user.user_permissions.add(
Permission.objects.get(codename="can_edit_learningunit"),
Permission.objects.get(codename="can_access_learningunit"))
cls.url = reverse(update_learning_unit,
args=[cls.learning_unit_year.id])
def setUp(self):
self.language_fr = LanguageFactory(code="FR")
self.language_en = LanguageFactory(code="EN")
self.learning_unit_year = LearningUnitYearFactory(
academic_year=create_current_academic_year())
def setUp(self):
self.admission = AdmissionFactory()
EducationGroupYearFactory(
education_group=self.admission.formation.education_group,
academic_year=create_current_academic_year()
)
def setUpTestData(cls):
cls.admission = AdmissionFactory()
EducationGroupYearFactory(
education_group=cls.admission.formation.education_group,
academic_year=create_current_academic_year()
)
def setUpTestData(cls):
cls.current_academic_year = create_current_academic_year()
def setUp(self):
self.central_manager = PersonFactory()
self.central_manager.user.groups.add(
Group.objects.get(name=CENTRAL_MANAGER_GROUP))
self.faculty_manager = PersonFactory()
self.faculty_manager.user.groups.add(
Group.objects.get(name=FACULTY_MANAGER_GROUP))
self.current_academic_year = create_current_academic_year()
self.learning_container = LearningContainerFactory()
self.learning_unit = LearningUnitFactory(
learning_container=self.learning_container)
self.learning_container_year = LearningContainerYearFactory(
learning_container=self.learning_container,
academic_year=self.current_academic_year,
container_type=learning_container_year_types.COURSE)
self.form = LearningUnitYearModelForm(data=None,
person=self.central_manager,
subtype=FULL)
campus = CampusFactory(organization=OrganizationFactory(
type=organization_type.MAIN))
self.language = LanguageFactory(code='FR')
self.post_data = {
'acronym_0': 'L',
'acronym_1': 'OSIS9001',
'academic_year': self.current_academic_year.pk,
'specific_title': 'The hobbit',
'specific_title_english': 'An Unexpected Journey',
'credits': 3,
'session': '3',
'status': True,
'quadrimester': 'Q1',
'internship_subtype': PROFESSIONAL_INTERNSHIP,
'attribution_procedure': INTERNAL_TEAM,
'campus': campus.pk,
'language': self.language.pk,
'periodicity': ANNUAL,
# Learning component year data model form
'form-TOTAL_FORMS': '2',
'form-INITIAL_FORMS': '0',
'form-MAX_NUM_FORMS': '2',
'form-0-hourly_volume_total_annual': 20,
'form-0-hourly_volume_partial_q1': 10,
'form-0-hourly_volume_partial_q2': 10,
'form-1-hourly_volume_total_annual': 20,
'form-1-hourly_volume_partial_q1': 10,
'form-1-hourly_volume_partial_q2': 10,
}
self.requirement_entity = EntityContainerYearFactory(
type=REQUIREMENT_ENTITY,
learning_container_year=self.learning_container_year)
self.allocation_entity = EntityContainerYearFactory(
type=ALLOCATION_ENTITY,
learning_container_year=self.learning_container_year)
self.additional_requirement_entity_1 = EntityContainerYearFactory(
type=ADDITIONAL_REQUIREMENT_ENTITY_1,
learning_container_year=self.learning_container_year)
self.additional_requirement_entity_2 = EntityContainerYearFactory(
type=ADDITIONAL_REQUIREMENT_ENTITY_2,
learning_container_year=self.learning_container_year)
EntityVersionFactory(
entity=self.additional_requirement_entity_1.entity,
start_date=self.learning_container_year.academic_year.start_date,
end_date=self.learning_container_year.academic_year.end_date)
EntityVersionFactory(
entity=self.additional_requirement_entity_2.entity,
start_date=self.learning_container_year.academic_year.start_date,
end_date=self.learning_container_year.academic_year.end_date)
self.allocation_entity_version = EntityVersionFactory(
entity=self.allocation_entity.entity,
start_date=self.learning_container_year.academic_year.start_date,
end_date=self.learning_container_year.academic_year.end_date)
self.requirement_entity_version = EntityVersionFactory(
entity=self.requirement_entity.entity,
start_date=self.learning_container_year.academic_year.start_date,
end_date=self.learning_container_year.academic_year.end_date)
self.entity_container_years = [
self.requirement_entity, self.allocation_entity,
self.additional_requirement_entity_1,
self.additional_requirement_entity_2
]
def setUp(self):
self.current_academic_year = create_current_academic_year()
def setUpTestData(cls):
cls.current_academic_calendar = AcademicCalendarFactory(academic_year=create_current_academic_year(),
reference=academic_calendar_type.EXAM_ENROLLMENTS)
def setUpTestData(cls):
cls.academic_year = create_current_academic_year()
cls.training = TrainingFactory(
education_group_type__name=TrainingType.PGRM_MASTER_120.name)
def setUpTestData(cls):
cls.current_academic_year = create_current_academic_year()
cls.previous_academic_year = AcademicYearFactory(
year=cls.current_academic_year.year - 1)
cls.next_academic_year = AcademicYearFactory(
year=cls.current_academic_year.year + 1)
def setUpTestData(cls):
create_current_academic_year()
cls.central_manager = CentralManagerFactory()
cls.faculty_manager = FacultyManagerFactory()
def setUpTestData(cls):
cls.maxDiff = None
cls.manager = AdviserManagerFactory()
a_person_teacher = PersonFactory.create(
first_name='Pierre',
last_name='Dupont',
email='*****@*****.**')
cls.teacher = AdviserTeacherFactory(person=a_person_teacher)
a_person_teacher2 = PersonFactory.create(
first_name='Marco',
last_name='Millet',
email='*****@*****.**')
cls.teacher2 = AdviserTeacherFactory(person=a_person_teacher2)
a_person_student = PersonWithoutUserFactory.create(
last_name="Durant", email='*****@*****.**')
cls.student = StudentFactory.create(person=a_person_student)
cls.education_group = EducationGroupFactory()
cls.education_group3 = EducationGroupFactory()
cls.academic_year1 = create_current_academic_year()
cls.academic_year2 = AcademicYearFactory(year=cls.academic_year1.year -
1)
cls.education_group_year = EducationGroupYearFactory(
academic_year=cls.academic_year1,
education_group=cls.education_group,
acronym="test_offer1")
cls.faculty_manager = FacultyAdviserFactory(
adviser=cls.manager, education_group=cls.education_group)
cls.offer_proposition1 = OfferPropositionFactory(
global_email_to_commission=True,
evaluation_first_year=True,
education_group=cls.education_group_year.education_group)
cls.offer_proposition2 = OfferPropositionFactory(
education_group=cls.education_group3,
global_email_to_commission=False)
cls.education_group_year2 = EducationGroupYearFactory(
acronym="test_offer2",
education_group=cls.offer_proposition2.education_group,
academic_year=cls.academic_year1)
cls.proposition_dissertation = PropositionDissertationFactory(
author=cls.teacher,
creator=a_person_teacher,
title='Proposition 1212121')
cls.dissertation_test_email = DissertationFactory(
author=cls.student,
title='Dissertation_test_email',
proposition_dissertation=cls.proposition_dissertation,
status='DRAFT',
active=True,
dissertation_role__adviser=cls.teacher,
dissertation_role__status='PROMOTEUR',
education_group_year=cls.education_group_year,
)
FacultyAdviserFactory(
adviser=cls.manager,
education_group=cls.education_group_year.education_group)
cls.manager2 = AdviserManagerFactory()
FacultyAdviserFactory(
adviser=cls.manager,
education_group=cls.education_group_year2.education_group)
FacultyAdviserFactory(
adviser=cls.manager,
education_group=cls.education_group_year.education_group)
roles = [
'PROMOTEUR', 'CO_PROMOTEUR', 'READER', 'PROMOTEUR', 'ACCOMPANIST',
'PRESIDENT'
]
status = [
'DRAFT', 'COM_SUBMIT', 'EVA_SUBMIT', 'TO_RECEIVE', 'DIR_SUBMIT',
'DIR_SUBMIT'
]
cls.dissertations_list = list()
for x in range(0, 6):
proposition_dissertation = PropositionDissertationFactory(
author=cls.teacher,
creator=a_person_teacher,
title='Proposition {}'.format(x))
PropositionOfferFactory(
proposition_dissertation=proposition_dissertation,
offer_proposition=cls.offer_proposition1)
cls.dissertations_list.append(
DissertationFactory(
author=cls.student,
title='Dissertation {}'.format(x),
education_group_year=cls.education_group_year,
proposition_dissertation=proposition_dissertation,
status=status[x],
active=True,
dissertation_role__adviser=cls.teacher,
dissertation_role__status=roles[x]))
cls.dissertation_1 = DissertationFactory(
author=cls.student,
title='Dissertation 2017',
education_group_year=cls.education_group_year,
proposition_dissertation=cls.proposition_dissertation,
status='COM_SUBMIT',
active=True,
dissertation_role__adviser=cls.teacher2,
dissertation_role__status='PROMOTEUR')
cls.url = reverse('manager_dissertations_search')
