def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields["secondary_domains"].widget.attrs['placeholder'] = _(
'Enter text to search')
if getattr(self.instance, 'administration_entity', None):
self.initial['administration_entity'] = get_last_version(
self.instance.administration_entity).pk
self.fields['decree_category'].choices = sorted(add_blank(
decree_category.DecreeCategories.choices()),
key=lambda c: c[1])
self.fields['rate_code'].choices = sorted(rate_code.RATE_CODE,
key=lambda c: c[1])
self.fields['main_domain'].queryset = Domain.objects.filter(type=domain_type.UNIVERSITY)\
.select_related('decree')
if not self.fields['certificate_aims'].disabled:
self.fields['section'].disabled = False
if not getattr(self.initial, 'academic_year', None):
self.set_initial_diploma_values()
if 'instance' in kwargs and not kwargs['instance']:
self.fields['academic_year'].label = _('Start')
def _get_cities(self):
cities = find_distinct_by_country(self.data['country'])
cities_choice_list = []
for a_city in cities:
city_name = a_city['city']
cities_choice_list.append(tuple((city_name, city_name)))
self.fields['city'].choices = add_blank(cities_choice_list)
def _get_campus_list(self):
campus_list = Campus.objects.filter(
organization__organizationaddress__city=self.data['city']
).distinct('organization__name').order_by('organization__name').values('pk', 'organization__name')
campus_choice_list = []
for a_campus in campus_list:
campus_choice_list.append(((a_campus['pk']), (a_campus['organization__name'])))
self.fields['campus'].choices = add_blank(campus_choice_list)
def _get_campus_list(self):
campus_list = Campus.objects.filter(
organization__organizationaddress__city=self.data['city']
).distinct('organization__name').order_by('organization__name').values('pk', 'organization__name')
campus_choice_list = []
for a_campus in campus_list:
campus_choice_list.append(((a_campus['pk']), (a_campus['organization__name'])))
self.fields['campus'].choices = add_blank(campus_choice_list)
def _get_cities(self):
cities = find_distinct_by_country(self.data['country'])
cities_choice_list = []
for a_city in cities:
city_name = a_city['city']
cities_choice_list.append(tuple((city_name, city_name)))
self.fields['city'].choices = add_blank(cities_choice_list)
def __init__(self, person, *args, **kwargs):
super(LearningUnitProposalCreationForm, self).__init__(*args, **kwargs)
# When we submit a proposal, we can select all requirement entity available
self.fields["requirement_entity"].queryset = find_main_entities_version()
if person.user.groups.filter(name=FACULTY_MANAGER_GROUP).exists():
self.fields["requirement_entity"].queryset = person.find_main_entities_version
self.fields["container_type"].choices = add_blank(LEARNING_CONTAINER_YEAR_TYPES_FOR_PROPOSAL_FACULTY)
self.fields["academic_year"].queryset = AcademicYear.objects\
.filter(year__gt=datetime.datetime.now().year)\
.filter(year__lte=MAX_ACADEMIC_YEAR_FACULTY)
def __init__(self, *args, start_year=None, end_year=None, **kwargs):
super().__init__(*args, **kwargs)
if not start_year:
start_year = current_academic_year().year
if not end_year:
end_year = start_year + LEARNING_UNIT_CREATION_SPAN_YEARS
self.choices = [(year, self.academic_year_str(year)) for year in range(start_year, end_year + 1)]
self.choices = add_blank(self.choices)
def __init__(self, *args, start_year=None, end_year=None, **kwargs):
super().__init__(*args, **kwargs)
if not start_year:
start_year = starting_academic_year().year
if not end_year:
end_year = start_year + LEARNING_UNIT_CREATION_SPAN_YEARS
self.choices = [(year, self.academic_year_str(year))
for year in range(start_year.year, end_year.year + 1)]
self.choices = add_blank(self.choices)
class EntitySearchForm(forms.Form):
acronym = forms.CharField(label=_('acronym'), required=False)
title = forms.CharField(label=_('title'), required=False)
entity_type = forms.ChoiceField(label=_('type'),
choices=add_blank(
entity_type.ENTITY_TYPES),
required=False)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields['acronym'].widget.attrs[
'style'] = "text-transform:uppercase"
def get_entities(self):
if super().is_valid():
return mdl.entity_version.search_entities(with_entity=True,
**self.cleaned_data)
else:
return EntityVersion.objects.all()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields["secondary_domains"].widget.attrs['placeholder'] = _('Enter text to search')
if getattr(self.instance, 'administration_entity', None):
self.initial['administration_entity'] = get_last_version(self.instance.administration_entity).pk
self.fields['decree_category'].choices = sorted(add_blank(decree_category.DecreeCategories.choices()),
key=lambda c: c[1])
self.fields['rate_code'].choices = sorted(rate_code.RATE_CODE, key=lambda c: c[1])
self.fields['main_domain'].queryset = Domain.objects.filter(type=domain_type.UNIVERSITY)\
.select_related('decree')
if not self.fields['certificate_aims'].disabled:
self.fields['section'].disabled = False
if not getattr(self.initial, 'academic_year', None):
self.set_initial_diploma_values()
if 'instance' in kwargs and not kwargs['instance']:
self.fields['academic_year'].label = _('Start')
def _create_type_declaration_vacant_list():
return add_blank(VacantDeclarationType.translation_choices())
def _create_learning_container_year_type_list():
return add_blank(LEARNING_CONTAINER_YEAR_TYPES_WITHOUT_EXTERNAL)
def test_add_blank_tuple(self):
result = add_blank((('yoda', 'jediMaster'),))
self.assertEqual(result, ((None, '---------'), ('yoda', 'jediMaster')))
def _create_faculty_learning_container_type_list():
return add_blank(LEARNING_CONTAINER_YEAR_TYPES_FOR_FACULTY)
def _create_external_first_letter_choices():
return add_blank(LearningUnitExternalSite.choices())
class LearningUnitYearForm(BootstrapForm):
first_letter = forms.ChoiceField(choices=lazy(_create_first_letter_choices,
tuple),
required=True)
acronym = forms.CharField(widget=forms.TextInput(attrs={
'maxlength': "15",
'required': True
}))
academic_year = forms.ModelChoiceField(
queryset=mdl.academic_year.find_academic_years(), required=True)
status = forms.BooleanField(required=False, initial=True)
internship_subtype = forms.TypedChoiceField(choices=add_blank(
mdl.enums.internship_subtypes.INTERNSHIP_SUBTYPES),
required=False,
empty_value=None)
credits = forms.DecimalField(
decimal_places=2,
validators=[MinValueValidator(0),
MaxValueValidator(MAXIMUM_CREDITS)],
widget=forms.NumberInput(attrs={
'min': MINIMUM_CREDITS,
'max': MAXIMUM_CREDITS
}))
common_title = forms.CharField(required=False)
common_title_english = forms.CharField(required=False,
widget=forms.TextInput())
specific_title = forms.CharField(required=False)
specific_title_english = forms.CharField(required=False,
widget=forms.TextInput())
session = forms.ChoiceField(add_blank(
mdl.enums.learning_unit_year_session.LEARNING_UNIT_YEAR_SESSION),
required=False)
subtype = forms.CharField(widget=forms.HiddenInput())
container_type = forms.ChoiceField(
choices=lazy(_create_learning_container_year_type_list, tuple),
widget=forms.Select(attrs={'onchange': 'showInternshipSubtype()'}))
faculty_remark = forms.CharField(required=False,
widget=forms.Textarea(attrs={'rows': 2}))
other_remark = forms.CharField(required=False,
widget=forms.Textarea(attrs={'rows': 2}))
periodicity = forms.CharField(widget=forms.Select(
choices=PERIODICITY_TYPES))
quadrimester = forms.CharField(widget=forms.Select(
choices=add_blank(LEARNING_UNIT_YEAR_QUADRIMESTERS)),
required=False)
campus = forms.ModelChoiceField(queryset=find_main_campuses())
requirement_entity = EntitiesVersionChoiceField(
find_main_entities_version().none(),
widget=forms.Select(
attrs={
'onchange':
('updateAdditionalEntityEditability(this.value, "id_additional_requirement_entity_1", false);'
'updateAdditionalEntityEditability(this.value, "id_additional_requirement_entity_2", true);'
)
}))
allocation_entity = EntitiesVersionChoiceField(
queryset=find_main_entities_version(),
required=True,
widget=forms.Select(attrs={'id': 'allocation_entity'}))
additional_requirement_entity_1 = EntitiesVersionChoiceField(
queryset=find_main_entities_version(),
required=False,
widget=forms.Select(
attrs={
'onchange':
'updateAdditionalEntityEditability(this.value, "id_additional_requirement_entity_2", false)',
'disable': 'disable'
}))
additional_requirement_entity_2 = EntitiesVersionChoiceField(
queryset=find_main_entities_version(),
required=False,
widget=forms.Select(attrs={'disable': 'disable'}))
language = forms.ModelChoiceField(find_all_languages(), empty_label=None)
def __init__(self, *args, **kwargs):
self.learning_unit = kwargs.pop('learning_unit', None)
super(LearningUnitYearForm, self).__init__(*args, **kwargs)
# TODO the default value must be set in model.
qs = Campus.objects.filter(name='Louvain-la-Neuve')
if qs.exists():
self.fields['campus'].initial = qs.get()
qs = Language.objects.filter(code='FR')
if qs.exists():
self.fields['language'].initial = qs.get().id
if self.initial.get('subtype') == "PARTIM":
self.fields['specific_title'].label = _(
'official_title_proper_to_partim')
self.fields['specific_title_english'].label = _(
'official_english_title_proper_to_partim')
else:
self.fields['specific_title'].label = _(
'official_title_proper_to_UE')
self.fields['specific_title_english'].label = _(
'official_english_title_proper_to_UE')
def _get_existing_acronym_list(self, academic_year, acronym):
if self.learning_unit:
learning_unit_years = mdl.learning_unit_year.find_gte_year_acronym(academic_year, acronym) \
.exclude(learning_unit=self.learning_unit)
else:
learning_unit_years = mdl.learning_unit_year.find_gte_year_acronym(
academic_year, acronym)
return [
learning_unit_year.acronym
for learning_unit_year in learning_unit_years
]
def clean(self):
cleaned_data = super().clean()
if self.errors:
return cleaned_data
self._check_if_acronym_already_exists(cleaned_data)
if 'internship_subtype' in self.fields \
and cleaned_data.get("container_type") == INTERNSHIP \
and not (cleaned_data['internship_subtype']):
self.add_error('internship_subtype', _('field_is_required'))
if not cleaned_data["common_title"] and not cleaned_data[
"specific_title"]:
self.add_error("common_title",
_("must_set_common_title_or_specific_title"))
requirement_entity = cleaned_data["requirement_entity"]
allocation_entity = cleaned_data["allocation_entity"]
container_type = cleaned_data["container_type"]
self._are_requirement_and_allocation_entities_valid(
requirement_entity, allocation_entity, container_type)
return cleaned_data
def _check_if_acronym_already_exists(self, cleaned_data):
if 'acronym' in cleaned_data and 'academic_year' in cleaned_data and cleaned_data[
'academic_year']:
acronym = cleaned_data['acronym']
academic_year = cleaned_data['academic_year']
learning_unit_years_list = self._get_existing_acronym_list(
academic_year, acronym)
if acronym in learning_unit_years_list:
self.add_error('acronym', _('already_existing_acronym'))
def _are_requirement_and_allocation_entities_valid(self,
requirement_entity,
allocation_entity,
container_type):
if requirement_entity != allocation_entity and \
container_type in LEARNING_CONTAINER_YEAR_TYPES_MUST_HAVE_SAME_ENTITIES:
self.add_error(
"allocation_entity",
_("requirement_and_allocation_entities_cannot_be_different"))
def clean_acronym(self, regex=LEARNING_UNIT_ACRONYM_REGEX_ALL):
acronym = _merge_first_letter_and_acronym(
self.cleaned_data.get('first_letter', ""),
self.cleaned_data.get('acronym', ""))
if not re.match(regex, acronym):
raise ValidationError(_('invalid_acronym'))
return acronym
class LearningUnitYearForm(BootstrapForm):
first_letter = forms.ChoiceField(choices=lazy(_create_first_letter_choices,
tuple),
required=True)
acronym = forms.CharField(widget=forms.TextInput(attrs={
'maxlength': "15",
'required': True
}))
academic_year = forms.ModelChoiceField(
queryset=mdl.academic_year.find_academic_years(), required=True)
status = forms.BooleanField(required=False, initial=True)
internship_subtype = forms.TypedChoiceField(choices=add_blank(
mdl.enums.internship_subtypes.INTERNSHIP_SUBTYPES),
required=False,
empty_value=None)
credits = forms.DecimalField(
decimal_places=2,
validators=[MinValueValidator(0),
MaxValueValidator(MAXIMUM_CREDITS)],
widget=forms.NumberInput(attrs={
'min': MINIMUM_CREDITS,
'max': MAXIMUM_CREDITS
}))
common_title = forms.CharField()
common_title_english = forms.CharField(required=False,
widget=forms.TextInput())
specific_title = forms.CharField(required=False)
specific_title_english = forms.CharField(required=False,
widget=forms.TextInput())
session = forms.ChoiceField(add_blank(
mdl.enums.learning_unit_year_session.LEARNING_UNIT_YEAR_SESSION),
required=False)
subtype = forms.CharField(widget=forms.HiddenInput())
container_type = forms.ChoiceField(
choices=lazy(_create_learning_container_year_type_list, tuple),
widget=forms.Select(attrs={'onchange': 'showInternshipSubtype()'}))
faculty_remark = forms.CharField(required=False,
widget=forms.Textarea(attrs={'rows': 2}))
other_remark = forms.CharField(required=False,
widget=forms.Textarea(attrs={'rows': 2}))
periodicity = forms.CharField(widget=forms.Select(
choices=PERIODICITY_TYPES))
quadrimester = forms.CharField(widget=forms.Select(
choices=add_blank(LEARNING_UNIT_YEAR_QUADRIMESTERS)),
required=False)
campus = forms.ModelChoiceField(queryset=find_main_campuses())
requirement_entity = EntitiesVersionChoiceField(
find_main_entities_version().none(),
widget=forms.Select(
attrs={
'onchange':
('updateAdditionalEntityEditability(this.value, "id_additional_requirement_entity_1", false);'
'updateAdditionalEntityEditability(this.value, "id_additional_requirement_entity_2", true);'
)
}))
allocation_entity = EntitiesVersionChoiceField(
queryset=find_main_entities_version(),
required=True,
widget=forms.Select(attrs={'id': 'allocation_entity'}))
additional_requirement_entity_1 = EntitiesVersionChoiceField(
queryset=find_main_entities_version(),
required=False,
widget=forms.Select(
attrs={
'onchange':
'updateAdditionalEntityEditability(this.value, "id_additional_requirement_entity_2", false)',
'disable': 'disable'
}))
additional_requirement_entity_2 = EntitiesVersionChoiceField(
queryset=find_main_entities_version(),
required=False,
widget=forms.Select(attrs={'disable': 'disable'}))
language = forms.ModelChoiceField(find_all_languages(), empty_label=None)
def clean(self):
cleaned_data = super().clean()
if 'internship_subtype' in self.fields \
and cleaned_data.get("container_type") == INTERNSHIP \
and not (cleaned_data['internship_subtype']):
self.add_error('internship_subtype', _('field_is_required'))
return cleaned_data
def clean_acronym(self, regex=LEARNING_UNIT_ACRONYM_REGEX_ALL):
acronym = _merge_first_letter_and_acronym(
self.cleaned_data.get('first_letter', ""),
self.cleaned_data.get('acronym', ""))
if not re.match(regex, acronym):
self.add_error('acronym', _('invalid_acronym'))
return acronym
def _create_external_first_letter_choices():
return add_blank(LearningUnitExternalSite.choices())
def _create_first_letter_choices():
return add_blank(LearningUnitManagementSite.choices())
def _get_section_choices():
return add_blank(CertificateAim.objects.values_list('section', 'section').distinct().order_by('section'))
def _create_attribution_procedure_list():
return add_blank(AttributionProcedures.translation_choices())
def _create_first_letter_choices():
return add_blank(LearningUnitManagementSite.choices())
def _get_section_choices():
return add_blank(
add_all(Country.objects.filter(entity__isnull=False).values_list('id', 'name') .distinct().order_by('name'))
)
def _create_learning_container_year_type_list():
return add_blank(LEARNING_CONTAINER_YEAR_TYPES_WITHOUT_EXTERNAL)
def _get_section_choices():
return add_blank(
CertificateAim.objects.values_list(
'section', 'section').distinct().order_by('section'))
def test_add_blank_list(self):
result = add_blank([('yoda', 'jediMaster')])
self.assertEqual(result, [(None, '---------'), ('yoda', 'jediMaster')])
def _get_section_choices():
return add_blank(add_all(
Country.objects.filter(entity__isnull=False).values_list(
'id', 'name').distinct().order_by('name')),
blank_choice_display="UCLouvain")
def test_add_blank_queryset(self):
luy = LearningUnitYearFactory()
result = add_blank(LearningUnitYear.objects.all().values_list('id', 'acronym'))
self.assertEqual(result, [(None, '---------'), (luy.id, luy.acronym)])
def _create_faculty_learning_container_type_list():
return add_blank(LEARNING_CONTAINER_YEAR_TYPES_FOR_FACULTY)
