class ExerciceFilter(filters.FilterSet): posteur__nom_prof = filters.CharFilter(lookup_expr='icontains') is_corrected = filters.BooleanFilter(field_name='correcs', method='filter_is_corrected') is_from_livre = filters.BooleanFilter(field_name='livre', method='filter_is_from_livre') is_delai_depasse = filters.BooleanFilter(field_name='date_limite', method='filter_is_delai_depasse') def filter_is_corrected(self, queryset, name, value): qs = queryset.annotate(num_c=Count(name)) results = qs.filter(num_c__gte=1) if value else qs.filter(num_c__lte=0) return results def filter_is_from_livre(self, queryset, name, value): results = queryset.filter(livre__isnull=not value) return results def filter_is_delai_depasse(self, queryset, name, value): if value: results = queryset.filter(date_limite__lt=now) else: results = queryset.filter(date_limite__gt=now) return results class Meta: model = Exercice fields = ['prefix_prof', 'nom_prof', 'nom_etablissement', 'niveau', 'option', 'voie', 'chapitre', 'type', 'devoir', 'livre', 'num_page', 'num_exo', 'is_corrected', 'is_from_livre', 'is_delai_depasse']
class ShiftingFilterSet(filters.FilterSet): def get_status( self, queryset, field_name, value, ): if value: if value in inverse_shifting_status: return queryset.filter(status=inverse_shifting_status[value]) return queryset status = filters.CharFilter(method="get_status", field_name="status") facility = filters.UUIDFilter(field_name="facility__external_id") patient = filters.UUIDFilter(field_name="patient__external_id") patient_name = filters.CharFilter(field_name="patient__name", lookup_expr="icontains") patient_phone_number = filters.CharFilter( field_name="patient__phone_number", lookup_expr="icontains") orgin_facility = filters.UUIDFilter( field_name="orgin_facility__external_id") shifting_approving_facility = filters.UUIDFilter( field_name="shifting_approving_facility__external_id") assigned_facility = filters.UUIDFilter( field_name="assigned_facility__external_id") emergency = filters.BooleanFilter(field_name="emergency") is_up_shift = filters.BooleanFilter(field_name="is_up_shift") is_kasp = filters.BooleanFilter(field_name="is_kasp") created_date = filters.DateFromToRangeFilter(field_name="created_date") modified_date = filters.DateFromToRangeFilter(field_name="modified_date") assigned_to = filters.NumberFilter(field_name="assigned_to__id")
class ProcessTaskFilter(filters.FilterSet): retry_type = filters.BooleanFilter(field_name='retry_type', method='filter_retry_type') retried = filters.BooleanFilter(method='filter_retried') hidden = filters.BooleanFilter(field_name='hidden', method='filter_hidden') def filter_hidden(self, queryset, name, value): if value is False: return queryset.filter(Q(Q(hidden=value) | Q(hidden__isnull=True)), ) return queryset.filter(hidden=value) def filter_retry_type(self, queryset, name, value): value = not value return queryset.filter(retried_task__isnull=value) def filter_retried(self, queryset, name, value): value = not value return queryset.filter(retried__isnull=value) class Meta: model = ProcessTask fields = [ 'retry_type', 'hidden', ]
class ListingFilter(filters.FilterSet): start_date = filters.DateFilter( field_name='start_date', lookup_expr='gte', ) end_date = filters.DateFilter( field_name='end_date', lookup_expr='lte', ) ensuite = filters.BooleanFilter( field_name='rooms__ensuite', lookup_expr='exact', ) minifridge = filters.BooleanFilter( field_name='rooms__minifridge', lookup_expr='exact', ) bed_type = NumberInFilter( field_name='rooms__bed_type', lookup_expr='in', ) class Meta: model = Listing fields = [ 'start_date', 'end_date', 'ensuite', 'minifridge', 'bed_type', ]
class DeliveryFilter(filters.FilterSet): first_name = filters.CharFilter(method='filter_field') last_name = filters.CharFilter(method='filter_field') country = filters.CharFilter(method='filter_field') phone = filters.CharFilter(method='filter_field') passport_id = filters.CharFilter(method='filter_field') in_house = filters.BooleanFilter(method='filter_in_house') in_store = filters.BooleanFilter(method='filter_in_store') class Meta: model = Delivery fields = () def filter_field(self, qs, name, value): query = {f"pilgrim__{name}__icontains": value} return qs.filter(**query) def filter_in_house(self, qs, name, value): if value: return qs.filter(exited_at__isnull=True) else: return qs.filter(exited_at__isnull=False) def filter_in_store(self, qs, name, value): if value: return qs.filter(exit_type=Delivery.DELIVERED_TO_STORE) else: return qs.exclude(exit_type=Delivery.DELIVERED_TO_STORE)
class GoodsFilter(filters.FilterSet): pricemin = filters.NumberFilter(field_name='shop_price', lookup_expr='gte', help_text='最小价格') pricemax = filters.NumberFilter(field_name='shop_price', lookup_expr='lte', help_text='最大价格') name = filters.CharFilter(field_name="name", lookup_expr="icontains", help_text='根据商品名过滤商品列表') top_category = filters.NumberFilter(method='top_category_filters', help_text='根据商品类目过滤商品列表') is_hot = filters.BooleanFilter(help_text='是否热卖') is_new = filters.BooleanFilter(help_text='是否新品') # name 是 top_category 这个字段 # value 是商品类别的id # queryset 是商品数据 def top_category_filters(self, queryset, name, value): # 商品数据根据它的商品三级类目或二级类目或三级类目进行过滤 queryset = queryset.filter( Q(category__id=value) | Q(category__parent_category_id=value) | Q(category__parent_category__parent_category_id=value)) print(queryset) return queryset class Meta: model = Goods fields = ['pricemin', 'pricemax', 'name', 'is_hot', 'is_new']
class CasEleveFilter(BaseFilters): student_field = "matricule" classe = filters.CharFilter(method='classe_by') activate_important = filters.BooleanFilter(field_name="important") no_sanctions = filters.BooleanFilter(method="no_sanctions_by") no_infos = filters.BooleanFilter(method="no_infos_by") class Meta: fields_to_filter = ('name', 'matricule_id', 'info__info', 'sanction_decision__sanction_decision', 'datetime_encodage',) model = CasEleve fields = BaseFilters.Meta.generate_filters(fields_to_filter) filter_overrides = BaseFilters.Meta.filter_overrides def no_infos_by(self, queryset, field_name, value): if value: return queryset.filter(sanction_decision__isnull=False) else: return queryset def no_sanctions_by(self, queryset, field_name, value): if value: return queryset.filter(info__isnull=False) else: return queryset
class ContractRouteFilter(filters.FilterSet): id = filters.NumberFilter(name="id", label="ID", lookup_expr="exact") id_range = filters.RangeFilter(name="id", label="ID Between") source = filters.CharFilter(name="source__name", label="Source City name", lookup_expr="icontains") source_null = filters.BooleanFilter(name="source", label="Is Source name Null", lookup_expr='isnull') destination = filters.CharFilter(name="destination__name", label="Destination name", lookup_expr="icontains") destination_null = filters.BooleanFilter(name="destination", label="Is Destination name Null", lookup_expr="isnull") rate_type = filters.CharFilter(name="rate_type__name", label="Rate Type name", lookup_expr="icontains") rate_type_null = filters.BooleanFilter(name="rate_type", label="Is Rate Type name Null", lookup_expr="isnull") rate_range = filters.NumericRangeFilter(name="rate", label="Rate Range") created_on = filters.IsoDateTimeFilter(name="created_on", label="Created on") created_between = filters.DateTimeFromToRangeFilter( name="created_on", label="Created Between") class Meta: model = ContractRoute fields = []
class TitleFilter(rest_framework.FilterSet): title = rest_framework.CharFilter(field_name='title', lookup_expr='iexact') entry_username = rest_framework.CharFilter(method='filter_by_username') today = rest_framework.BooleanFilter(method='get_today') full_text = rest_framework.CharFilter(method='get_full_text') followed = rest_framework.BooleanFilter(method="get_followed_title") class Meta: model = Title fields = ('title', 'today', 'full_text', "followed", 'is_ukde') def filter_by_username(self, queryset, name, value): return queryset.filter(entry__user__username=value, entry__status='publish').distinct() def get_today(self, queryset, name, value): return queryset.active_today() def get_full_text(self, queryset, name, value): return queryset.full_text_search(value) def get_followed_title(self, queryset, name, value): if self.request.user.is_authenticated: queryset = queryset.prefetch_related("follows") return queryset.filter(follows__user=self.request.user) return queryset def get_title_with_is_ukde(self, queryset): if self.request.user.is_authenticated: return queryset.get_titles_with_is_ukde() return queryset
class MakingOrderFilter(filters.FilterSet): name = filters.CharFilter(field_name='name', lookup_expr='icontains') standard = filters.CharFilter(field_name='standard', lookup_expr='icontains') drawing_number = filters.CharFilter(field_name='drawing_number', lookup_expr='icontains') no_supplier = filters.BooleanFilter(field_name='supplier', lookup_expr='isnull') no_bom = filters.BooleanFilter(field_name='bill_of_material', lookup_expr='isnull') class Meta: model = MakingOrder fields = [ 'id', 'number', 'company', 'manufacturer', 'bill_of_material', 'bill_of_material__job_order', 'bill_of_material__type', 'name', 'standard', 'is_printed', 'supplier', 'no_supplier', 'unit_price', 'no_bom', 'bill_of_material__type__is_processed_parts' ] order_by = filters.OrderingFilter( choices=( ('created_at', 'created_at'), ('unit_price', 'unit_price'), ('number', 'number'), ('name', 'name'), ('supplier__name', 'supplier__name'), ('manufacturer__name', 'manufacturer__name'), ('standard', 'standard'), ('drawing_number', 'drawing_number'), ('desired_delivery_date', 'desired_delivery_date'), ('-desired_delivery_date', '-desired_delivery_date'), ('is_printed', 'is_printed') ), )
class SubscriberCalendarsFilter(filters.FilterSet): subscribed = filters.BooleanFilter( field_name='subscribers', method='filter_subscribed', ) permission = filters.BooleanFilter( field_name='groups', method='filter_permission', ) class Meta: model = Calendar fields = ['subscribed', 'permission'] def filter_subscribed(self, queryset, name, value): if not value or not self.request.user.is_authenticated: return queryset return queryset.filter(**{name: self.request.user.id}) def filter_permission(self, queryset, name, value): if not value or not self.request.user.is_authenticated: return queryset.filter(name='') return queryset \ .filter( Q(permissions__role=self.request.user.role), Q(permissions__group__user=self.request.user), Q(permissions__authority=AuthorityChoice.write)) \ .distinct()
class StorageMediumFilter(filters.FilterSet): status = ListFilter(field_name='status', distinct='true') medium_type = filters.ChoiceFilter(field_name='storage_target__type', choices=medium_type_CHOICES) storage_type = filters.ChoiceFilter( field_name= 'storage_target__storage_method_target_relations__storage_method__type', choices=storage_type_CHOICES) deactivatable = filters.BooleanFilter(label='deactivatable', method='filter_deactivatable') include_inactive_ips = filters.BooleanFilter( method='filter_include_inactive_ips') migratable = filters.BooleanFilter(label='migratable', method='filter_migratable') medium_id_range = CharSuffixRangeFilter(field_name='medium_id') policy = filters.ModelChoiceFilter( label='Policy', queryset=StoragePolicy.objects.all(), field_name= 'storage_target__storage_method_target_relations__storage_method__storage_policies', distinct=True) def filter_include_inactive_ips(self, queryset, *args): # this filter is only used together with deactivatable return queryset def filter_deactivatable(self, queryset, name, value): include_inactive_ips = self.request.query_params.get( 'include_inactive_ips', False) include_inactive_ips = include_inactive_ips in (True, 'True', 'true', '1') return queryset.deactivatable( include_inactive_ips=include_inactive_ips) def filter_migratable(self, queryset, name, value): if value: return queryset.migratable() else: return queryset.non_migratable() ordering = StorageMediumOrderingFilter(fields=( ('id', 'id'), ('medium_id', 'medium_id'), ('storage_target__name', 'storage_target'), ('storage_target__max_capacity', 'max_capacity'), ('status', 'status'), ('location', 'location'), ('location_status', 'location_status'), ('used_capacity', 'used_capacity'), ('create_date', 'create_date'), ), ) class Meta: model = StorageMedium fields = ( 'status', 'medium_type', 'storage_type', 'medium_id', )
class StorageMethodFilter(filters.FilterSet): policy = filters.ModelChoiceFilter(label='Policy', queryset=StoragePolicy.objects.all(), field_name='storage_policies', distinct=True) has_enabled_target = filters.BooleanFilter( method='filter_has_enabled_target') has_migrate_target = filters.BooleanFilter( method='filter_has_migrate_target') def filter_has_enabled_target(self, queryset, name, value): status = STORAGE_TARGET_STATUS_ENABLED return queryset.filter_has_target_with_status(status, value) def filter_has_migrate_target(self, queryset, name, value): status = STORAGE_TARGET_STATUS_MIGRATE return queryset.filter_has_target_with_status(status, value) class Meta: model = StorageMethod fields = ( 'enabled', 'policy', 'has_enabled_target', 'has_migrate_target', )
class AahoOfficeFilter(filters.FilterSet): id = filters.NumberFilter(name="id", label="ID", lookup_expr="exact") id_range = filters.RangeFilter(name="id", label="ID Between") branch_name = filters.CharFilter(name="branch_name", label="Aaho Office Name", lookup_expr='icontains') branch_name_null = filters.BooleanFilter(name="branch_name", label="Is Aaho Office Name Null", lookup_expr="isnull") branch = filters.CharFilter(name="branch__name", label="Aaho Office Branch", lookup_expr='icontains') branch_null = filters.BooleanFilter(name="branch", label="Is Aaho Office Branch Null", lookup_expr="isnull") address = filters.CharFilter(name="address", label="Aaho Office Address Name", lookup_expr='icontains') address_null = filters.BooleanFilter( name="address", label="Is Aaho Office Address Name Null", lookup_expr="isnull") created_on = filters.IsoDateTimeFilter(name="created_on", label="Created on") created_between = filters.DateTimeFromToRangeFilter( name="created_on", label="Created Between") class Meta: model = AahoOffice fields = []
class HostFilter(drf_filters.FilterSet): cluster_is_null = drf_filters.BooleanFilter(field_name='cluster_id', lookup_expr='isnull') provider_is_null = drf_filters.BooleanFilter(field_name='provider_id', lookup_expr='isnull') class Meta: model = Host fields = ['cluster_id', 'prototype_id', 'provider_id', 'fqdn']
class CustomerContractFilter(filters.FilterSet): id = filters.NumberFilter(name="id", label="ID", lookup_expr="exact") id_range = filters.RangeFilter(name="id", label="ID Between") customer_name = filters.CharFilter(name="customer__name__username", label="Customer name", lookup_expr="icontains") customer_name_null = filters.BooleanFilter(name="customer__name__username", label="Is Customer name Null", lookup_expr='isnull') customer_code = filters.CharFilter(name="customer__company_code", label="Customer name") customer_code_null = filters.BooleanFilter(name="customer__name__username", label="Is Customer name Null", lookup_expr="isnull") start_date_between = filters.DateTimeFromToRangeFilter( name="start_date", label="Start Date Between") billing_frequency = filters.ChoiceFilter(name="billing_frequency", choices=BILLING_FREQUENCY_CHOICES) created_on = filters.IsoDateTimeFilter(name="created_on", label="Created on") created_between = filters.DateTimeFromToRangeFilter( name="created_on", label="Created Between") class Meta: model = CustomerContract fields = []
class PatientFilterSet(filters.FilterSet): source = filters.ChoiceFilter(choices=PatientRegistration.SourceChoices) disease_status = CareChoiceFilter(choice_dict=DISEASE_STATUS_DICT) facility = filters.UUIDFilter(field_name="facility__external_id") phone_number = filters.CharFilter(field_name="phone_number") allow_transfer = filters.BooleanFilter(field_name="allow_transfer") name = filters.CharFilter(field_name="name", lookup_expr="icontains") ip_no = filters.CharFilter(field_name="last_consultation__ip_no", lookup_expr="icontains") gender = filters.NumberFilter(field_name="gender") age = filters.NumberFilter(field_name="age") age_min = filters.NumberFilter(field_name="age", lookup_expr="gt") age_max = filters.NumberFilter(field_name="age", lookup_expr="lt") category = filters.ChoiceFilter(field_name="last_consultation__category", choices=CATEGORY_CHOICES) created_date = filters.DateFromToRangeFilter(field_name="created_date") modified_date = filters.DateFromToRangeFilter(field_name="modified_date") srf_id = filters.CharFilter(field_name="srf_id") is_declared_positive = filters.BooleanFilter(field_name="is_declared_positive") # Location Based Filtering district = filters.NumberFilter(field_name="district__id") district_name = filters.CharFilter(field_name="district__name", lookup_expr="icontains") local_body = filters.NumberFilter(field_name="local_body__id") local_body_name = filters.CharFilter(field_name="local_body__name", lookup_expr="icontains") state = filters.NumberFilter(field_name="state__id") state_name = filters.CharFilter(field_name="state__name", lookup_expr="icontains") # Consultation Fields last_consultation_admission_date = filters.DateFromToRangeFilter(field_name="last_consultation__admission_date") last_consultation_discharge_date = filters.DateFromToRangeFilter(field_name="last_consultation__discharge_date") last_consultation_admitted_to = filters.NumberFilter(field_name="last_consultation__admitted_to") last_consultation_assigned_to = filters.NumberFilter(field_name="last_consultation__assigned_to")
class UserFilter(filters.FilterSet): current = filters.BooleanFilter(name="current", label="Current", method="filter_current") viewer = filters.CharFilter(method="filter_viewer") is_active = filters.BooleanFilter(name="is_active", label="is_active") def filter_current(self, queryset, name, value): if value: return queryset.filter(id=self.request.user.id) else: return queryset def filter_viewer(self, queryset, name, value): if value: return queryset.filter(page_viewer_users=value) else: return queryset.filter(page_viewer_users=None) class Meta: model = User ordering = ['name'] fields = {}
class ProcessTaskFilter(filters.FilterSet): undo_type = filters.BooleanFilter(field_name='undo_type', method='filter_undo_type') retry_type = filters.BooleanFilter(field_name='retry_type', method='filter_retry_type') undone = filters.BooleanFilter(method='filter_undone') retried = filters.BooleanFilter(method='filter_retried') hidden = filters.BooleanFilter(field_name='hidden') def filter_undo_type(self, queryset, name, value): value = not value return queryset.filter(undone_task__isnull=value) def filter_retry_type(self, queryset, name, value): value = not value return queryset.filter(retried_task__isnull=value) def filter_undone(self, queryset, name, value): value = not value return queryset.filter(undone__isnull=value) def filter_retried(self, queryset, name, value): value = not value return queryset.filter(retried__isnull=value) class Meta: model = ProcessTask fields = [ 'undo_type', 'retry_type', 'hidden', ]
class ScheduleChangeFilter(BaseFilters): activate_ongoing = filters.BooleanFilter(method="activate_ongoing_by") activate_has_classe = filters.BooleanFilter( method="activate_has_classe_by") class Meta: fields_to_filter = ( 'date_change', 'activate_ongoing', 'activate_has_classe', ) model = ScheduleChangeModel fields = BaseFilters.Meta.generate_filters(fields_to_filter) filter_overrides = BaseFilters.Meta.filter_overrides def activate_ongoing_by(self, queryset, name, value): return queryset.filter( Q(date_change__gte=timezone.now().date(), time_end__hour__gte=timezone.now().astimezone().hour) | Q(date_change=timezone.now().date(), time_start=None, time_end=None) | Q(date_change__gt=timezone.now())) def activate_has_classe_by(self, queryset, name, value): return queryset.exclude(classes__exact="")
class CityFilter(filters.FilterSet): id = filters.NumberFilter(name="id", label="ID", lookup_expr="exact") id_range = filters.RangeFilter(name="id", label="ID Between") name = filters.CharFilter(name="name", label="City Name", lookup_expr='icontains') name_null = filters.BooleanFilter(name="name", label="Is City Null", lookup_expr="isnull") code = filters.CharFilter(name="code", label="City Code", lookup_expr='icontains') code_null = filters.BooleanFilter(name="code", label="Is City Null", lookup_expr="isnull") state_name = filters.CharFilter(name="state__name", label="State Name", lookup_expr='icontains') state_name_null = filters.BooleanFilter(name="state", label="Is State Null", lookup_expr="isnull") created_on = filters.IsoDateTimeFilter(name="created_on", label="Created on") created_between = filters.DateTimeFromToRangeFilter( name="created_on", label="Created Between") class Meta: model = City fields = []
class UltimateOracleFilter(filters.FilterSet): creator = filters.AllValuesMultipleFilter() creation_date_time = filters.DateTimeFromToRangeFilter() is_outcome_set = filters.BooleanFilter() forwarded_oracle_creator = filters.AllValuesMultipleFilter( name='forwarded_oracle__creator') forwarded_oracle_creation_date_time = filters.DateTimeFromToRangeFilter( name='forwarded_oracle__creation_date_time') forwarded_oracle_is_outcome_set = filters.BooleanFilter( name='forwarded_oracle__is_outcome_set') forwarded_oracle_factory = filters.AllValuesMultipleFilter( name='forwarded_oracle__factory') ordering = filters.OrderingFilter( fields=(('creation_date_time', 'creation_date_order'), ('forwarded_oracle__creation_date_time', 'forwarded_oracle_creation_date_order'))) class Meta: model = UltimateOracle fields = ('creator', 'creation_date_time', 'is_outcome_set', 'forwarded_oracle_creator', 'forwarded_oracle_creation_date_time', 'forwarded_oracle_is_outcome_set', 'forwarded_oracle_factory', 'ordering')
class ShiftingFilterSet(filters.FilterSet): status = CareChoiceFilter(choice_dict=inverse_shifting_status) breathlessness_level = CareChoiceFilter( choice_dict=inverse_breathlessness_level) disease_status = CareChoiceFilter(choice_dict=DISEASE_STATUS_DICT, field_name="patient__disease_status") facility = filters.UUIDFilter(field_name="facility__external_id") patient = filters.UUIDFilter(field_name="patient__external_id") patient_name = filters.CharFilter(field_name="patient__name", lookup_expr="icontains") patient_phone_number = filters.CharFilter( field_name="patient__phone_number", lookup_expr="icontains") orgin_facility = filters.UUIDFilter( field_name="orgin_facility__external_id") shifting_approving_facility = filters.UUIDFilter( field_name="shifting_approving_facility__external_id") assigned_facility = filters.UUIDFilter( field_name="assigned_facility__external_id") emergency = filters.BooleanFilter(field_name="emergency") is_up_shift = filters.BooleanFilter(field_name="is_up_shift") is_kasp = filters.BooleanFilter(field_name="is_kasp") created_date = filters.DateFromToRangeFilter(field_name="created_date") modified_date = filters.DateFromToRangeFilter(field_name="modified_date") assigned_to = filters.NumberFilter(field_name="assigned_to__id") created_by = filters.NumberFilter(field_name="created_by__id") last_edited_by = filters.NumberFilter(field_name="last_edited_by__id")
class PromotionFilter(filters.FilterSet): exclude_past_events = filters.BooleanFilter(method='filter_past_events', label=_('Show upcoming only')) usable_only = filters.BooleanFilter(method='filter_used_promotions', label=_('Show only usable promotions')) editable_only = filters.BooleanFilter(method='filter_editable', label=_('Show editable only')) def filter_past_events(self, queryset, name, value): is_filtering_requested = value date_is_before_today = Q(end_date__lt=datetime.date.today()) date_is_today_but_time_is_in_past = Q( end_date=datetime.date.today()) & Q( end_time__lt=datetime.datetime.now().time()) if is_filtering_requested: return queryset.exclude(date_is_before_today | date_is_today_but_time_is_in_past) else: return queryset def filter_used_promotions(self, queryset, name, value): is_filtering_requested = value if is_filtering_requested: return queryset.filter(available_count__gt=F('used_count')) return queryset def filter_editable(self, queryset, name, value): is_filtering_requested = value if not is_filtering_requested: return queryset if self.request.user.is_authenticated: return get_objects_for_user(self.request.user, 'change_promotion', self.queryset) else: return self.queryset.none()
class MembersFilter(filters.FilterSet): """ Filterset to filter members by skills, holiday and working hours """ skills = filters.BaseInFilter(field_name='skills__name') holidays = filters.BooleanFilter(method='filter_is_on_holidays') is_working = filters.BooleanFilter(method='filter_is_working') class Meta: model = Member fields = ( 'skills', 'project', 'holidays', 'is_working', ) def filter_is_on_holidays(self, queryset, name, value): if value: return queryset.filter(Q(on_holidays_till__isnull=False) | Q(on_holidays_till__gt=datetime.now())) return queryset.filter(Q(on_holidays_till__isnull=True) | Q(on_holidays_till__lt=datetime.now())) def filter_is_working(self, queryset, name, value): if value: return queryset.filter(Q(workhours__start__lt=datetime.now()) & Q(workhours__end__gt=datetime.now())) return queryset.filter(Q(workhours__start__gt=datetime.now()) | Q(workhours__end__lt=datetime.now()))
class InvoiceFilter(filters.FilterSet): unpaid_invoices = filters.BooleanFilter(method='filter_unpaid_invoices') last_invoice_only = filters.BooleanFilter(method='filter_last_invoice') product_name = filters.CharFilter(field_name='products__product__name', distinct=True, lookup_expr='istartswith') customer_name = filters.CharFilter(field_name='customer__name', distinct=True, lookup_expr='istartswith') class Meta: model = database.models.Invoice fields = { 'created': ['lte', 'gte'], 'date_of_sale': ['lte', 'gte'], 'credit': ['exact',], 'id': ['exact',], } def filter_unpaid_invoices(self, queryset, name, value): if value: queryset = queryset.filter(invoice_total__gt=Coalesce(F('payments_total'), 0.0)) return queryset def filter_last_invoice(self, queryset, name, value): if value: last_id = queryset.latest('id').id queryset = queryset.filter(id=last_id) return queryset
class BuildFilter(rest_filters.FilterSet): """ Custom filterset for BuildList API endpoint """ status = rest_filters.NumberFilter(label='Status') active = rest_filters.BooleanFilter(label='Build is active', method='filter_active') def filter_active(self, queryset, name, value): if str2bool(value): queryset = queryset.filter(status__in=BuildStatus.ACTIVE_CODES) else: queryset = queryset.exclude(status__in=BuildStatus.ACTIVE_CODES) return queryset overdue = rest_filters.BooleanFilter(label='Build is overdue', method='filter_overdue') def filter_overdue(self, queryset, name, value): if str2bool(value): queryset = queryset.filter(Build.OVERDUE_FILTER) else: queryset = queryset.exclude(Build.OVERDUE_FILTER) return queryset
class ShipmentFilter(filters.filterset.FilterSet): has_ship_from_location = filters.BooleanFilter( field_name='ship_from_location', lookup_expr='isnull', exclude=True) has_ship_to_location = filters.BooleanFilter(field_name='ship_to_location', lookup_expr='isnull', exclude=True) has_final_destination_location = filters.BooleanFilter( field_name='final_destination_location', lookup_expr='isnull', exclude=True) has_quickadd_tracking = filters.BooleanFilter( field_name='quickadd_tracking', lookup_expr='isnull', exclude=True) state = CustomMultipleChoiceFilter(method=filter_state, choices=SHIPMENT_STATE_CHOICES) exception = filters.CharFilter(method=filter_enum) gtx_validation = filters.CharFilter(method=filter_enum) assignee_id = filters.UUIDFilter(field_name='assignee_id') # Tag filter fields tag_type = filters.CharFilter(field_name='shipment_tags__tag_type', lookup_expr='icontains', distinct=True) tag_value = filters.CharFilter(field_name='shipment_tags__tag_value', lookup_expr='icontains', distinct=True) class Meta: model = Shipment fields = ( 'mode_of_transport_code', 'ship_from_location__name', 'ship_from_location__city', 'ship_from_location__address_1', 'ship_from_location__postal_code', 'ship_from_location__country', 'ship_to_location__name', 'ship_to_location__city', 'ship_to_location__state', 'ship_to_location__address_1', 'ship_to_location__postal_code', 'ship_to_location__country', 'final_destination_location__name', 'final_destination_location__city', 'ship_from_location', 'final_destination_location__state', 'final_destination_location__address_1', 'ship_to_location', 'final_destination_location__postal_code', 'final_destination_location__country', 'final_destination_location', 'ship_from_location__state', 'state', 'delayed', 'asset_physical_id', 'asset_custodian_id', 'quickadd_tracking', 'carrier_abbv', )
class SlotFilterSet(filters.FilterSet): computer = filters.UUIDFilter(field_name="computer__external_id") program = filters.UUIDFilter(field_name="computer__program__external_id") max_students = filters.NumberFilter(field_name="max_students", lookup_expr="lte") language = filters.CharFilter(field_name="language") is_mentor_assigned = filters.BooleanFilter(field_name="is_mentor_assigned") is_student_assigned = filters.BooleanFilter( field_name="is_student_assigned")
class OrganizationFilter(filters.FilterSet): """ Custom filters for a competition. """ external = filters.BooleanFilter(field_name='external') historical = filters.BooleanFilter(field_name='historical') class Meta: model = Organization fields = ['abbreviation', 'external', 'historical']