class OrganizationForm(forms.ModelForm):
start_date = forms.DateField(label=_('partner_start_date'),
help_text=_('partner_start_date_help_text'),
widget=DatePickerInput(
format=DATE_FORMAT,
attrs={
'class': 'datepicker',
'autocomplete': 'off'
},
))
end_date = forms.DateField(label=_('partner_end_date'),
required=False,
widget=DatePickerInput(
format=DATE_FORMAT,
attrs={
'class': 'datepicker',
'autocomplete': 'off'
},
))
website = forms.URLField(label=_('website'))
class Meta:
model = Organization
fields = ['name', 'code', 'type']
def __init__(self, *args, **kwargs):
user = kwargs.pop('user')
super().__init__(*args, **kwargs)
self.fields['name'].label = _('partner_name')
self.fields['type'].label = _('partner_type')
self.fields['type'].required = True
self.fields['type'].choices = [
c for c in self.fields['type'].choices if c[0] != MAIN
]
self.fields['code'].label = _('partner_code')
if not self.instance.pk:
self.fields['start_date'].help_text = ''
else:
self.fields['start_date'].initial = self.instance.start_date
self.fields['end_date'].initial = self.instance.end_date
self.fields['website'].initial = self.instance.website
if not is_linked_to_adri_entity(user):
del self.fields['code']
def clean(self):
super().clean()
data = self.cleaned_data
if data['end_date'] and data['start_date'] > data['end_date']:
self.add_error(
'start_date',
ValidationError(_('start_date_gt_end_date_error')),
)
return data
def save(self, commit=True):
# Generate an acronym upon creation
if not self.instance.pk:
self.instance.prefix = generate_partner_prefix(self.instance.name)
return super().save(commit)
class EntityCalendarEducationalInformationForm(bootstrap.BootstrapModelForm):
start_date = forms.DateTimeField(
widget=DatePickerInput(format=DATE_FORMAT),
input_formats=[
DATE_FORMAT,
],
label=_("Educational information opening"))
end_date = forms.DateTimeField(widget=DatePickerInput(format=DATE_FORMAT),
input_formats=[
DATE_FORMAT,
],
label=_("Educational information ending"))
class Meta:
model = EntityCalendar
fields = ["start_date", "end_date"]
def __init__(self, entity_version, *args, **kwargs):
entity_calendar_obj = entity_calendar.find_by_entity_and_reference_for_current_academic_year(
entity_version.entity.id,
academic_calendar_type.SUMMARY_COURSE_SUBMISSION)
initial = {} if entity_calendar_obj else find_summary_course_submission_dates_for_entity_version(
entity_version)
super().__init__(*args,
instance=entity_calendar_obj,
initial=initial,
**kwargs)
def save_entity_calendar(self, entity, *args, **kwargs):
self.instance.entity = entity
self.instance.academic_calendar = get_by_reference_and_academic_year(
academic_calendar_type.SUMMARY_COURSE_SUBMISSION,
current_academic_year())
return self.save(*args, **kwargs)
class Meta(PartnershipBaseForm.Meta):
fields = PartnershipBaseForm.Meta.fields + (
'start_date',
'end_date',
)
widgets = {
**PartnershipBaseForm.Meta.widgets,
'start_date':
DatePickerInput(
format=DATE_FORMAT,
attrs={
'class': 'datepicker',
'placeholder': _('partnership_start_date'),
'autocomplete': 'off',
},
),
'end_date':
DatePickerInput(
format=DATE_FORMAT,
attrs={
'class': 'datepicker',
'placeholder': _('partnership_end_date'),
'autocomplete': 'off',
},
),
}
class Meta(PartnershipAgreementFormMixin.Meta):
widgets = {
'start_date':
DatePickerInput(
format=DATE_FORMAT,
attrs={
'class': 'datepicker',
'placeholder': _('partnership_start_date'),
'autocomplete': 'off',
},
),
'end_date':
DatePickerInput(
format=DATE_FORMAT,
attrs={
'class': 'datepicker',
'placeholder': _('partnership_end_date'),
'autocomplete': 'off',
},
),
}
class AdministrativeDataSessionForm(forms.Form):
exam_enrollment_range = DateRangeField(label=_('Exam enrollments'), required=False)
scores_exam_submission = forms.DateField(widget=DatePickerInput(format=DATE_FORMAT),
input_formats=[DATE_FORMAT, ],
label=_('Marks presentation'),
required=False)
dissertation_submission = forms.DateField(widget=DatePickerInput(format=DATE_FORMAT),
input_formats=[DATE_FORMAT, ],
label=_('Dissertation submission'),
required=False)
deliberation = forms.SplitDateTimeField(widget=DateTimePickerInput(),
label=_('Deliberation'), required=False)
scores_exam_diffusion = forms.SplitDateTimeField(widget=DateTimePickerInput(),
label=_("Scores diffusion"),
required=False)
def __init__(self, *args, **kwargs):
self.education_group_year = kwargs.pop('education_group_year')
self.session = kwargs.pop('session')
self.list_offer_year_calendar = kwargs.pop('list_offer_year_calendar')
super().__init__(*args, **kwargs)
self._init_fields()
def _get_offer_year_calendar(self, field_name):
ac_type = _get_academic_calendar_type(field_name)
try:
return self.list_offer_year_calendar.get(academic_calendar__reference=ac_type)
except ObjectDoesNotExist:
academic_calendar = AcademicCalendar.objects.get(sessionexamcalendar__number_session=self.session,
academic_year=self.education_group_year.academic_year,
reference=ac_type)
return create_offer_year_calendar(self.education_group_year,
academic_calendar)
def _init_fields(self):
for name, field in self.fields.items():
oyc = self._get_offer_year_calendar(name)
if not oyc:
continue
if isinstance(field, DateRangeField):
field.initial = (convert_datetime_to_date(oyc.start_date),
convert_datetime_to_date(oyc.end_date))
elif isinstance(field, forms.DateField):
field.initial = convert_datetime_to_date(oyc.start_date)
else:
field.initial = oyc.start_date
field.widget.add_min_max_value(oyc.academic_calendar.start_date, oyc.academic_calendar.end_date)
def save(self):
for name, value in self.cleaned_data.items():
oyc = _set_values_in_offer_year_calendar(self._get_offer_year_calendar(name), value)
if oyc.id:
oyc.save()
else:
if oyc.start_date or oyc.end_date:
oyc.save()
def clean(self):
for name, value in list(self.cleaned_data.items()):
oyc = _set_values_in_offer_year_calendar(self._get_offer_year_calendar(name), value)
try:
oyc.clean()
except ValidationError as e:
self.add_error(name, e)
class AdministrativeDataSessionForm(BootstrapForm):
exam_enrollment_range = DateRangeField(label=_('EXAM_ENROLLMENTS'),
required=False)
scores_exam_submission = forms.DateField(
widget=DatePickerInput(format=DATE_FORMAT),
input_formats=[
DATE_FORMAT,
],
label=_('marks_presentation'),
required=False)
dissertation_submission = forms.DateField(
widget=DatePickerInput(format=DATE_FORMAT),
input_formats=[
DATE_FORMAT,
],
label=_('dissertation_presentation'),
required=False)
deliberation = forms.SplitDateTimeField(widget=DateTimePickerInput(),
label=_('DELIBERATION'),
required=False)
scores_exam_diffusion = forms.SplitDateTimeField(
widget=DateTimePickerInput(),
label=_("scores_diffusion"),
required=False)
def __init__(self, *args, **kwargs):
self.education_group_year = kwargs.pop('education_group_year')
self.session = kwargs.pop('session')
self.list_offer_year_calendar = kwargs.pop('list_offer_year_calendar')
super().__init__(*args, **kwargs)
if self.list_offer_year_calendar:
self._init_fields()
else:
raise ObjectDoesNotExist(
'There is no OfferYearCalendar for the education_group_year {}'
.format(self.education_group_year))
def _get_offer_year_calendar(self, field_name):
ac_type = _get_academic_calendar_type(field_name)
return self.list_offer_year_calendar.get(
academic_calendar__reference=ac_type)
def _init_fields(self):
for name, field in self.fields.items():
oyc = self._get_offer_year_calendar(name)
if not oyc:
continue
if isinstance(field, DateRangeField):
field.initial = (convert_datetime_to_date(oyc.start_date),
convert_datetime_to_date(oyc.end_date))
elif isinstance(field, forms.DateField):
field.initial = convert_datetime_to_date(oyc.start_date)
else:
field.initial = oyc.start_date
field.widget.add_min_max_value(oyc.academic_calendar.start_date,
oyc.academic_calendar.end_date)
def save(self):
for name, value in self.cleaned_data.items():
oyc = self._get_offer_year_calendar(name)
_set_values_in_offer_year_calendar(oyc, value)
oyc.save()
def clean(self):
for name, value in list(self.cleaned_data.items()):
oyc = self._get_offer_year_calendar(name)
_set_values_in_offer_year_calendar(oyc, value)
try:
oyc.clean()
except ValidationError as e:
self.add_error(name, e)
class PartnershipFilterForm(forms.Form):
# UCL
ucl_entity = EntityChoiceField(
label=_('faculty_entity_filter'),
queryset=EntityProxy.objects.ucl_entities(),
empty_label=_('ucl_entity'),
required=False,
widget=autocomplete.ModelSelect2(
url='partnerships:autocomplete:ucl_entity_filter',
attrs={
'data-width': '100%',
'data-reset': '#id_years_entity,#id_university_offer',
},
),
)
ucl_entity_with_child = forms.BooleanField(
label=_('Include subordinate entities'),
required=False,
)
education_level = forms.ModelChoiceField(
label=_('education_level_filter'),
queryset=PartnershipYearEducationLevel.objects.filter(
partnerships_years__isnull=False).distinct(),
widget=autocomplete.ModelSelect2(
attrs={
'data-width': '100%',
'class': 'resetting',
'data-reset': '#id_university_offer',
}),
required=False,
)
years_entity = forms.ModelChoiceField(
label=_('entity_filter'),
queryset=EntityProxy.objects.year_entities(),
required=False,
widget=autocomplete.ModelSelect2(
url='partnerships:autocomplete:years_entity_filter',
forward=['ucl_entity'],
attrs={
'data-width': '100%',
'class': 'resetting',
'data-reset': '#id_university_offer',
},
),
)
university_offer = forms.ModelChoiceField(
label=_('university_offers_filter'),
queryset=(
EducationGroupYear.objects.select_related('academic_year').filter(
partnerships__isnull=False).distinct()),
required=False,
widget=autocomplete.ModelSelect2(
url='partnerships:autocomplete:university_offers_filter',
forward=['ucl_entity', 'education_level', 'years_entity'],
attrs={'data-width': '100%'},
),
)
# Partner
partner_entity = forms.ModelChoiceField(
label=_('partner_entity'),
queryset=EntityProxy.objects.partners_having_partnership(),
empty_label=_('partner_entity'),
widget=autocomplete.ModelSelect2(
attrs={'data-width': '100%'},
url='partnerships:autocomplete:partner_entity_partnerships_filter',
),
required=False,
)
partner_type = forms.ChoiceField(
label=_('partner_type'),
choices=((None, '---------'), ) + ORGANIZATION_TYPE,
required=False,
)
erasmus_code = forms.CharField(
label=_('erasmus_code'),
widget=forms.TextInput(attrs={'placeholder': _('erasmus_code')}),
required=False,
)
use_egracons = forms.NullBooleanField(
label=_('use_egracons'),
widget=CustomNullBooleanSelect(),
required=False,
)
city = forms.ChoiceField(
label=_('city'),
choices=((None, _('city')), ),
widget=autocomplete.Select2(attrs={'data-width': '100%'}),
required=False,
)
country = forms.ModelChoiceField(
label=_('country'),
queryset=Country.objects.order_by('name').distinct(),
empty_label=_('country'),
widget=autocomplete.ModelSelect2(attrs={'data-width': '100%'}),
required=False,
)
continent = forms.ModelChoiceField(
label=_('continent'),
queryset=Continent.objects.order_by('name').distinct(),
empty_label=_('continent'),
required=False,
)
partner_tags = forms.ModelMultipleChoiceField(
label=_('partner_tags'),
queryset=PartnerTag.objects.of_partners_having_partnerships(),
widget=autocomplete.ModelSelect2Multiple(attrs={'data-width': '100%'}),
required=False,
)
# Partnerships
education_field = forms.ModelChoiceField(
label=_('education_field'),
queryset=DomainIsced.objects.filter(
partnershipyear__isnull=False).distinct(),
widget=autocomplete.ModelSelect2(attrs={'data-width': '100%'}),
required=False,
)
is_sms = forms.NullBooleanField(
label=_('is_sms'),
widget=CustomNullBooleanSelect(),
required=False,
)
is_smp = forms.NullBooleanField(
label=_('is_smp'),
widget=CustomNullBooleanSelect(),
required=False,
)
is_sta = forms.NullBooleanField(
label=_('is_sta'),
widget=CustomNullBooleanSelect(),
required=False,
)
is_stt = forms.NullBooleanField(
label=_('is_stt'),
widget=CustomNullBooleanSelect(),
required=False,
)
is_smst = forms.NullBooleanField(
label=_('is_smst'),
widget=CustomNullBooleanSelect(),
required=False,
)
partnership_type = forms.ChoiceField(
label=_('partnership_type'),
choices=((None, '---------'), ) + PartnershipType.choices(),
required=False,
)
subtype = forms.ModelChoiceField(
label=_('partnership_subtype'),
queryset=PartnershipSubtype.objects.filter(
years__isnull=False).distinct(),
widget=autocomplete.ModelSelect2(
url='partnerships:autocomplete:subtype',
forward=['partnership_type'],
),
required=False,
)
funding_type = forms.ModelChoiceField(
label=_('funding_type'),
queryset=FundingType.objects.filter(years__isnull=False).distinct(),
widget=autocomplete.ModelSelect2(
url='partnerships:autocomplete:funding_type',
forward=['funding_program'],
),
required=False,
)
funding_program = forms.ModelChoiceField(
label=_('funding_program'),
queryset=FundingProgram.objects.filter(
fundingtype__years__isnull=False, ).distinct(),
widget=autocomplete.ModelSelect2(
url='partnerships:autocomplete:funding_program',
forward=['funding_source'],
),
required=False,
)
funding_source = forms.ModelChoiceField(
label=_('funding_source'),
queryset=FundingSource.objects.filter(
fundingprogram__fundingtype__years__isnull=False, ).distinct(),
required=False,
)
supervisor = forms.ModelChoiceField(
label=_('partnership_supervisor'),
queryset=Person.objects.filter(
Q(partnerships_supervisor__isnull=False)
| Q(management_entities__isnull=False)).order_by(
'last_name').distinct(),
widget=autocomplete.ModelSelect2(attrs={'data-width': '100%'}),
required=False,
)
tags = forms.ModelMultipleChoiceField(
label=_('tags'),
queryset=PartnershipTag.objects.all(),
widget=autocomplete.ModelSelect2Multiple(attrs={'data-width': '100%'}),
required=False,
)
partnership_in = forms.ModelChoiceField(
label=_('partnership_in'),
help_text=_('parnership_in_help_text'),
queryset=AcademicYear.objects.all(),
required=False,
)
partnership_ending_in = forms.ModelChoiceField(
label=_('partnership_ending_in'),
help_text=_('parnership_ending_in_help_text'),
queryset=AcademicYear.objects.all(),
required=False,
)
partnership_valid_in = forms.ModelChoiceField(
label=_('partnership_valid_in'),
queryset=AcademicYear.objects.all(),
required=False,
)
partnership_not_valid_in = forms.ModelChoiceField(
label=_('partnership_not_valid_in'),
queryset=AcademicYear.objects.all(),
required=False,
)
partnership_with_no_agreements_in = forms.ModelChoiceField(
label=_('partnership_with_no_agreements_in'),
help_text=_('partnership_with_no_agreements_in_help_text'),
queryset=AcademicYear.objects.all(),
required=False,
)
partnership_date_type = forms.ChoiceField(
label=_('Partnerships'),
choices=((None, '---------'), ) + DateFilterType.choices(),
required=False,
)
partnership_date_from = forms.DateField(
label=_('during (all or part of) the period from'),
required=False,
widget=DatePickerInput(
format=DATE_FORMAT,
attrs={
'class': 'datepicker',
'autocomplete': 'off'
},
),
input_formats=[DATE_FORMAT],
initial=now,
)
partnership_date_to = forms.DateField(
label=_('to'),
required=False,
widget=DatePickerInput(
format=DATE_FORMAT,
attrs={
'class': 'datepicker',
'autocomplete': 'off'
},
),
input_formats=[DATE_FORMAT],
initial=now,
)
comment = forms.CharField(
label=_('comment'),
required=False,
)
ordering = forms.CharField(widget=forms.HiddenInput, required=False)
is_public = forms.NullBooleanField(
label=_('partnership_is_public'),
widget=CustomNullBooleanSelect(),
required=False,
)
def __init__(self, *args, **kwargs):
user = kwargs.pop('user')
super().__init__(*args, **kwargs)
# Cities
cities = (
EntityVersionAddress.objects.filter(
# We need to go around the relation for sub-entities
entity_version__entity__organization__entity__partner_of__isnull
=False,
city__isnull=False,
).values_list('city', flat=True).order_by('city').distinct('city'))
self.fields['city'].choices = ((None, _('city')), ) + tuple(
(city, city) for city in cities)
allowed = [
scope for scope in PartnershipType
if partnership_type_allowed_for_user_scope(user, scope)
]
# If we have only one scope, pre-filter with this scope
if len(allowed) == 1:
self.fields['partnership_type'].initial = allowed[0].name
elif len(allowed) > 1 and PartnershipType.MOBILITY in allowed:
self.fields[
'partnership_type'].initial = PartnershipType.MOBILITY.name
# Everyone has access to every type, except faculty managers
if len(allowed) == 1 and not is_linked_to_adri_entity(user):
# They have only access to mobility (their only type)
self.fields['partnership_type'].disabled = True
self.fields['partnership_type'].widget = forms.HiddenInput()
# Init ucl_entity for faculty manager
if is_faculty_manager(user):
university = PartnershipEntityManager.get_person_related_entities(
user.person)[0]
self.fields['ucl_entity'].initial = university
self.fields['ucl_entity_with_child'].initial = True
def clean_ordering(self):
# Django filters expects a list
ordering = self.cleaned_data.get('ordering')
if ordering:
return [ordering]
def clean(self):
data = super().clean()
special = data.get('partnership_date_type')
date_from = data.get('partnership_date_from')
date_to = data.get('partnership_date_to')
if special and not date_from:
self.add_error('partnership_date_from', _("required"))
if date_from and date_to and date_from > date_to:
self.add_error(
'partnership_date_to',
_("End date must be after start date"),
)
return data