class PageFilter(filters.FilterSet):
nature = filters.MultipleChoiceFilter(choices=NATURE_CHOICES)
progress = filters.MultipleChoiceFilter(choices=PROGRESS_CHOICES)
class Meta:
model = Page
fields = ["nature", "progress"]
class MonsterFilter(filters.FilterSet):
name = filters.CharFilter(method='filter_name')
element = filters.MultipleChoiceFilter(choices=Monster.ELEMENT_CHOICES)
archetype = filters.MultipleChoiceFilter(choices=Monster.TYPE_CHOICES)
leader_skill_attribute = filters.MultipleChoiceFilter(
name='leader_skill__attribute', choices=LeaderSkill.ATTRIBUTE_CHOICES)
leader_skill_area = filters.MultipleChoiceFilter(
name='leader_skill__area', choices=LeaderSkill.AREA_CHOICES)
class Meta:
model = Monster
fields = {
'com2us_id': ['exact'],
'family_id': ['exact'],
'base_stars': ['lte', 'gte'],
'obtainable': ['exact'],
'is_awakened': ['exact'],
'fusion_food': ['exact'],
}
def filter_name(self, queryset, name, value):
if value:
return queryset.filter(name__istartswith=value)
else:
return queryset
class MonsterFilter(filters.FilterSet):
name = filters.CharFilter(method='filter_name')
element = filters.MultipleChoiceFilter(choices=Monster.ELEMENT_CHOICES)
archetype = filters.MultipleChoiceFilter(choices=Monster.TYPE_CHOICES)
leader_skill_attribute = filters.MultipleChoiceFilter(field_name='leader_skill__attribute', choices=LeaderSkill.ATTRIBUTE_CHOICES)
leader_skill_area = filters.MultipleChoiceFilter(field_name='leader_skill__area', choices=LeaderSkill.AREA_CHOICES)
order_by = filters.OrderingFilter(fields=[
'name', 'element', 'base_stars', 'archetype', 'com2us_id', 'family_id',
'raw_hp', 'raw_attack', 'raw_defense',
'base_hp', 'base_attack', 'base_defense',
'max_lvl_hp', 'max_lvl_attack', 'max_lvl_defense',
'speed', 'crit_rate', 'crit_damage', 'resistance', 'accuracy',
])
class Meta:
model = Monster
fields = {
'id': ['in'],
'com2us_id': ['exact'],
'family_id': ['exact'],
'base_stars': ['lte', 'gte'],
'obtainable': ['exact'],
'is_awakened': ['exact'],
'fusion_food': ['exact'],
'homunculus': ['exact'],
}
def filter_name(self, queryset, name, value):
if value:
return queryset.filter(name__istartswith=value)
else:
return queryset
class CoursePageFilter(filters.FilterSet):
lang_code = filters.MultipleChoiceFilter(name='lang_code', \
lookup_expr='exact', choices=settings.LANGUAGES, \
widget=forms.CheckboxSelectMultiple, initial='en', \
label=_('Language'))
keywords = filters.ModelMultipleChoiceFilter(
name='multilang_keywords',
queryset=MultilangKeyword.objects.all(),
widget=forms.CheckboxSelectMultiple,
label=_('Keywords'))
level = filters.MultipleChoiceFilter(name='level', \
lookup_expr='exact', choices=LEVELS, \
widget=forms.CheckboxSelectMultiple, \
label=_('Level'))
delivery_method = filters.MultipleChoiceFilter(name='delivery_format', \
lookup_expr='exact', choices=CoursePage.DELIVERY_FORMAT, \
widget=forms.CheckboxSelectMultiple, \
label=_('Delivery Method'))
o = filters.OrderingFilter(choices=(('title', _('Title')), ),
fields={
'title': 'title',
},
initial='title',
help_text='')
class Meta:
model = CoursePage
fields = {}
class InfoFilters(filters.FilterSet):
phone = filters.NumberFilter(field_name='house_info__phone',
lookup_expr='iexact')
id = filters.NumberFilter(field_name='house_info__house_id',
lookup_expr='iexact')
offer_type = filters.NumberFilter(field_name='offer_type')
date = filters.NumberFilter(field_name='parsing_time__days',
lookup_expr='lte')
min_price = filters.NumberFilter(field_name="price", lookup_expr='gte')
max_price = filters.NumberFilter(field_name="price", lookup_expr='lte')
num_of_rooms = filters.MultipleChoiceFilter(
choices=CHOICES,
field_name='house_info__num_of_rooms',
lookup_expr='icontains',
)
description = filters.CharFilter(field_name='data',
lookup_expr='icontains')
street = filters.CharFilter(field_name='address', lookup_expr='icontains')
type_house = filters.MultipleChoiceFilter(
choices=CHOICES_TYPE,
field_name='type',
lookup_expr='icontains',
)
max_floor = filters.NumberFilter(field_name='house_info__floor',
lookup_expr='lte')
min_floor = filters.NumberFilter(field_name='house_info__floor',
lookup_expr='gte')
max_floor_count = filters.NumberFilter(
field_name='house_info__floor_count', lookup_expr='lte')
min_floor_count = filters.NumberFilter(
field_name='house_info__floor_count', lookup_expr='gte')
min_area = filters.NumberFilter(field_name='house_info__total_area',
lookup_expr='gte')
max_area = filters.NumberFilter(field_name='house_info__total_area',
lookup_expr='lte')
min_kitchen_area = filters.NumberFilter(
field_name='house_info__kitchen_area', lookup_expr='gte')
max_kitchen_area = filters.NumberFilter(
field_name='house_info__kitchen_area', lookup_expr='lte')
min_living_area = filters.NumberFilter(
field_name='house_info__living_area', lookup_expr='gte')
max_living_area = filters.NumberFilter(
field_name='house_info__living_area', lookup_expr='lte')
min_land_area = filters.NumberFilter(field_name='house_info__land_area',
lookup_expr='gte')
max_land_area = filters.NumberFilter(field_name='house_info__land_area',
lookup_expr='lte')
class Meta:
model = HouseModel
fields = [
'min_price', 'street', 'max_price', 'num_of_rooms', 'max_floor',
'min_floor', 'min_area', 'max_area', 'max_floor_count',
'min_floor_count', 'id', 'phone', 'type_house', 'min_kitchen_area',
'max_kitchen_area', 'min_living_area', 'max_living_area',
'min_land_area', 'max_land_area', 'offer_type', 'date',
'description'
]
class DriverStopsFilter(filters.FilterSet):
agency = filters.ModelChoiceFilter(
queryset=models.Agency.objects.no_cache().all(),
label="Agency",
method="filter_agency",
required=True,
)
stop_date = filters.DateFromToRangeFilter(label="Stop date",
method="filter_stop_date")
gender = filters.MultipleChoiceFilter(choices=models.GENDER_CHOICES)
race = filters.MultipleChoiceFilter(choices=models.RACE_CHOICES)
ethnicity = filters.MultipleChoiceFilter(choices=models.ETHNICITY_CHOICES)
stop_officer_id = filters.CharFilter(label="Officer ID",
method="filter_officer")
stop_purpose = filters.MultipleChoiceFilter(label="Stop purpose",
choices=models.PURPOSE_CHOICES,
method="filter_stop_purpose")
stop_action = filters.MultipleChoiceFilter(label="Stop action",
choices=models.ACTION_CHOICES,
method="filter_stop_action")
def filter_agency(self, queryset, name, value):
return queryset.filter(stop__agency_id=value)
def filter_stop_date(self, queryset, name, value):
start_date = value.start
end_date = value.stop
query = Q()
if start_date:
query &= Q(stop__date__gte=start_date)
if end_date:
query &= Q(stop__date__lte=end_date)
return queryset.filter(query)
def filter_officer(self, queryset, name, value):
return queryset.filter(stop__officer_id=value)
def filter_stop_purpose(self, queryset, name, value):
return queryset.filter(stop__purpose__in=value)
def filter_stop_action(self, queryset, name, value):
return queryset.filter(stop__action__in=value)
class Meta:
model = models.Person
fields = (
"agency",
"stop_date",
"age",
"gender",
"race",
"ethnicity",
"stop_officer_id",
"stop_purpose",
"stop_action",
)
class StoreInventoryFilter(django_filters.FilterSet):
broadSizeCategory = filters.MultipleChoiceFilter(
label='',
choices=SIZE_CHOICES,
widget=forms.CheckboxSelectMultiple(attrs={
'onclick': 'this.form.submit()',
'class': 'hide'
}))
strSpecial = filters.MultipleChoiceFilter(
method='str_special_filter',
label='',
choices=SPECIALS_CHOICES,
widget=forms.CheckboxSelectMultiple(
attrs={'onclick': 'this.form.submit()'}))
# strSpecial = filters.MultipleChoiceFilter(label='', choices=SPECIALS_CHOICES, widget=forms.CheckboxSelectMultiple(attrs={'onclick':'this.form.submit()'}), exclude=True)
strUnitType = filters.MultipleChoiceFilter(
label='',
choices=CC_CHOICES,
widget=forms.CheckboxSelectMultiple(
attrs={'onclick': 'this.form.submit()'}))
ftruckrental = filters.MultipleChoiceFilter(
method='truck_rental_filter',
label='',
choices=FTR_CHOICES,
widget=forms.CheckboxSelectMultiple(
attrs={'onclick': 'this.form.submit()'}))
class Meta:
model = StoreInventory
fields = [
'broadSizeCategory', 'strSpecial', 'strUnitType', 'dblTtlAvail'
]
def str_special_filter(self, queryset, name, value):
return queryset.filter(
Q(strSpecial__exact='W') | Q(strSpecial__exact='X'))
def truck_rental_filter(self, queryset, name, value):
return queryset.filter(
Q(intprop__ftruckrental__exact='-1')
| Q(intprop__ftruckrentalss__exact='-1'))
@property
def dstnct(self):
test = super().qs
return test.values('intprop__storeid').order_by().annotate(
Count('intprop'),
Min('dblcurrentrate'),
Max('strSpecial'),
address=F('intprop__address'),
city=F('intprop__city'),
st=F('intprop__st'),
phone=F('intprop__phone'),
postalcode=F('intprop__postalcode'),
storenum=F('intprop__storeid')).exclude(dblTtlAvail__exact=0)
class EventFilterSet(filters.FilterSet):
category = filters.MultipleChoiceFilter(
method='filter_category',
label='Category',
choices=settings.EVENT_TYPE_CHOICES,
)
follow_type = filters.MultipleChoiceFilter(
method='filter_follow_type',
label='Follow Type',
choices=settings.EVENT_FOLLOW_MODE_CHOICES,
)
languages = filters.CharFilter(
method='filter_languages',
)
location = filters.CharFilter(
method='filter_location',
)
class Meta:
model = Event
fields = [
'category',
'follow_type',
'languages',
'location'
]
def filter_category(self, queryset, name, value):
query = Q()
for query_value in value:
query |= Q(category__code=query_value)
return queryset.filter(query)
def filter_follow_type(self, queryset, name, value):
query = Q()
for query_value in value:
query |= Q(follow_type__contains=query_value)
return queryset.filter(query)
def filter_languages(self, queryset, name, value):
query = Q()
for language in value.split(','):
query |= Q(languages__contains=[language])
return queryset.filter(query)
def filter_location(self, queryset, name, value):
query = Q()
for location in value.split(','):
query |= Q(location__icontains=location)
return queryset.filter(query)
class PerformanceMetricsFilter(FilterSet):
date_from = filters.DateFilter('date',
label='date from (YYYY-MM-DD)',
lookup_expr='gte')
date_to = filters.DateFilter('date',
label='date to (YYYY-MM-DD)',
lookup_expr='lte')
metrics = filters.MultipleChoiceFilter(label='metrics',
choices=METRICS_CHOICES,
method='filter_metrics')
group_by = filters.MultipleChoiceFilter(label='group by',
choices=GROUPING_CHOICES,
method='group_data')
class Meta:
model = PerformanceMetric
fields = (
'date_from',
'date_to',
'group_by',
'metrics',
)
def filter_metrics(self, queryset, name, value):
if not value:
return queryset
# Create list of metrics to include from 'value' argument
metrics_to_include = []
for i in value:
metrics_to_include.append(METRICS_CHOICES[int(i)][-1])
if hasattr(self, 'columns_to_group'):
return queryset.values(*self.columns_to_group, *metrics_to_include)
else:
return queryset.values(*metrics_to_include)
def group_data(self, queryset, name, value):
if not value:
return queryset
# Create list of columns to include from 'value' argument
self.columns_to_group = []
for i in value:
self.columns_to_group.append(GROUPING_CHOICES[int(i)][-1])
grouped_data = queryset.order_by().values(*self.columns_to_group).distinct() \
.annotate(impressions=Sum('impressions')) \
.annotate(clicks=Sum('clicks')) \
.annotate(installs=Sum('installs')) \
.annotate(spend=Sum('spend')) \
.annotate(revenue=Sum('revenue'))
return grouped_data
class EventFilterSet(filters.FilterSet):
# Filtering by country and importance level
importance = filters.MultipleChoiceFilter(field_name="importance",
label="filter by importance",
choices=[(i, i)
for i in range(1, 4)])
country = filters.MultipleChoiceFilter(field_name="country",
label="filter by country",
choices=Countries())
class Meta:
model = Event
fields = ["importance", "country"]
class PatientTransferFilter(filters.FilterSet):
icmr_id = filters.CharFilter(
field_name="from_patient_facility__patient__icmr_id",
lookup_expr="istartswith")
govt_id = filters.CharFilter(
field_name="from_patient_facility__patient__govt_id",
lookup_expr="istartswith")
patient_name = filters.CharFilter(
field_name="from_patient_facility__patient__name",
lookup_expr="istartswith")
gender = filters.MultipleChoiceFilter(
field_name="from_patient_facility__patient__gender",
choices=common_constants.GENDER_CHOICES,
)
year = filters.RangeFilter(
field_name="from_patient_facility__patient__year", lookup_expr="range")
month = filters.RangeFilter(
field_name="from_patient_facility__patient__month",
lookup_expr="range")
from_facility = filters.filters.ModelMultipleChoiceFilter(
field_name="from_patient_facility__facility",
queryset=facility_models.Facility.objects.all())
to_facility = filters.filters.ModelMultipleChoiceFilter(
field_name="to_facility",
queryset=facility_models.Facility.objects.all())
phone_number = filters.CharFilter(
field_name="from_patient_facility__patient__phone_number",
lookup_expr="istartswith")
requested_at = CustomDateTimeFromToRangeFilter(field_name="created_at")
status_updated_at = CustomDateTimeFromToRangeFilter(
field_name="status_updated_at")
status = filters.MultipleChoiceFilter(
field_name="status", choices=patient_constants.TRANSFER_STATUS_CHOICES)
class Meta:
model = patients_models.PatientTransfer
fields = (
"gender",
"year",
"month",
"from_facility",
"to_facility",
"requested_at",
"status_updated_at",
"status",
"icmr_id",
"govt_id",
"patient_name",
"phone_number",
)
class SetFilter(filters.FilterSet):
set_id = filters.CharFilter(
field_name='id',
lookup_expr='iexact',
distinct=True)
labeler = filters.CharFilter(
field_name='spls__labeler',
lookup_expr='icontains',
distinct=True)
package_ndc = filters.CharFilter(
field_name='spls__products__packages__code',
lookup_expr='icontains',
distinct=True)
product_ndc = filters.CharFilter(
field_name='spls__products__code',
lookup_expr='icontains',
distinct=True)
product_name = filters.CharFilter(
field_name='spls__products__name',
lookup_expr='icontains',
distinct=True)
inactive_ingredient_name = filters.CharFilter(
field_name='spls__products__inactive_ingredients__name',
lookup_expr='icontains',
distinct=True)
inactive_ingredient_unii = filters.CharFilter(
field_name='spls__products__inactive_ingredients__unii',
lookup_expr='icontains',
distinct=True)
schedule = filters.MultipleChoiceFilter(
field_name='spls__products__schedule',
choices=SCHEDULE_CHOICES,
distinct=True)
rxcui = filters.CharFilter(
field_name='rxnorms__rxcui',
lookup_expr='iexact',
distinct=True)
rxstring = filters.CharFilter(
field_name='rxnorms__rxstring',
lookup_expr='icontains',
distinct=True)
rxtty = filters.MultipleChoiceFilter(
field_name='rxnorms__rxtty',
choices=TTY_CHOICES,
distinct=True)
class Meta:
model = Set
fields = []
class FrameFilter(django_filters.FilterSet):
start = django_filters.DateTimeFilter(field_name='DATE_OBS', lookup_expr='gte')
end = django_filters.DateTimeFilter(field_name='DATE_OBS', lookup_expr='lte')
dayobs = django_filters.DateFilter(field_name='DAY_OBS', lookup_expr='iexact')
basename = django_filters.CharFilter(field_name='basename', lookup_expr='icontains')
OBJECT = django_filters.CharFilter(field_name='OBJECT', lookup_expr='icontains')
public = django_filters.BooleanFilter(field_name='public', method='public_filter')
EXPTIME = django_filters.NumberFilter(field_name='EXPTIME', lookup_expr='gte')
covers = django_filters.CharFilter(method='covers_filter')
exclude_OBSTYPE = django_filters.MultipleChoiceFilter(
field_name='OBSTYPE',
choices=Frame.OBSERVATION_TYPES,
label='Exclude Obstypes',
exclude=True
)
intersects = django_filters.CharFilter(method='intersects_filter')
def covers_filter(self, queryset, name, value):
geo = GEOSGeometry(value)
return queryset.filter(area__covers=geo)
def intersects_filter(self, queryset, name, value):
geo = GEOSGeometry(value)
return queryset.filter(area__intersects=geo)
def public_filter(self, queryset, name, value):
if not value:
return queryset.exclude(L1PUBDAT__lt=timezone.now())
return queryset
class Meta:
model = Frame
fields = ['DATE_OBS', 'DAY_OBS', 'PROPID', 'OBSTYPE', 'INSTRUME',
'RLEVEL', 'SITEID', 'TELID', 'FILTER', 'L1PUBDAT',
'BLKUID', 'REQNUM']
class JournalFilter(filters.FilterSet):
status = filters.MultipleChoiceFilter(choices=JournalStatus.choices)
orgs = CharListFilter(name='organization__key', lookup_expr='in')
class Meta:
model = Journal
fields = ('orgs', 'status',)
class DietaEspecialFilter(filters.FilterSet):
aluno = filters.CharFilter(field_name='aluno__uuid', lookup_expr='iexact')
nome_aluno = filters.CharFilter(field_name='aluno__nome',
lookup_expr='icontains')
nome_completo_aluno = filters.CharFilter(field_name='aluno__nome',
lookup_expr='iexact')
codigo_eol_aluno = filters.CharFilter(field_name='aluno__codigo_eol',
lookup_expr='iexact')
escola = filters.CharFilter(field_name='rastro_escola__uuid',
lookup_expr='iexact')
dre = filters.CharFilter(
field_name='rastro_escola__diretoria_regional__uuid',
lookup_expr='iexact')
cpf_responsavel = filters.CharFilter(field_name='aluno__responsaveis__cpf',
lookup_expr='iexact')
ativo = filters.BooleanFilter(field_name='ativo')
tipo_solicitacao = filters.CharFilter(field_name='tipo_solicitacao',
lookup_expr='iexact')
data_inicial = filters.DateFilter(field_name='criado_em',
lookup_expr='date__gte')
data_final = filters.DateFilter(field_name='criado_em',
lookup_expr='date__lte')
classificacao = filters.ModelMultipleChoiceFilter(
field_name='classificacao__id',
to_field_name='id',
queryset=ClassificacaoDieta.objects.all())
status = filters.MultipleChoiceFilter(
choices=[(str(state), state)
for state in DietaEspecialWorkflow.states])
class GuiaFilter(filters.FilterSet):
codigo_unidade = filters.CharFilter(
field_name='codigo_unidade',
lookup_expr='exact',
)
nome_unidade = filters.CharFilter(
field_name='nome_unidade',
lookup_expr='icontains',
)
numero_guia = filters.CharFilter(
field_name='numero_guia',
lookup_expr='exact',
)
numero_requisicao = filters.CharFilter(
field_name='solicitacao__numero_solicitacao',
lookup_expr='exact',
)
data_inicial = filters.DateFilter(
field_name='data_entrega',
lookup_expr='gte',
)
data_final = filters.DateFilter(
field_name='data_entrega',
lookup_expr='lte',
)
status = filters.MultipleChoiceFilter(
field_name='status',
choices=[(str(state), state) for state in GuiaRemessaWorkFlow.states],
)
class StayReservationFilter(FilterDefaultValuesMixin, filters.FilterSet):
# defaults = {'status': ['booked', 'confirmed']}
document_number = filters.NumberFilter('id')
reserved_from__gte = filters.DateFilter('reserved_from', 'gte')
reserved_to__lte = filters.DateFilter('reserved_to', 'lte')
reservation_number = filters.CharFilter('reservation_number', 'icontains')
contact_name = filters.CharFilter('contact_name', 'icontains')
contact_number = filters.CharFilter('contact_number', 'icontains')
contact_email = filters.CharFilter('contact_email', 'icontains')
status = filters.MultipleChoiceFilter('status',
choices=Reservation.STATUS.choices)
activities_ids = filters.CharFilter(method='activities_filter')
def activities_filter(self, queryset, name, value):
value = re.split(r'\s*,\s*', value) if isinstance(value,
str) else value
return queryset.filter(activities__id__in=value)
class Meta:
model = StayReservation
fields = [
'document_number', 'reserved_from', 'reserved_from__gte',
'tent_id', 'price', 'reserved_to', 'reserved_to__lte',
'stay_type_id', 'status', 'reservation_number', 'contact_name',
'contact_number', 'contact_email', 'company_id', 'guests_count',
'created_at', 'reservation_type', 'activities_ids'
]
class EventFilter(filters.FilterSet):
start_after = filters.DateFilter(name='start', lookup_expr='gte')
start_before = filters.DateFilter(name='start', lookup_expr='lte')
end_after = filters.DateFilter(name='end', lookup_expr='gte')
end_before = filters.DateFilter(name='end', lookup_expr='lte')
TAG_CHOICES = Tag.objects.all().values_list('name', 'name')
tag = filters.MultipleChoiceFilter(
choices=TAG_CHOICES,
name='tags',
method=filter_tag_by_name,
)
class Meta:
model = Event
fields = (
'completed',
'tag',
'start',
'start_before',
'start_after',
'end',
'end_before',
'end_after',
)
order_by = ('-slug', 'slug', 'start', '-start', 'end', '-end')
class FoodReservationFilter(FilterDefaultValuesMixin, filters.FilterSet):
# defaults = {'status': ['booked', 'confirmed']}
document_number = filters.NumberFilter('id')
reservation_date__lte = filters.DateFilter('reservation_date', 'lte')
reservation_date__gte = filters.DateFilter('reservation_date', 'gte')
reservation_number = filters.CharFilter('reservation_number', 'icontains')
contact_name = filters.CharFilter('contact_name', 'icontains')
contact_number = filters.CharFilter('contact_number', 'icontains')
contact_email = filters.CharFilter('contact_email', 'icontains')
company = filters.CharFilter('company__name', 'icontains')
status = filters.MultipleChoiceFilter('status',
choices=Reservation.STATUS.choices)
food_ids = filters.CharFilter(method='food_filter')
def food_filter(self, qs, name, value):
value = re.split(r'\s*,\s*', value) if isinstance(value,
str) else value
return qs.filter(food__id__in=value)
class Meta:
model = FoodReservation
fields = [
'document_number', 'reservation_date', 'reservation_date__gte',
'reservation_date__lte', 'status', 'reservation_number',
'contact_name', 'contact_number', 'contact_email', 'company',
'company_id', 'meal_type_id', 'food_ids', 'reservation_type',
'created_at', 'guests_count', 'price'
]
class AssignmentTypeFilter(filters.FilterSet):
# single filter
# topics = filters.CharFilter(lookup_expr='icontains')
# multiple choice filter
TOPIC_LIST = (
('device', 'device'),
('essential', 'essential'),
('common', 'common'),
('concept', 'concept'),
('person', 'person'),
('event', 'event'),
('text', 'text'),
)
# multiple choice filter
topics = filters.MultipleChoiceFilter(
field_name="topics",
lookup_expr='contains',
conjoined=True, # uses AND instead of OR
choices=TOPIC_LIST)
# assign model and field terms
class Meta:
model = AssignmentTypes
fields = ('title', 'verb', 'topics')
class SubmissionsFilter(filters.FilterSet):
round = RoundLabFilter(queryset=RoundsAndLabs.objects.all())
status = filters.MultipleChoiceFilter(choices=PHASES)
active = filters.BooleanFilter(method='filter_active', label='Active')
submit_date = filters.DateFromToRangeFilter(field_name='submit_time',
label='Submit date')
fund = filters.ModelMultipleChoiceFilter(
field_name='page',
label='fund',
queryset=Page.objects.type(FundType) | Page.objects.type(LabType))
class Meta:
model = ApplicationSubmission
fields = (
'status',
'round',
'active',
'submit_date',
'fund',
)
def filter_active(self, qs, name, value):
if value is None:
return qs
if value:
return qs.active()
else:
return qs.inactive()
class ProdutoFilter(filters.FilterSet):
uuid = filters.CharFilter(field_name='homologacoes__uuid',
lookup_expr='iexact')
nome_produto = filters.CharFilter(field_name='nome__unaccent',
lookup_expr='icontains')
data_inicial = filters.DateFilter(field_name='homologacoes__criado_em',
lookup_expr='date__gte')
data_final = filters.DateFilter(field_name='homologacoes__criado_em',
lookup_expr='date__lte')
nome_marca = filters.CharFilter(field_name='marca__nome__unaccent',
lookup_expr='icontains')
nome_fabricante = filters.CharFilter(
field_name='fabricante__nome__unaccent', lookup_expr='icontains')
nome_terceirizada = filters.CharFilter(
field_name='homologacoes__rastro_terceirizada__nome_fantasia',
lookup_expr='icontains')
aditivos = filters.CharFilter(field_name='aditivos',
method='filtra_aditivos')
status = filters.MultipleChoiceFilter(
field_name='homologacoes__status',
choices=[(str(state), state)
for state in HomologacaoProdutoWorkflow.states])
class Meta:
model = Produto
fields = [
'nome_produto', 'nome_marca', 'nome_fabricante',
'nome_terceirizada', 'data_inicial', 'data_final',
'tem_aditivos_alergenicos', 'eh_para_alunos_com_dieta'
]
def filtra_aditivos(self, qs, name, value):
filtro = cria_filtro_aditivos(value)
return qs.filter(filtro)
class RunFilter(filters.FilterSet):
"""
Provides useful filtering options for the
:class:`~django_analyses.models.run.Run` model.
"""
analysis = filters.ModelMultipleChoiceFilter(
"analysis_version__analysis",
queryset=ANALYSES_WITH_RUNS,
)
analysis_version = filters.ModelMultipleChoiceFilter(
"analysis_version", queryset=ANALYSIS_VERSIONS_WITH_RUNS)
status = filters.MultipleChoiceFilter(choices=RunStatus.choices())
start_time = filters.DateTimeFromToRangeFilter()
end_time = filters.DateTimeFromToRangeFilter()
if Subject:
subject = filters.NumberFilter(method="get_subject_runs",
label="By subject ID:",
required=False)
class Meta:
model = Run
fields = ("id", )
def get_subject_runs(self, queryset: QuerySet, name: str,
pk: int) -> QuerySet:
try:
subject = Subject.objects.get(id=pk)
except Subject.DoesNotExist:
pass
else:
return subject.query_run_set()
class SolicitacaoFilter(filters.FilterSet):
uuid = filters.CharFilter(
field_name='uuid',
lookup_expr='exact',
)
numero_requisicao = filters.CharFilter(
field_name='numero_solicitacao',
lookup_expr='exact',
)
nome_distribuidor = filters.CharFilter(
field_name='distribuidor__nome_fantasia',
lookup_expr='icontains',
)
data_inicial = filters.DateFilter(
field_name='guias__data_entrega',
lookup_expr='gte',
)
data_final = filters.DateFilter(
field_name='guias__data_entrega',
lookup_expr='lte',
)
numero_guia = filters.CharFilter(
field_name='guias__numero_guia',
lookup_expr='exact',
)
codigo_unidade = filters.CharFilter(
field_name='guias__codigo_unidade',
lookup_expr='exact',
)
nome_unidade = filters.CharFilter(
field_name='guias__nome_unidade__unaccent',
lookup_expr='icontains',
)
nome_produto = filters.CharFilter(
field_name='guias__alimentos__nome_alimento__unaccent',
lookup_expr='icontains',
)
status = filters.MultipleChoiceFilter(
field_name='status',
choices=[(str(state), state)
for state in SolicitacaoRemessaWorkFlow.states],
)
status_guia = filters.MultipleChoiceFilter(
field_name='guias__status',
choices=[(str(state), state) for state in GuiaRemessaWorkFlow.states],
)
class ChangeFilter(filters.FilterSet):
timestamp = filters.IsoDateTimeFromToRangeFilter()
action = filters.MultipleChoiceFilter(choices=Change.ACTION_CHOICES)
user = filters.CharFilter(field_name="user__username")
class Meta:
model = Change
fields = ["action", "user", "timestamp"]
class ActivityLogFilters(filters.FilterSet):
status = filters.MultipleChoiceFilter(
choices=models.ActivityLogModel.STATUS_CHOICES)
student = StudentFilter(queryset=StudentModel.objects.all())
class Meta:
model = models.ActivityLogModel
fields = ["activity", "grand_set", "group", "status", "student"]
class HobbyEventFilter(filters.FilterSet):
category = HierarchyModelMultipleChoiceFilter(
field_name='hobby__categories', queryset=HobbyCategory.objects.all(),
label=_('HobbyCategory id'),
)
ordering = NearestOrderingFilter(
fields=(
# (field name, param name)
('distance_to_point', 'nearest'),
),
field_labels={
'distance_to_point': _('Nearest'),
},
label=_('Ordering. Choices: `nearest`')
)
near_latitude = dummy_filter(filters.NumberFilter(label=_('Near latitude. This field is required when `nearest` ordering is used.')))
near_longitude = dummy_filter(filters.NumberFilter(label=_('Near longitude. This field is required when `nearest` ordering is used.')))
hobby = filters.ModelChoiceFilter(field_name='hobby', queryset=Hobby.objects.all(), label=_('Hobby id'))
start_date_from = filters.DateFilter(field_name='start_date', lookup_expr='gte',
label=_(f'Return results starting from given date (inclusive).'
f' Use ISO 8601 date format, eg. "2020-01-30".'))
start_date_to = filters.DateFilter(field_name='start_date', lookup_expr='lte',
label=_(f'Return results with starting date up to given date (inclusive).'
f' Use ISO 8601 date format, eg. "2020-01-30".'))
start_time_from = filters.TimeFilter(field_name='start_time', lookup_expr='gte',
label=_(f'Return results with starting time from given time (inclusive)'
f' Eg. "19:00".'))
start_time_to = filters.TimeFilter(field_name='start_time', lookup_expr='lte',
label=_(f'Return results with starting time up to given time (inclusive)'
f' Eg. "21:00".'))
start_weekday = filters.MultipleChoiceFilter(choices=HobbyEvent.DAY_OF_WEEK_CHOICES,
label=_(f'Return results with starting date in given weekday.'
f' Enter a number from 1 to 7. Use ISO 8601 weekdays:'
f' 1=Monday, 7=Sunday.'))
exclude_past_events = filters.BooleanFilter(method='filter_past_events', label=_('Show upcoming only'))
price_type = filters.CharFilter(method='filter_price_type', label=_('Filter HobbyEvents by price type'))
class Meta:
model = HobbyEvent
fields = ['category', 'hobby', 'start_date_from', 'start_date_to',
'start_time_from', 'start_time_to', 'start_weekday']
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_price_type(self, queryset, name, value):
value_in_price_type_choices = any(value == price_type for price_type, label in Hobby.PRICE_TYPE_CHOICES)
if value_in_price_type_choices:
queryset = queryset.filter(hobby__price_type=value)
return queryset
class UserFilter(filters.FilterSet):
position = filters.MultipleChoiceFilter(
choices=models.Profile.USER_TYPES,
field_name='profile__position',
label='Position'
)
class Meta:
model = User
fields = ['username', 'position']
class ProgramFilter(FilterSetMixin, filters.FilterSet):
marketable = filters.BooleanFilter(method='filter_marketable')
status = filters.MultipleChoiceFilter(choices=ProgramStatus.choices)
type = filters.CharFilter(field_name='type__translations__name_t', lookup_expr='iexact')
types = CharListFilter(field_name='type__slug', lookup_expr='in')
uuids = UUIDListFilter()
class Meta:
model = Program
fields = ('hidden', 'marketable', 'marketing_slug', 'status', 'type', 'types',)
class LabelingTaskFilterSet(filters.FilterSet):
name = filters.CharFilter(field_name='name', lookup_expr='icontains')
labeler = filters.CharFilter(field_name='labeler_name', lookup_expr='icontains', label='Labeler name contains')
dataset = filters.CharFilter(field_name='dataset', lookup_expr='icontains', label='Dataset path contains')
status = filters.MultipleChoiceFilter(
field_name='status',
choices=LabelingTask.STATUSES,
)
class Meta:
model = LabelingTask
fields = ('name', 'dataset', 'labeler', 'status')
