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