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']
