class MeasurementValueFilter(filters.FilterSet):
assay = django_filters.ModelChoiceFilter(
name='measurement__assay',
queryset=models.Assay.objects.all(),
)
created_before = django_filters.IsoDateTimeFilter(
name='updated__mod_time',
lookup_expr='lte',
)
created_after = django_filters.IsoDateTimeFilter(
name='updated__mod_time',
lookup_expr='gte',
)
line = django_filters.ModelChoiceFilter(
name='measurement__assay__line',
queryset=models.Line.objects.all(),
)
x__gt = django_filters.NumberFilter(name='x', lookup_expr='0__gte')
x__lt = django_filters.NumberFilter(name='x', lookup_expr='0__lte')
y__gt = django_filters.NumberFilter(name='y', lookup_expr='0__gte')
y__lt = django_filters.NumberFilter(name='y', lookup_expr='0__lte')
class Meta:
model = models.MeasurementValue
fields = {'measurement': ['exact', 'in']}
class ConvencionalesFiltro(django_filters.FilterSet):
lista = filters.ModelChoiceFilter(queryset=Lista.objects.all().distinct(),
label='',
empty_label='Buscar Colectivo')
distrito = filters.ModelChoiceFilter(
queryset=Distrito.objects.all().distinct(),
label='',
empty_label='Buscar Distrito')
cargo = filters.ModelChoiceFilter(queryset=Cargo.objects.all().distinct(),
label='',
empty_label='Buscar Comisión')
email = django_filters.CharFilter(
lookup_expr='icontains',
widget=TextInput(attrs={'placeholder': 'Buscar por Apellido'}),
label='Buscar Apellido')
# movimiento = filters.ModelChoiceFilter(queryset=Movimiento.objects.all().distinct(), label='', empty_label='Buscar por Partido/Movimiento...')
class Meta:
model = Convencional
fields = (
'lista',
'cargo',
'distrito',
'email',
)
class EventsFilter(FilterSet):
severity = filters.MultipleChoiceFilter(
required=False,
choices=SEVERITY_CHOICES,
widget=forms.SelectMultiple(
attrs={
'style': 'width: 250px',
'data-placeholder': 'Filter by Severity',
'class': 'chosen-select'
}))
feature = filters.TypedChoiceFilter(
choices=((None, ''), ) + DeviceFeature.FEATURE_CHOICES,
widget=forms.Select(
attrs={
'style': 'width: 150px',
'data-placeholder': 'Filter by Feature',
'class': 'chosen-select-deselect'
}))
device = filters.ModelChoiceFilter(
empty_label='',
required=False,
queryset=Device.objects.all(),
widget=forms.Select(
attrs={
'style': 'width: 150px',
'data-placeholder': 'Filter by Device',
'class': 'chosen-select-deselect'
}))
threshold = filters.ModelChoiceFilter(
empty_label='',
required=False,
queryset=Threshold.objects.all(),
widget=forms.Select(
attrs={
'style': 'width: 250px',
'data-placeholder': 'Filter by Threshold',
'class': 'chosen-select-deselect'
}))
order_by = OrderingFilter(fields=[
'id', 'device', 'feature', 'threshold', 'severity', 'summary',
'first_time', 'last_time', 'count', 'clear_time', 'notify_time'
])
class Meta:
model = Event
fields = [
'feature',
'device',
'threshold',
'severity',
]
class TransactionFilterSet(filterset.FilterSet):
account = filters.ModelChoiceFilter(queryset=account_queryset)
category = filters.ModelChoiceFilter(queryset=category_queryset)
tags = filters.CharFilter(method="filter_by_tags")
created_at = filters.CharFilter(method="filter_by_date_range")
updated_at = filters.CharFilter(method="filter_by_date_range")
ordering = filters.OrderingFilter(fields=ORDERING_FIELDS,
field_labels=ORDERING_LABELS,
label=_("Ordering"))
min_amount = filters.NumberFilter(field_name="amount",
lookup_expr="gte",
label=_("Minimum amount"))
max_amount = filters.NumberFilter(field_name="amount",
lookup_expr="lte",
label=_("Maximum amount"))
description = filters.CharFilter(lookup_expr="icontains",
label=_("Descripton"))
class Meta:
model = Transaction
fields = ("type", )
form = TransactionFilterForm
def filter_by_tags(self, queryset, field_name, tags):
if self.form.is_valid():
tag_values = [tag["value"] for tag in tags]
queryset = queryset.filter(**{
"author": self.request.user,
f"{field_name}__name__in": tag_values
})
return queryset
def filter_by_date_range(self, queryset, name, value):
if self.form.is_valid():
start_date, end_date = value.split(" - ")
date_field = forms.DateField()
start_datetime = datetime.combine(
date=date_field.clean(start_date),
time=time.min,
tzinfo=pytz.UTC)
end_datetime = datetime.combine(date=date_field.clean(end_date),
time=time.max,
tzinfo=pytz.UTC)
queryset = queryset.filter(
**{
"author": self.request.user,
f"{name}__gte": start_datetime,
f"{name}__lte": end_datetime,
})
return queryset
class MeasurementFilter(filters.FilterSet):
active = django_filters.BooleanFilter(name='active')
created_before = django_filters.IsoDateTimeFilter(
name='update_ref__mod_time',
lookup_expr='lte',
)
created_after = django_filters.IsoDateTimeFilter(
name='update_ref__mod_time',
lookup_expr='gte',
)
compartment = django_filters.ChoiceFilter(
name='compartment',
choices=models.Measurement.Compartment.CHOICE,
)
line = django_filters.ModelChoiceFilter(
name='assay__line',
queryset=models.Line.objects.all(),
)
measurement_format = django_filters.ChoiceFilter(
name='measurement_format',
choices=models.Measurement.Format.CHOICE,
)
class Meta:
model = models.Measurement
fields = {
'assay': ['exact', 'in'],
'measurement_type': ['exact', 'in'],
'x_units': ['exact', 'in'],
'y_units': ['exact', 'in']
}
class AssayFilter(EDDObjectFilter):
experimenter = django_filters.ModelChoiceFilter(
field_name="experimenter",
help_text=_("ID of the user set as the Assay experimenter"),
queryset=User.objects.all(),
)
in_study = django_filters.CharFilter(
field_name="study",
help_text=_("An identifier for the study; can use ID, UUID, or Slug"),
method=filter_in_study,
)
line = ModelChoiceInFilter(
field_name="line",
help_text=_("IDs of line(s) to limit assays"),
queryset=models.Line.objects.all(),
)
protocol = ModelChoiceInFilter(
field_name="protocol",
help_text=_("IDs of protocol(s) to limit assays"),
queryset=models.Protocol.objects.all(),
)
class Meta:
model = models.Assay
fields = []
class MeasurementFilter(filters.FilterSet):
active = django_filters.BooleanFilter(field_name="active")
created_before = django_filters.IsoDateTimeFilter(
field_name="update_ref__mod_time", lookup_expr="lte"
)
created_after = django_filters.IsoDateTimeFilter(
field_name="update_ref__mod_time", lookup_expr="gte"
)
compartment = django_filters.ChoiceFilter(
field_name="compartment", choices=models.Measurement.Compartment.CHOICE
)
line = django_filters.ModelChoiceFilter(
field_name="assay__line", queryset=models.Line.objects.all()
)
measurement_format = django_filters.ChoiceFilter(
field_name="measurement_format", choices=models.Measurement.Format.CHOICE
)
class Meta:
model = models.Measurement
fields = {
"assay": ["exact", "in"],
"measurement_type": ["exact", "in"],
"x_units": ["exact", "in"],
"y_units": ["exact", "in"],
}
class UserToolFilterSet(FilterSet):
name = filters.CharFilter(field_name="title",
lookup_expr="icontains",
label=_("Tool name"))
borrower = filters.ModelChoiceFilter(method="filter_by_borrower",
queryset=User.objects.none(),
label=_("Borrower"))
class Meta:
model = UserTool
fields = ("name", "taxonomies", "state", "user")
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.filters["user"].label = "Owner"
self.filters["borrower"].queryset = User.objects.filter(is_active=True)
def get_form_class(self):
default_class = super().get_form_class()
fields = default_class.base_fields
return type(str("%sForm" % self.__class__.__name__),
(UserToolFilterViewForm, ), fields)
def filter_by_borrower(self, qs, name, value):
return qs.borrowing_by_user(value)
class QuickEducationGroupYearFilter(FilterSet):
academic_year = filters.ModelChoiceFilter(
queryset=AcademicYear.objects.all(),
required=False,
label=_('Ac yr.'),
empty_label=pgettext_lazy("plural", "All"),
)
acronym = filters.CharFilter(
field_name="acronym",
lookup_expr='icontains',
max_length=40,
required=False,
label=_('Acronym/Short title'),
)
partial_acronym = filters.CharFilter(
field_name="partial_acronym",
lookup_expr='icontains',
max_length=40,
required=False,
label=_('Code'),
)
title = filters.CharFilter(
field_name="title",
lookup_expr='icontains',
max_length=255,
required=False,
label=_('Title')
)
ordering = OrderingFilter(
fields=(
('academic_year__year', 'academic_year'),
('acronym', 'acronym'),
('partial_acronym', 'code'),
('title', 'title'),
),
widget=forms.HiddenInput
)
class Meta:
model = EducationGroupYear
fields = [
'acronym',
'title',
'academic_year',
'partial_acronym'
]
def __init__(self, *args, initial=None, **kwargs):
super().__init__(*args, **kwargs)
self.queryset = self.get_queryset()
if initial:
self.form.fields["academic_year"].initial = initial["academic_year"]
def get_queryset(self):
# Need this close so as to return empty query by default when form is unbound
if not self.data:
return EducationGroupYear.objects.none()
return EducationGroupYear.objects.all()
class ProductFilter(django_filters.FilterSet):
platforms = filters.ModelChoiceFilter(
label=_('Platforms'),
queryset=Platform.objects.all(),
widget=PlatformListGroupLinkWidget(choices=[('', _('All'))]))
categories = filters.ModelChoiceFilter(
label=_('Categories'),
queryset=Category.objects.all(),
widget=ListGroupLinkWidget(choices=[('', _('All'))]))
class Meta:
model = Product
fields = [
'platforms',
'categories',
]
class PersonaFilter(FilterSet):
skills = filters.ModelChoiceFilter(
name='_profile__skills',
label=_('Skills'),
queryset=Skill.objects.all(),
widget=ListGroupLinkWidget(choices=[('', _('All'))]))
class Meta:
model = Persona
class MeasurementValueFilter(filters.FilterSet):
assay = django_filters.ModelChoiceFilter(
field_name="measurement__assay", queryset=models.Assay.objects.all())
created_before = django_filters.IsoDateTimeFilter(
field_name="updated__mod_time", lookup_expr="lte")
created_after = django_filters.IsoDateTimeFilter(
field_name="updated__mod_time", lookup_expr="gte")
line = django_filters.ModelChoiceFilter(
field_name="measurement__assay__line",
queryset=models.Line.objects.all())
x__gt = django_filters.NumberFilter(field_name="x", lookup_expr="0__gte")
x__lt = django_filters.NumberFilter(field_name="x", lookup_expr="0__lte")
y__gt = django_filters.NumberFilter(field_name="y", lookup_expr="0__gte")
y__lt = django_filters.NumberFilter(field_name="y", lookup_expr="0__lte")
class Meta:
model = models.MeasurementValue
fields = {"measurement": ["exact", "in"]}
class FrontProductFilter(FilterSet):
category = filters.ModelChoiceFilter(
name="shop_products__categories",
queryset=Category.objects.all_except_deleted(),
lookup_expr="exact")
class Meta:
model = Product
fields = ["category"]
class PlayerFilter(django_filters.FilterSet):
"""To filter backend data in a form in the HTML table for Players model"""
player = filters.ModelChoiceFilter(queryset=players)
#(field_name="player", lookup_expr='icontains')
class Meta:
model = Player
fields = "__all__"
exclude = ["handicap", "player"]
class EventFilter(django_filters.FilterSet):
category = filters.ModelChoiceFilter(
label=_('Categories'),
queryset=Category.objects.all(),
widget=ListGroupLinkWidget(choices=[('', _('All'))]))
class Meta:
model = Event
fields = [
'category',
]
class ProviderServiceFilterSet(FilterSet):
name = filters.CharFilter(lookup_expr='icontains')
area = filters.ModelChoiceFilter(name='provider__area',
lookup_expr='exact',
queryset=Area.objects.all())
class Meta:
model = ProviderService
form = SearchForm
fields = []
class QuickLearningUnitYearFilter(FilterSet):
academic_year = filters.ModelChoiceFilter(
queryset=AcademicYear.objects.all(),
required=False,
label=_('Ac yr.'),
empty_label=pgettext_lazy("plural", "All"),
)
acronym = filters.CharFilter(
field_name="acronym",
lookup_expr="iregex",
max_length=40,
required=False,
label=_('Code'),
)
title = filters.CharFilter(
field_name="full_title",
lookup_expr="icontains",
max_length=40,
label=_('Title'),
)
ordering = OrderingFilter(fields=(
('academic_year__year', 'academic_year'),
('acronym', 'acronym'),
('full_title', 'title'),
),
widget=forms.HiddenInput)
class Meta:
model = LearningUnitYear
fields = [
"academic_year",
"acronym",
"title",
]
def __init__(self, *args, initial=None, **kwargs):
super().__init__(*args, **kwargs)
self.queryset = self.get_queryset()
if initial:
self.form.fields["academic_year"].initial = initial[
"academic_year"]
def get_queryset(self):
# Need this close so as to return empty query by default when form is unbound
if not self.data:
return LearningUnitYear.objects.none()
queryset = LearningUnitYear.objects_with_container.select_related(
'academic_year', )
queryset = LearningUnitYearQuerySet.annotate_full_title_class_method(
queryset)
return queryset
class LogEntryFilterSet(FilterSet):
content_type = filters.ModelChoiceFilter(
queryset=ContentType.objects.filter(app_label='configfactory',
model__in=[
Environment._meta.model_name,
Component._meta.model_name,
User._meta.model_name,
]))
class Meta:
model = LogEntry
fields = ['user', 'content_type', 'object_id', 'action_type']
class ImportFilter(BaseImportModelFilter):
file_format = line = django_filters.ModelChoiceFilter(
name="import__file_format", queryset=models.ImportFormat.objects.all())
class Meta:
model = models.Import
fields = {
"study": ["exact", "in"],
"protocol": ["exact", "in"],
"category": ["exact", "in"],
"status": ["exact", "in"],
"file_format": ["exact", "in"],
}
class StudyFilter(EDDObjectFilter):
contact = django_filters.ModelChoiceFilter(
field_name="contact",
help_text=_("ID of the user set as the Study contact"),
queryset=User.objects.all(),
)
slug = django_filters.CharFilter(
field_name="slug",
help_text=_("The exact value of the study URL slug"),
lookup_expr="exact",
)
class Meta:
model = models.Study
fields = []
class TestResultFilterSet(FilterSet):
first_name = filters.CharFilter(field_name='acuity_appointment__appointment_data__firstName', label='First Name',
lookup_expr='icontains')
last_name = filters.CharFilter(field_name='acuity_appointment__appointment_data__lastName', label='Last Name',
lookup_expr='icontains')
email = filters.CharFilter(field_name='acuity_appointment__appointment_data__email', label='Email',
lookup_expr='icontains')
phone = filters.CharFilter(field_name='acuity_appointment__appointment_data__phone', label='Phone',
lookup_expr='icontains')
appointment_id = filters.CharFilter(field_name='acuity_appointment__acuity_appointment_id', label='Appointment ID',
lookup_expr='icontains')
test_type = filters.ModelChoiceFilter(field_name='test_type', label='Test Type', queryset=TestType.objects.all())
class Meta:
model = Test
fields = ['first_name', 'last_name', 'email', 'phone', 'appointment_id', 'test_type']
class HeroFilterSet(FilterSet):
user_name = filters.CharFilter(field_name='user__username')
find_opponents_for = filters.ModelChoiceFilter(
method='get_available_opponents',
label="find opponents for",
queryset=Hero.objects.all())
is_alive = filters.BooleanFilter(label='is alive')
class Meta:
model = Hero
fields = ('user_name', 'race', 'guild', 'is_alive',
'find_opponents_for')
def get_available_opponents(self, queryset, name, value: Hero):
available_heroes = Hero.objects.get_annotations().filter(
is_alive=True, race__in=value.race.can_fight_with.all()).exclude(
user=value.user).exclude(battles__in=value.battles.all())
return available_heroes
class FamilyFilter(FilterSet):
name = filters.ModelChoiceFilter(queryset=FamilyList.objects.all())
# family_name = filters.CharFilter(label='family name', lookup_expr='contains')
# women_s = filters.CharFilter(label='women special', lookup_expr='contains')
order_by = MyOrderingFilter(fields=(
('name', 'name'),
('age', 'age'),
),
field_labels={
'name': 'name',
'age': 'age',
},
label='sort order')
class Meta:
model = FamilyList
fields = ('name', )
class LearningUnitFilter(FilterSet):
academic_year = filters.ModelChoiceFilter(
queryset=AcademicYear.objects.all(),
required=False,
label=_('Ac yr.'),
empty_label=pgettext_lazy("plural", "All"),
)
acronym = filters.CharFilter(
field_name="acronym",
lookup_expr="iregex",
max_length=40,
required=False,
label=_('Code'),
)
requirement_entity = filters.CharFilter(
method='filter_entity',
max_length=20,
label=_('Req. Entity'),
)
allocation_entity = filters.CharFilter(
method='filter_entity',
max_length=20,
label=_('Alloc. Entity'),
)
with_entity_subordinated = filters.BooleanFilter(
method=lambda queryset, *args, **kwargs: queryset,
label=_('Include subordinate entities'),
widget=forms.CheckboxInput,
initial='True'
)
tutor = filters.CharFilter(
method="filter_tutor",
max_length=40,
label=_('Tutor'),
)
quadrimester = filters.ChoiceFilter(
choices=quadrimesters.LEARNING_UNIT_YEAR_QUADRIMESTERS,
required=False,
field_name="quadrimester",
label=_('Quadri'),
empty_label=pgettext_lazy("plural", "All"),
)
container_type = filters.ChoiceFilter(
choices=LearningContainerYearType.choices() + MOBILITY_CHOICE,
required=False,
field_name="learning_container_year__container_type",
label=_('Type'),
empty_label=pgettext_lazy("plural", "All"),
method="filter_container_type"
)
subtype = filters.ChoiceFilter(
choices=learning_unit_year_subtypes.LEARNING_UNIT_YEAR_SUBTYPES,
required=False,
field_name="subtype",
label=_('Subtype'),
empty_label=pgettext_lazy("plural", "All")
)
status = filters.ChoiceFilter(
choices=active_status.ACTIVE_STATUS_LIST_FOR_FILTER,
required=False,
label=_('Status'),
field_name="status",
empty_label=pgettext_lazy("plural", "All")
)
title = filters.CharFilter(
field_name="full_title",
method="filter_learning_unit_year_field",
max_length=40,
label=_('Title'),
)
search_type = filters.CharFilter(
field_name="acronym",
method=lambda request, *args, **kwargs: request,
widget=forms.HiddenInput,
required=False,
initial=SearchTypes.SIMPLE_SEARCH.value
)
order_by_field = 'ordering'
ordering = OrderingFilter(
fields=(
('academic_year__year', 'academic_year'),
('acronym', 'acronym'),
('full_title', 'title'),
('learning_container_year__container_type', 'type'),
('subtype', 'subtype'),
('entity_requirement', 'requirement_entity'),
('entity_allocation', 'allocation_entity'),
('credits', 'credits'),
('status', 'status'),
('has_proposal', 'has_proposal'),
),
widget=forms.HiddenInput
)
class Meta:
model = LearningUnitYear
fields = [
"academic_year",
"acronym",
"title",
"container_type",
"subtype",
"requirement_entity",
"allocation_entity",
"credits",
"status",
]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.queryset = self.get_queryset()
self.form.fields["academic_year"].initial = starting_academic_year()
def filter_tutor(self, queryset, name, value):
for tutor_name in value.split():
queryset = queryset.filter(
Q(learningcomponentyear__attributionchargenew__attribution__tutor__person__first_name__iregex=tutor_name
) |
Q(learningcomponentyear__attributionchargenew__attribution__tutor__person__last_name__iregex=tutor_name)
).distinct()
return queryset
def filter_container_type(self, queryset, name, value):
if value == MOBILITY:
return queryset.filter(externallearningunityear__mobility=True)
elif value == learning_container_year_types.EXTERNAL:
return queryset.filter(externallearningunityear__co_graduation=True)
return queryset.filter(learning_container_year__container_type=value)
def filter_entity(self, queryset, name, value):
return filter_by_entities(name, queryset, value, self.form.cleaned_data['with_entity_subordinated'])
def get_queryset(self):
# Need this close so as to return empty query by default when form is unbound
if not self.data:
return LearningUnitYear.objects.none()
has_proposal = ProposalLearningUnit.objects.filter(
learning_unit_year=OuterRef('pk'),
)
queryset = LearningUnitYear.objects_with_container.select_related(
'academic_year',
'learning_container_year__academic_year',
'language',
'proposallearningunit',
'externallearningunityear'
).order_by('academic_year__year', 'acronym').annotate(
has_proposal=Exists(has_proposal),
)
queryset = LearningUnitYearQuerySet.annotate_full_title_class_method(queryset)
queryset = LearningUnitYearQuerySet.annotate_entities_allocation_and_requirement_acronym(queryset)
return queryset
def filter_learning_unit_year_field(self, queryset, name, value):
return filter_field_by_regex(queryset, name, value)
class EducationGroupFilter(FilterSet):
academic_year = filters.ModelChoiceFilter(
queryset=AcademicYear.objects.all(),
required=False,
empty_label=pgettext_lazy("plural", "All"),
label=_('Ac yr.'))
category = filters.ChoiceFilter(
choices=list(Categories.choices()),
required=False,
label=_('Category'),
field_name='education_group_type__category',
empty_label=pgettext_lazy("plural", "All"))
education_group_type = filters.ModelChoiceFilter(
queryset=EducationGroupType.objects.none(),
required=False,
empty_label=pgettext_lazy("plural", "All"),
label=_('Type'),
widget=SelectWithData)
management_entity = filters.CharFilter(
method='filter_with_entity_subordinated', label=_('Entity'))
with_entity_subordinated = filters.BooleanFilter(
method=lambda queryset, *args, **kwargs: queryset,
label=_('With subord. ent.'),
widget=forms.CheckboxInput)
acronym = filters.CharFilter(
field_name="acronym",
lookup_expr='icontains',
max_length=40,
required=False,
label=_('Acronym/Short title'),
)
title = filters.CharFilter(field_name="title",
lookup_expr='icontains',
max_length=255,
required=False,
label=_('Title'))
partial_acronym = filters.CharFilter(
field_name="partial_acronym",
lookup_expr='icontains',
max_length=15,
required=False,
label=_('Code'),
)
order_by_field = 'ordering'
ordering = OrderingFilter(
fields=(('acronym', 'acronym'), ('partial_acronym', 'code'),
('academic_year__year', 'academic_year'), ('title', 'title'),
('education_group_type__name',
'type'), ('management_entity__entityversion__acronym',
'management_entity')),
widget=forms.HiddenInput)
class Meta:
model = EducationGroupYear
fields = [
'acronym',
'partial_acronym',
'title',
'education_group_type__name',
'management_entity',
'with_entity_subordinated',
]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.form.fields[
'education_group_type'].queryset = EducationGroupType.objects.all(
).order_by_translated_name()
self.form.fields['academic_year'].initial = current_academic_year()
self.form.fields[
'category'].initial = education_group_categories.TRAINING
def filter_with_entity_subordinated(self, queryset, name, value):
with_subordinated = self.form.cleaned_data['with_entity_subordinated']
if value:
entity_ids = get_entities_ids(value, with_subordinated)
queryset = queryset.filter(management_entity__in=entity_ids)
return queryset
class F(SeveralFieldsFilter):
f = filters.ModelChoiceFilter(queryset=qs)
class EducationGroupFilter(FilterSet):
academic_year = filters.ModelChoiceFilter(
queryset=AcademicYear.objects.all(),
required=False,
label=_('Ac yr.'),
empty_label=pgettext_lazy("plural", "All"),
)
category = filters.ChoiceFilter(
choices=list(Categories.choices()),
required=False,
label=_('Category'),
field_name='education_group_type__category',
empty_label=pgettext_lazy("plural", "All"))
education_group_type = filters.ModelMultipleChoiceFilter(
queryset=EducationGroupType.objects.none(),
required=False,
label=_('Type'),
widget=autocomplete.ModelSelect2Multiple(
url='education_group_type_autocomplete',
forward=['category'],
),
)
management_entity = filters.CharFilter(
method='filter_with_entity_subordinated', label=_('Entity'))
with_entity_subordinated = filters.BooleanFilter(
method=lambda queryset, *args, **kwargs: queryset,
label=_('Include subordinate entities'),
widget=forms.CheckboxInput)
acronym = filters.CharFilter(
field_name="acronym",
method="filter_education_group_year_field",
max_length=40,
required=False,
label=_('Acronym/Short title'),
)
title = filters.CharFilter(field_name="title",
method='filter_education_group_year_field',
max_length=255,
required=False,
label=_('Title'))
partial_acronym = filters.CharFilter(
field_name="partial_acronym",
method='filter_education_group_year_field',
max_length=15,
required=False,
label=_('Code'),
)
order_by_field = 'ordering'
ordering = OrderingFilter(
fields=(('acronym', 'acronym'), ('partial_acronym', 'code'),
('academic_year__year', 'academic_year'), ('title', 'title'),
('type_ordering', 'type'), ('entity_management_version',
'management_entity')),
widget=forms.HiddenInput)
class Meta:
model = EducationGroupYear
fields = [
'acronym',
'partial_acronym',
'title',
'education_group_type__name',
'management_entity',
'with_entity_subordinated',
]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.queryset = self.get_queryset()
self.form.fields[
'education_group_type'].queryset = EducationGroupType.objects.all(
).order_by_translated_name()
self.form.fields['academic_year'].initial = starting_academic_year()
self.form.fields[
'category'].initial = education_group_categories.TRAINING
self.form.fields["with_entity_subordinated"].initial = kwargs.pop(
'with_entity_subordinated', True)
def filter_with_entity_subordinated(self, queryset, name, value):
with_subordinated = self.form.cleaned_data['with_entity_subordinated']
if value:
entity_ids = get_entities_ids(value, with_subordinated)
queryset = queryset.filter(management_entity__in=entity_ids)
return queryset
@staticmethod
def filter_education_group_year_field(queryset, name, value):
return filter_field_by_regex(queryset, name, value)
def get_queryset(self):
# Need this close so as to return empty query by default when form is unbound
if not self.data:
return EducationGroupYear.objects.none()
management_entity = entity_version.EntityVersion.objects.filter(
entity=OuterRef('management_entity'), ).current(
OuterRef('academic_year__start_date')).values('acronym')[:1]
return EducationGroupYear.objects.all().annotate(type_ordering=Case(
*[
When(education_group_type__name=key, then=Value(str(_(val))))
for i, (key, val) in enumerate(education_group_types.ALL_TYPES)
],
default=Value(''),
output_field=CharField())).annotate(
entity_management_version=Subquery(management_entity))
def filter_queryset(self, queryset):
# Order by id to always ensure same order when objects have same values for order field (ex: title)
qs = super().filter_queryset(queryset)
order_fields = qs.query.order_by + ('id', )
return qs.order_by(*order_fields)
class ExternalLearningUnitFilter(FilterSet):
academic_year = filters.ModelChoiceFilter(
queryset=AcademicYear.objects.all(),
required=False,
label=_('Ac yr.'),
empty_label=pgettext_lazy("plural", "All"),
)
acronym = filters.CharFilter(
field_name="acronym",
lookup_expr="iregex",
max_length=40,
required=False,
label=_('Code'),
)
title = filters.CharFilter(
field_name="full_title",
method="filter_learning_unit_year_field",
max_length=40,
label=_('Title'),
)
status = filters.ChoiceFilter(
choices=active_status.ACTIVE_STATUS_LIST_FOR_FILTER,
required=False,
label=_('Status'),
field_name="status",
empty_label=pgettext_lazy("plural", "All"))
country = filters.ModelChoiceFilter(
queryset=Country.objects.filter(
organizationaddress__isnull=False).distinct().order_by('name'),
field_name="campus__organization__organizationaddress__country",
required=False,
label=_("Country"))
city = filters.ChoiceFilter(
choices=BLANK_CHOICE_DASH,
field_name="campus__organization__organizationaddress__city",
required=False,
label=_("City"),
help_text=_("Please select a country first"))
campus = filters.ChoiceFilter(
choices=BLANK_CHOICE_DASH,
required=False,
label=_("Institution"),
help_text=_("Please select a country and a city first"))
search_type = filters.CharFilter(
field_name="acronym",
method=lambda request, *args, **kwargs: request,
widget=forms.HiddenInput,
required=False,
initial=SearchTypes.EXTERNAL_SEARCH.value)
order_by_field = 'ordering'
ordering = OrderingFilter(fields=(
('academic_year__year', 'academic_year'),
('acronym', 'acronym'),
('full_title', 'title'),
('status', 'status'),
('campus__organization__name', 'campus'),
('credits', 'credits'),
),
widget=forms.HiddenInput)
class Meta:
model = LearningUnitYear
fields = [
"academic_year",
"acronym",
"title",
"credits",
"status",
]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.queryset = self.get_queryset()
self.form.fields["academic_year"].initial = starting_academic_year()
if self.data.get('country'):
self._init_dropdown_list()
def _init_dropdown_list(self):
if self.data.get('country'):
self._init_cities_choices()
if self.data.get('city'):
self._init_campus_choices()
def _init_cities_choices(self):
cities_choices = OrganizationAddress.objects.filter(
country=self.data["country"]).distinct('city').order_by(
'city').values_list('city', 'city')
self.form.fields['city'].choices = cities_choices
def _init_campus_choices(self):
campus_choices = Campus.objects.filter(
organization__organizationaddress__city=self.data['city']
).distinct('organization__name').order_by(
'organization__name').values_list('pk', 'organization__name')
self.form.fields['campus'].choices = campus_choices
def get_queryset(self):
# Need this close so as to return empty query by default when form is unbound
if not self.data:
return LearningUnitYear.objects.none()
has_proposal = ProposalLearningUnit.objects.filter(
learning_unit_year=OuterRef('pk'), )
qs = LearningUnitYear.objects_with_container.filter(
externallearningunityear__co_graduation=True,
externallearningunityear__mobility=False,
).select_related(
'academic_year',
'learning_container_year__academic_year',
'language',
'externallearningunityear',
'campus',
'proposallearningunit',
'campus__organization',
).prefetch_related("learningcomponentyear_set").annotate(
has_proposal=Exists(has_proposal)).order_by(
'academic_year__year', 'acronym')
qs = LearningUnitYearQuerySet.annotate_full_title_class_method(qs)
qs = LearningUnitYearQuerySet.annotate_entities_allocation_and_requirement_acronym(
qs)
return qs
def filter_learning_unit_year_field(self, queryset, name, value):
return filter_field_by_regex(queryset, name, value)
class LearningUnitDescriptionFicheFilter(FilterSet):
academic_year = filters.ModelChoiceFilter(
queryset=AcademicYear.objects.all(), required=True, label=_('Ac yr.'))
acronym = filters.CharFilter(
field_name="acronym",
lookup_expr='icontains',
max_length=40,
required=False,
label=_('Code'),
)
learning_unit_title = filters.CharFilter(
field_name='full_title',
lookup_expr='icontains',
label=_('Title'),
)
container_type = filters.ChoiceFilter(
field_name='learning_container_year__container_type',
choices=LearningContainerYearType.choices() +
((MOBILITY, _('Mobility')), ),
label=_('Type'),
empty_label=pgettext_lazy("plural", "All"))
subtype = filters.ChoiceFilter(
choices=learning_unit_year_subtypes.LEARNING_UNIT_YEAR_SUBTYPES,
label=_('Subtype'),
empty_label=pgettext_lazy("plural", "All"))
status = filters.TypedChoiceFilter(
choices=(('', _("All")), ('true', _("Active")), ('false',
_("Inactive"))),
label=_('Status'),
coerce=strtobool,
)
quadrimester = filters.ChoiceFilter(
choices=quadrimesters.LEARNING_UNIT_YEAR_QUADRIMESTERS,
label=_('Quadri'),
empty_label=pgettext_lazy("plural", "All"))
tutor = filters.CharFilter(
method='filter_tutor',
label=_('Tutor'),
)
requirement_entity = filters.CharFilter(
method='filter_requirement_entity_with_entity_subordinated',
label=_('Req. Entity'))
allocation_entity = filters.CharFilter(
method='filter_allocation_entity_with_entity_subordinated',
label=_('Alloc. Ent.'))
with_entity_subordinated = filters.BooleanFilter(
method=lambda queryset, *args, **kwargs: queryset,
label=_('Include subordinate entities'),
widget=forms.CheckboxInput)
class Meta:
model = LearningUnitYear
fields = []
def __init__(self, data=None, queryset=None, *, request=None, prefix=None):
translated_text_qs = TranslatedText.objects.filter(
entity=LEARNING_UNIT_YEAR,
text_label__label__in=CMS_LABEL_PEDAGOGY,
changed__isnull=False,
reference=OuterRef('pk')).order_by("-changed")
queryset = LearningUnitYear.objects.all().annotate(
full_title=Case(
When(Q(learning_container_year__common_title__isnull=True)
| Q(learning_container_year__common_title__exact=''),
then='specific_title'),
When(Q(specific_title__isnull=True)
| Q(specific_title__exact=''),
then='learning_container_year__common_title'),
default=Concat('learning_container_year__common_title',
Value(' - '), 'specific_title'),
output_field=CharField(),
),
last_translated_text_changed=Subquery(
translated_text_qs.values('changed')[:1]),
)
super(LearningUnitDescriptionFicheFilter, self).__init__(
data=data,
queryset=queryset,
request=request,
prefix=prefix,
)
self.form.fields['academic_year'].initial = starting_academic_year()
self.form.fields['with_entity_subordinated'].initial = True
def filter_tutor(self, queryset, name, value):
return queryset.filter(
Q(learningcomponentyear__attributionchargenew__attribution__tutor__person__first_name__icontains
=value)
|
Q(learningcomponentyear__attributionchargenew__attribution__tutor__person__last_name__icontains
=value))
def filter_requirement_entity_with_entity_subordinated(
self, queryset, name, value):
with_subordinated = self.form.cleaned_data['with_entity_subordinated']
if value:
entity_ids = get_entities_ids(value, with_subordinated)
queryset = queryset.filter(
learning_container_year__requirement_entity__in=entity_ids)
return queryset
def filter_allocation_entity_with_entity_subordinated(
self, queryset, name, value):
with_subordinated = self.form.cleaned_data['with_entity_subordinated']
if value:
entity_ids = get_entities_ids(value, with_subordinated)
queryset = queryset.filter(
learning_container_year__allocation_entity__in=entity_ids)
return queryset
@property
def qs(self):
queryset = super(LearningUnitDescriptionFicheFilter, self).qs
if self.is_bound:
queryset = self._compute_summary_status(queryset)
queryset = queryset.select_related(
'learning_container_year__academic_year', 'academic_year')
return queryset
def _compute_summary_status(self, queryset):
"""
This function will compute the summary status. First, we will take the entity calendar
(or entity calendar parent and so one) of the requirement entity. If not found, the summary status is
computed with the general Academic Calendar Object
"""
entity_calendars_computed = entity_calendar.build_calendar_by_entities(
self.form.cleaned_data['academic_year'].past(),
SUMMARY_COURSE_SUBMISSION,
)
requirement_entities_ids = queryset.values_list(
'learning_container_year__requirement_entity', flat=True)
summary_status_case_statment = [
When(last_translated_text_changed__isnull=True, then=False)
]
for requirement_entity_id in set(requirement_entities_ids):
start_summary_course_submission = entity_calendars_computed.get(
requirement_entity_id, {}).get('start_date')
if start_summary_course_submission is None:
continue
summary_status_case_statment.append(
When(learning_container_year__requirement_entity=
requirement_entity_id,
last_translated_text_changed__gte=
start_summary_course_submission,
then=True))
queryset = queryset.annotate(
summary_status=Case(*summary_status_case_statment,
default=Value(False),
output_field=BooleanField()))
return queryset
class ProposalLearningUnitFilter(FilterSet):
academic_year = filters.ModelChoiceFilter(
queryset=AcademicYear.objects.all(),
required=False,
label=_('Ac yr.'),
empty_label=pgettext_lazy("plural", "All"),
)
acronym = filters.CharFilter(
field_name="acronym",
lookup_expr="iregex",
max_length=40,
required=False,
label=_('Code'),
)
requirement_entity = filters.CharFilter(
method='filter_entity',
max_length=20,
label=_('Req. Entity'),
)
with_entity_subordinated = filters.BooleanFilter(
method=lambda queryset, *args, **kwargs: queryset,
label=_('Include subordinate entities'),
widget=forms.CheckboxInput,
initial='True')
tutor = filters.CharFilter(
method="filter_tutor",
max_length=40,
label=_('Tutor'),
)
entity_folder = filters.ChoiceFilter(
field_name="proposallearningunit__entity_id",
label=_('Folder entity'),
required=False,
empty_label=pgettext_lazy("plural", "All"),
)
folder = filters.NumberFilter(field_name="proposallearningunit__folder_id",
min_value=0,
required=False,
label=_('Folder num.'),
widget=forms.TextInput())
proposal_type = filters.ChoiceFilter(
field_name="proposallearningunit__type",
label=_('Proposal type'),
choices=_get_sorted_choices(ProposalType.choices()),
required=False,
empty_label=pgettext_lazy("plural", "All"),
)
proposal_state = filters.ChoiceFilter(
field_name="proposallearningunit__state",
label=_('Proposal status'),
choices=_get_sorted_choices(ProposalState.choices()),
required=False,
empty_label=pgettext_lazy("plural", "All"),
)
search_type = filters.CharFilter(
field_name="acronym",
method=lambda request, *args, **kwargs: request,
widget=forms.HiddenInput,
required=False,
initial=SearchTypes.PROPOSAL_SEARCH.value)
order_by_field = 'ordering'
ordering = ProposalLearningUnitOrderingFilter(
fields=(
('academic_year__year', 'academic_year'),
('acronym', 'acronym'),
('full_title', 'title'),
('learning_container_year__container_type', 'type'),
('entity_requirement', 'requirement_entity'),
('proposallearningunit__type', 'proposal_type'),
('proposallearningunit__state', 'proposal_state'),
('proposallearningunit__folder_id',
'folder'), # Overrided by ProposalLearningUnitOrderingFilter
),
widget=forms.HiddenInput)
class Meta:
model = LearningUnitYear
fields = [
"academic_year",
"acronym",
"subtype",
"requirement_entity",
]
def __init__(self, *args, person=None, **kwargs):
super().__init__(*args, **kwargs)
self.person = person
self.queryset = self.get_queryset
self._get_entity_folder_id_linked_ordered_by_acronym(self.person)
# Academic year default value = n+1 for proposals search -> use event having n+1 as first open academic year
event_perm = event_perms.EventPermCreationOrEndDateProposalFacultyManager(
)
self.form.fields[
"academic_year"].initial = event_perm.get_academic_years().first()
def _get_entity_folder_id_linked_ordered_by_acronym(self, person):
most_recent_acronym = EntityVersion.objects.filter(entity__id=OuterRef(
'id'), ).order_by("-start_date").values('acronym')[:1]
entities = Entity.objects.filter(
proposallearningunit__isnull=False).annotate(
entity_acronym=Subquery(
most_recent_acronym)).distinct().order_by("entity_acronym")
self.form.fields['entity_folder'].choices = [
(ent.pk, ent.entity_acronym) for ent in entities
]
def filter_entity(self, queryset, name, value):
with_subordinated = self.form.cleaned_data['with_entity_subordinated']
lookup_expression = "__".join(["learning_container_year", name, "in"])
if value:
entity_ids = get_entities_ids(value, with_subordinated)
queryset = queryset.filter(**{lookup_expression: entity_ids})
return queryset
def filter_tutor(self, queryset, name, value):
for tutor_name in value.split():
filter_by_first_name = Q(
learningcomponentyear__attributionchargenew__attribution__tutor__person__first_name__iregex
=tutor_name)
filter_by_last_name = Q(
learningcomponentyear__attributionchargenew__attribution__tutor__person__last_name__iregex
=tutor_name)
queryset = queryset.filter(filter_by_first_name
| filter_by_last_name).distinct()
return queryset
@property
def get_queryset(self):
# Need this close so as to return empty query by default when form is unbound
if not self.data:
return LearningUnitYear.objects.none()
entity_folder = EntityVersion.objects.filter(
entity=OuterRef('proposallearningunit__entity'), ).current(
OuterRef('academic_year__start_date')).values('acronym')[:1]
has_proposal = ProposalLearningUnit.objects.filter(
learning_unit_year=OuterRef('pk'), )
queryset = LearningUnitYear.objects_with_container.filter(
proposallearningunit__isnull=False).select_related(
'academic_year',
'learning_container_year__academic_year',
'language',
'externallearningunityear',
'campus',
'proposallearningunit',
'campus__organization',
).prefetch_related("learningcomponentyear_set", ).annotate(
has_proposal=Exists(has_proposal),
entity_folder=Subquery(entity_folder),
)
queryset = LearningUnitYearQuerySet.annotate_full_title_class_method(
queryset)
queryset = LearningUnitYearQuerySet.annotate_entities_allocation_and_requirement_acronym(
queryset)
return queryset
