class WxUserFilter(filters.FilterSet):
nickname = filters.CharFilter(field_name='nickname',
lookup_expr='icontains')
province = filters.CharFilter(field_name='province',
lookup_expr='icontains')
city = filters.CharFilter(field_name='city', lookup_expr='icontains')
date_joined = filters.DateFromToRangeFilter(field_name='date_joined')
rebate_right = filters.CharFilter(method='rebate_right_filter')
bonus_right = filters.CharFilter(method='bonus_right_filter')
level = filters.CharFilter(field_name='level__level__title',
lookup_expr='icontains')
def rebate_right_filter(self, queryset, name, value):
if value == 'true':
return queryset.filter(rebate_right='true')
elif value == 'false':
return queryset.filter(rebate_right__in=['false', 'null'])
return queryset
def bonus_right_filter(self, queryset, name, value):
print(value)
if value == 'true':
return queryset.filter(bonus_right='true')
elif value == 'false':
return queryset.filter(bonus_right__in=['false', 'null'])
return queryset
class Meta:
model = WxUser
fields = {
'nickname': [],
'province': [],
'city': [],
'date_joined': [],
'testers': ['exact'],
'upload_perm': ['exact'],
'rebate_right': ['exact'],
'bonus_right': ['exact'],
'level': ['exact'],
}
class InstructorsOverTimeFilter(AMYFilterSet):
badges = filters.ModelMultipleChoiceFilter(
queryset=Badge.objects.instructor_badges(),
label='Badges',
)
country = filters.MultipleChoiceFilter(
choices=list(Countries()),
widget=Select2MultipleWidget,
help_text="Instructor's country",
)
date = filters.DateFromToRangeFilter(
label='Date range (from - to)',
help_text="Filters on award's date",
widget=filter_widgets.RangeWidget(attrs={"class": "dateinput"}),
)
class Meta:
model = Person
fields = [
'badges',
'country',
]
class TransactionGroupFilter(filters.FilterSet):
"""
date_before, date_after, money_min, money_max等をクエリパラメータに指定して検索する
max, min（以上・以下）どちらか片方だけでもOK / dateは一致検索もできる
"""
def get_hashed_pdf_url(self, queryset, name, value):
filename = value.split('.')[0]
return queryset.filter(
# containsとすることで、pdf名に被りがあっても、両方とも検索にヒットする
pdf__contains=hashlib.sha256(filename.encode()).hexdigest())
# （注意）django-filter==2.0から、引数にはnameではなく、field_nameを使う。
date = filters.DateFromToRangeFilter(field_name='date')
createdOn = filters.DateFilter(field_name='createdOn')
slipNum = filters.NumberFilter(field_name='slipNum')
department = filters.CharFilter(field_name='department')
currency = filters.CharFilter(field_name='currency')
pdf = filters.CharFilter(field_name='pdf', method='get_hashed_pdf_url')
class Meta:
model = TransactionGroup
fields = ['date', 'pdf', 'slipNum']
class PtGroupFilter(filters.FilterSet):
user = filters.CharFilter(field_name='user__nickname',
lookup_expr='icontains')
ptgroup_no = filters.CharFilter(field_name='ptgroup_no',
lookup_expr='icontains')
partake = filters.CharFilter(field_name='partake__nickname',
lookup_expr='icontains')
add_time = filters.DateFromToRangeFilter(field_name='add_time')
goods_name = filters.CharFilter(field_name='goods_name',
lookup_expr='icontains')
class Meta:
model = PtGroup
fields = {
'user': [],
'ptgroup_no': [],
'ptgoods': ['exact'],
'goods_name': [],
'status': ['exact'],
'add_time': [],
'partake': [],
'shop': ['exact'],
}
class ItemsFilter(filters.FilterSet):
order_sn = filters.CharFilter(label='订单号', field_name='order__order_sn', lookup_expr='contains')
user = filters.CharFilter(label='用户', field_name='order__user__nickname', lookup_expr='contains')
goods_name = filters.CharFilter(label='商品名', field_name='goods_backup__goods_name', lookup_expr='contains')
gtype_name = filters.CharFilter(label='规格名', field_name='goods_backup__gtype_name', lookup_expr='contains')
add_time = filters.DateFromToRangeFilter(label='创建时间', field_name='order__add_time')
order__shop = filters.NumberFilter(label='所属店铺', method='order_shop__filter')
def order_shop__filter(self, queryset, name, value):
return queryset.filter(Q(order__shop__id=value)|Q(order__entrust_shop__id=value))
class Meta:
model = Items
fields = {
'order_sn': [],
'user': [],
'send_type': ['exact'],
'order__shop': ['exact'],
'order__model_type': ['exact'],
'goods_name': [],
'gtype_name': [],
'add_time': [],
}
class WorkshopsOverTimeFilter(AMYFilterSet):
tags = filters.ModelMultipleChoiceFilter(
queryset=Tag.objects.all(),
label='Events with at least one of the following tags:',
widget=widgets.SelectMultiple(attrs=dict(size=13)),
)
country = filters.MultipleChoiceFilter(
choices=list(Countries()),
widget=Select2MultipleWidget,
)
start = filters.DateFromToRangeFilter(
label='Date range (from - to)',
help_text="Filters only on the 'Event.start' field",
widget=filter_widgets.RangeWidget(attrs={"class": "dateinput"}),
)
class Meta:
model = Event
fields = [
'tags',
'country',
'start',
]
class GoodsFilter(filters.FilterSet):
name = filters.CharFilter(field_name='name', lookup_expr='contains')
search = django_filters.CharFilter(label='搜索', method='search_filter')
date_time = filters.DateFromToRangeFilter(field_name='add_time')
status = filters.ChoiceFilter(label='商品状态',
method='status_filter',
choices=(('is_sell', '在售'), ('preview',
'预览'),
('not_enough', '库存不足'), ('not_sell',
'下架')))
def search_filter(self, queryset, name, value):
return queryset.filter(
Q(name__icontains=value) | Q(category__name__icontains=value)
| Q(goods_brief__icontains=value))
def status_filter(self, queryset, name, value):
status = list(Goods.status_dict.keys())[list(
Goods.status_dict.values()).index(value)]
return queryset.filter(status=status)
class Meta:
model = Goods
fields = {
'name': [],
'category': ['exact'],
'shop': ['exact'],
'status': ['exact'],
'search': ['exact'],
'date_time': [],
'is_template': ['exact'],
'model_type': ['exact'],
'groupbuy': ['exact'],
'recommendation': ['exact'],
'fictitious': ['exact'],
}
class UserFilterSet(filters.FilterSet):
first_name = filters.CharFilter(field_name="first_name",
lookup_expr="icontains")
last_name = filters.CharFilter(field_name="last_name",
lookup_expr="icontains")
username = filters.CharFilter(field_name="username",
lookup_expr="icontains")
phone_number = filters.CharFilter(field_name="phone_number",
lookup_expr="icontains")
last_login = filters.DateFromToRangeFilter(field_name="last_login")
def get_user_type(
self,
queryset,
field_name,
value,
):
if value:
if value in INVERSE_USER_TYPE:
return queryset.filter(user_type=INVERSE_USER_TYPE[value])
return queryset
user_type = filters.CharFilter(method="get_user_type",
field_name="user_type")
class SaleFilter(filters.FilterSet):
date = filters.DateFromToRangeFilter()
class Meta:
model = Sale
fields = ['rama', 'date', 'seller']
class SaleFilter(filters.FilterSet):
date = filters.DateFromToRangeFilter()
class Meta:
model = Sale
fields = '__all__'
class TransactionFilter(filters.FilterSet):
updated_at = filters.DateFromToRangeFilter()
class Meta:
model = Transaction
fields = ['updated_at']
class PatientFilter(filters.FilterSet):
name = filters.CharFilter(field_name="name", lookup_expr="istartswith")
icmr = filters.CharFilter(field_name="icmr_id", lookup_expr="istartswith")
govt = filters.CharFilter(field_name="govt_id", lookup_expr="istartswith")
gender = filters.MultipleChoiceFilter(
field_name="gender", choices=common_constants.GENDER_CHOICES)
year = filters.RangeFilter(field_name="year", lookup_expr="range")
month = filters.RangeFilter(field_name="month", lookup_expr="range")
contact = filters.CharFilter(field_name="phone_number",
lookup_expr="istartswith")
address = filters.CharFilter(field_name="address",
lookup_expr="istartswith")
district = filters.MultipleChoiceFilter(
field_name="district",
choices=accounts_models.District.objects.all().values_list(
"id", "name"),
)
cluster_group = filters.MultipleChoiceFilter(
field_name="cluster_group",
choices=patients_models.PatientGroup.objects.all().values_list(
"id", "name"),
)
covid_status = filters.MultipleChoiceFilter(
field_name="covid_status",
choices=patients_models.CovidStatus.objects.all().values_list(
"id", "name"),
)
clinical_status = filters.MultipleChoiceFilter(
field_name="clinical_status",
choices=patients_models.ClinicalStatus.objects.all().values_list(
"id", "name"),
)
clinical_status_updated_at = filters.DateFromToRangeFilter(
field_name="clinical_status_updated_at")
facility = filters.ModelMultipleChoiceFilter(
field_name="patientfacility__facility",
queryset=facility_models.Facility.objects.all())
portea_called_at = filters.DateFromToRangeFilter(
field_name="portea_called_at")
portea_able_to_connect = filters.BooleanFilter(
field_name="portea_able_to_connect")
facility_district = filters.ModelMultipleChoiceFilter(
field_name="patientfacility__facility__district",
queryset=accounts_models.District.objects.all())
facility_type = filters.ModelMultipleChoiceFilter(
field_name="patientfacility__facility__facility_type",
queryset=facility_models.FacilityType.objects.all())
ownership_type = filters.ModelMultipleChoiceFilter(
field_name="patientfacility__facility__owned_by",
queryset=commons_models.OwnershipType.objects.all())
patient_status = filters.MultipleChoiceFilter(
field_name="patient_status",
choices=patient_constants.PATIENT_STATUS_CHOICES,
)
def filter_queryset(self, queryset):
qs = super().filter_queryset(queryset)
# TODO Move below annotate to view
return qs.annotate(
facility_status=F("patientfacility__patient_status__name"),
facility=F("patientfacility__facility__name"),
facility_type=F("patientfacility__facility__facility_type__name"),
ownership_type=F("patientfacility__facility__owned_by__name"),
facility_district=F("patientfacility__facility__district__name"),
)
def filter_patient_status(self, queryset, name, value):
if value:
return queryset.filter(
Q(current_facility__patient_status__name=value)
| Q(patient_status=value))
return queryset
class Meta:
model = patients_models.Patient
fields = (
"name",
"icmr",
"govt",
"gender",
"year",
"month",
"contact",
"address",
"district",
"cluster_group",
"covid_status",
"patient_status",
"clinical_status",
"clinical_status_updated_at",
"portea_called_at",
"portea_able_to_connect",
"facility",
"facility_district",
"facility_type",
"ownership_type",
)
class LeaderboardFilter(filters.FilterSet):
posted = filters.DateFromToRangeFilter(field_name='date')
class HistoricalCompanyRelatedFilterSet(filters.FilterSet):
history_date = filters.DateFromToRangeFilter()
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")
date_declared_positive = filters.DateFromToRangeFilter(
field_name="date_declared_positive")
date_of_result = filters.DateFromToRangeFilter(field_name="date_of_result")
last_vaccinated_date = filters.DateFromToRangeFilter(
field_name="last_vaccinated_date")
# 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")
division = filters.NumberFilter(field_name="district__division__id")
division_name = filters.CharFilter(field_name="district__division__name",
lookup_expr="icontains")
state = filters.NumberFilter(field_name="state__id")
state_name = filters.CharFilter(field_name="state__name",
lookup_expr="icontains")
# Consultation Fields
is_kasp = filters.BooleanFilter(field_name="last_consultation__is_kasp")
last_consultation_kasp_enabled_date = filters.DateFromToRangeFilter(
field_name="last_consultation__kasp_enabled_date")
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_symptoms_onset_date = filters.DateFromToRangeFilter(
field_name="last_consultation__symptoms_onset_date")
last_consultation_admitted_to_list = MultiSelectFilter(
field_name="last_consultation__admitted_to")
last_consultation_admitted_to = filters.NumberFilter(
field_name="last_consultation__admitted_to")
last_consultation_assigned_to = filters.NumberFilter(
field_name="last_consultation__assigned_to")
last_consultation_is_telemedicine = filters.BooleanFilter(
field_name="last_consultation__is_telemedicine")
# Vaccination Filters
covin_id = filters.CharFilter(field_name="covin_id")
is_vaccinated = filters.BooleanFilter(field_name="is_vaccinated")
number_of_doses = filters.NumberFilter(field_name="number_of_doses")
# Permission Filters
assigned_to = filters.NumberFilter(field_name="assigned_to")
class OrderFilter(filters.FilterSet):
status = filters.CharFilter(lookup_expr='exact')
summary = filters.RangeFilter()
created_at = filters.DateFromToRangeFilter(lookup_expr='exact')
updated_at = filters.DateFromToRangeFilter(lookup_expr='exact')
class WellListFilter(AnyOrAllFilterSet):
well = filters.CharFilter(method='filter_well_tag_or_plate',
label='Well tag or identification plate number')
street_address_or_city = filters.CharFilter(
method='filter_street_address_or_city', label='Street address or city')
owner_full_name = filters.CharFilter(lookup_expr='icontains')
legal = filters.CharFilter(
method='filter_combined_legal',
label='Legal lot, District legal lot, Legal plan or Legal PID')
date_of_work = filters.DateFromToRangeFilter(method='filter_date_of_work',
label='Date of work')
well_depth = filters.RangeFilter(method='filter_well_depth',
label='Well depth (finished or total)')
filter_pack_range = filters.RangeFilter(method='filter_filter_pack_range',
label='Filter pack from/to range')
liner_range = filters.RangeFilter(method='filter_liner_range',
label='Liner range')
# Don't require a choice (i.e. select box) for aquifer
aquifer = filters.NumberFilter()
street_address = filters.CharFilter(lookup_expr='icontains')
city = filters.CharFilter(lookup_expr='icontains')
well_location_description = filters.CharFilter(lookup_expr='icontains')
construction_start_date = filters.DateFromToRangeFilter()
construction_end_date = filters.DateFromToRangeFilter(
label='Construction End Date')
alteration_start_date = filters.DateFromToRangeFilter()
alteration_end_date = filters.DateFromToRangeFilter(
label='Alteration End Date')
decommission_start_date = filters.DateFromToRangeFilter()
decommission_end_date = filters.DateFromToRangeFilter()
well_identification_plate_attached = filters.CharFilter(
lookup_expr='icontains')
water_supply_system_name = filters.CharFilter(lookup_expr='icontains')
water_supply_system_well_name = filters.CharFilter(lookup_expr='icontains')
driller_name = filters.CharFilter(lookup_expr='icontains')
drilling_methods = filters.ModelChoiceFilter(
queryset=DrillingMethodCode.objects.all())
consultant_name = filters.CharFilter(lookup_expr='icontains')
consultant_company = filters.CharFilter(lookup_expr='icontains')
ground_elevation = filters.RangeFilter()
surface_seal_length = filters.RangeFilter()
surface_seal_thickness = filters.RangeFilter()
surface_seal_depth = filters.RangeFilter()
backfill_type = filters.CharFilter(lookup_expr='icontains')
backfill_depth = filters.RangeFilter()
liner_diameter = filters.RangeFilter()
liner_thickness = filters.RangeFilter()
liner_from = filters.RangeFilter()
liner_to = filters.RangeFilter()
other_screen_material = filters.CharFilter(lookup_expr='icontains')
other_screen_bottom = filters.CharFilter(lookup_expr='icontains')
screen_information = filters.CharFilter(lookup_expr='icontains')
filter_pack_from = filters.RangeFilter()
filter_pack_to = filters.RangeFilter()
filter_pack_thickness = filters.RangeFilter()
development_methods = filters.ModelChoiceFilter(
queryset=DevelopmentMethodCode.objects.all())
development_hours = filters.RangeFilter()
development_notes = filters.CharFilter(lookup_expr='icontains')
yield_estimation_rate = filters.RangeFilter()
yield_estimation_duration = filters.RangeFilter()
static_level_before_test = filters.RangeFilter()
drawdown = filters.RangeFilter()
hydro_fracturing_yield_increase = filters.RangeFilter()
recommended_pump_depth = filters.RangeFilter()
recommended_pump_rate = filters.RangeFilter()
water_quality_characteristics = filters.ModelChoiceFilter(
queryset=WaterQualityCharacteristic.objects.all())
water_quality_colour = filters.CharFilter(lookup_expr='icontains')
water_quality_odour = filters.CharFilter(lookup_expr='icontains')
well_yield = filters.RangeFilter()
observation_well_number = filters.CharFilter(lookup_expr='icontains')
observation_well_number_has_value = filters.BooleanFilter(
field_name='observation_well_number',
method='filter_has_value',
label='Any value for observation well number')
utm_northing = filters.RangeFilter()
utm_easting = filters.RangeFilter()
decommission_reason = filters.CharFilter(lookup_expr='icontains')
decommission_sealant_material = filters.CharFilter(lookup_expr='icontains')
decommission_backfill_material = filters.CharFilter(
lookup_expr='icontains')
decommission_details = filters.CharFilter(lookup_expr='icontains')
aquifer_vulnerability_index = filters.RangeFilter()
storativity = filters.RangeFilter()
transmissivity = filters.RangeFilter()
hydraulic_conductivity = filters.CharFilter(lookup_expr='icontains')
specific_storage = filters.CharFilter(lookup_expr='icontains')
specific_yield = filters.RangeFilter()
testing_method = filters.CharFilter(lookup_expr='icontains')
testing_duration = filters.RangeFilter()
analytic_solution_type = filters.RangeFilter()
boundary_effect = filters.RangeFilter()
final_casing_stick_up = filters.RangeFilter()
bedrock_depth = filters.RangeFilter()
static_water_level = filters.RangeFilter()
artesian_flow = filters.RangeFilter()
artesian_flow_has_value = filters.BooleanFilter(
field_name='artesian_flow',
method='filter_has_value',
label='Any value for artesian flow')
artesian_pressure = filters.RangeFilter()
artesian_pressure_has_value = filters.BooleanFilter(
field_name='artesian_pressure',
method='filter_has_value',
label='Any value for artesian pressure')
well_cap_type = filters.CharFilter(lookup_expr='icontains')
comments = filters.CharFilter(lookup_expr='icontains')
ems_has_value = filters.BooleanFilter(field_name='ems',
method='filter_has_value',
label='Any value for EMS id')
class Meta:
model = Well
fields = [
'alteration_end_date',
'alteration_start_date',
'alternative_specs_submitted',
'analytic_solution_type',
'aquifer',
'aquifer_lithology',
'aquifer_vulnerability_index',
'artesian_flow',
'artesian_pressure',
'backfill_depth',
'backfill_type',
'bcgs_id',
'bedrock_depth',
'boundary_effect',
'city',
'comments',
'company_of_person_responsible',
'construction_end_date',
'construction_start_date',
'coordinate_acquisition_code',
'date_of_work',
'decommission_backfill_material',
'decommission_details',
'decommission_end_date',
'decommission_method',
'decommission_reason',
'decommission_sealant_material',
'decommission_start_date',
'development_hours',
'development_methods',
'development_notes',
'diameter',
'drawdown',
'driller_name',
'drilling_company',
'drilling_methods',
'ems',
'filter_pack_from',
'filter_pack_material',
'filter_pack_material_size',
'filter_pack_thickness',
'filter_pack_to',
'final_casing_stick_up',
'finished_well_depth',
'ground_elevation',
'ground_elevation_method',
'hydraulic_conductivity',
'hydro_fracturing_performed',
'hydro_fracturing_yield_increase',
'id_plate_attached_by',
'identification_plate_number',
'intended_water_use',
'land_district',
'legal',
'legal_block',
'legal_district_lot',
'legal_lot',
'legal_pid',
'legal_plan',
'legal_range',
'legal_section',
'legal_township',
'licenced_status',
'liner_diameter',
'liner_from',
'liner_material',
'liner_thickness',
'liner_to',
'observation_well_number',
'observation_well_status',
'other_screen_bottom',
'other_screen_material',
'owner_full_name',
'person_responsible',
'recommended_pump_depth',
'recommended_pump_rate',
'screen_bottom',
'screen_information',
'screen_intake_method',
'screen_material',
'screen_opening',
'screen_type',
'specific_storage',
'specific_yield',
'static_level_before_test',
'static_water_level',
'storativity',
'street_address',
'street_address_or_city',
'surface_seal_depth',
'surface_seal_length',
'surface_seal_material',
'surface_seal_method',
'surface_seal_thickness',
'testing_duration',
'testing_method',
'total_depth_drilled',
'transmissivity',
'utm_easting',
'utm_northing',
'utm_zone_code',
'water_quality_characteristics',
'water_quality_colour',
'water_quality_odour',
'water_supply_system_name',
'water_supply_system_well_name',
'well',
'well_cap_type',
'well_class',
'well_depth',
'well_disinfected',
'well_identification_plate_attached',
'well_location_description',
'well_orientation',
'well_status',
'well_subclass',
'well_tag_number',
'well_yield',
'well_yield_unit',
'yield_estimation_duration',
'yield_estimation_method',
'yield_estimation_rate',
]
def filter_well_tag_or_plate(self, queryset, name, value):
return queryset.filter(
Q(well_tag_number=value) | Q(identification_plate_number=value))
def filter_street_address_or_city(self, queryset, name, value):
return queryset.filter(
Q(street_address__icontains=value) | Q(city__icontains=value))
def filter_combined_legal(self, queryset, name, value):
lookups = (Q(legal_lot=value) | Q(legal_plan=value)
| Q(legal_district_lot=value))
# Check if we have a positive integer before querying the
# legal_pid field.
try:
int_value = int(value)
except (TypeError, ValueError):
pass
else:
if int_value >= 0:
lookups = lookups | Q(legal_pid=int_value)
return queryset.filter(lookups)
def filter_date_of_work(self, queryset, name, value):
if value.start is not None and value.stop is not None:
range_dates = (value.start.date(), value.stop.date())
queryset = queryset.filter(
Q(construction_start_date__range=range_dates)
| Q(construction_end_date__range=range_dates)
| Q(alteration_start_date__range=range_dates)
| Q(alteration_end_date__range=range_dates)
| Q(decommission_start_date__range=range_dates)
| Q(decommission_end_date__range=range_dates))
elif value.start is not None:
after_date = value.start.date()
queryset = queryset.filter(
Q(construction_start_date__gte=after_date)
| Q(construction_end_date__gte=after_date)
| Q(alteration_start_date__gte=after_date)
| Q(alteration_end_date__gte=after_date)
| Q(decommission_start_date__gte=after_date)
| Q(decommission_end_date__gte=after_date))
elif value.stop is not None:
before_date = value.stop.date()
queryset = queryset.filter(
Q(construction_start_date__lte=before_date)
| Q(construction_end_date__lte=before_date)
| Q(alteration_start_date__lte=before_date)
| Q(alteration_end_date__lte=before_date)
| Q(decommission_start_date__lte=before_date)
| Q(decommission_end_date__lte=before_date))
return queryset
def filter_well_depth(self, queryset, name, value):
if value.start is not None and value.stop is not None:
queryset = queryset.filter(
Q(finished_well_depth__range=(value.start, value.stop))
| Q(total_depth_drilled__range=(value.start, value.stop)))
elif value.start is not None:
queryset = queryset.filter(
Q(finished_well_depth__gte=value.start)
| Q(total_depth_drilled__gte=value.start))
elif value.stop is not None:
queryset = queryset.filter(
Q(finished_well_depth__lte=value.stop)
| Q(total_depth_drilled__lte=value.stop))
return queryset
def filter_filter_pack_range(self, queryset, name, value):
if value.start is not None and value.stop is not None:
queryset = queryset.filter(
Q(filter_pack_from__range=(value.start, value.stop))
| Q(filter_pack_to__range=(value.start, value.stop)))
elif value.start is not None:
queryset = queryset.filter(
Q(filter_pack_from__gte=value.start)
| Q(filter_pack_to__gte=value.start))
elif value.stop is not None:
queryset = queryset.filter(
Q(filter_pack_from__lte=value.stop)
| Q(filter_pack_to__lte=value.stop))
return queryset
def filter_liner_range(self, queryset, name, value):
if value.start is not None and value.stop is not None:
queryset = queryset.filter(
Q(liner_from__range=(value.start, value.stop))
| Q(liner_to__range=(value.start, value.stop)))
elif value.start is not None:
queryset = queryset.filter(
Q(liner_from__gte=value.start) | Q(liner_to__gte=value.start))
elif value.stop is not None:
queryset = queryset.filter(
Q(liner_from__lte=value.stop) | Q(liner_to__lte=value.stop))
return queryset
def filter_has_value(self, queryset, name, value):
if value:
lookup = '__'.join([name, 'isnull'])
return queryset.filter(**{lookup: False})
return queryset
class BaseFilter(filters.FilterSet):
create_time = filters.DateFromToRangeFilter(field_name='create_time')
update_time = filters.DateFromToRangeFilter(field_name='update_time')
class EmployeeFilter(filters.FilterSet):
max_date = filters.DateFromToRangeFilter(field_name='occurrences__in_time')
class Meta:
model = Employee
fields = ['name', 'max_date']
class SpecimenFilter(PropertyFilterSet):
"""
標本情報のフィルタセット
"""
date_identified = filters.DateFromToRangeFilter()
date_last_modified = filters.DateFromToRangeFilter()
collection_code = filters.NumberFilter(lookup_expr='exact')
collection_code_range = filters.RangeFilter(field_name='collection_code')
kingdom = PropertyCharFilter(field_name='kingdom', lookup_expr='icontains')
phylum = PropertyCharFilter(field_name='phylum', lookup_expr='icontains')
class_name = PropertyCharFilter(field_name='class_name',
lookup_expr='icontains')
order = PropertyCharFilter(field_name='order', lookup_expr='icontains')
suborder = PropertyCharFilter(field_name='suborder',
lookup_expr='icontains')
family = PropertyCharFilter(field_name='family', lookup_expr='icontains')
subfamily = PropertyCharFilter(field_name='subfamily',
lookup_expr='icontains')
tribe = PropertyCharFilter(field_name='tribe', lookup_expr='icontains')
subtribe = PropertyCharFilter(field_name='subtribe',
lookup_expr='icontains')
genus = PropertyCharFilter(field_name='genus', lookup_expr='icontains')
subgenus = PropertyCharFilter(field_name='subgenus',
lookup_expr='icontains')
species = PropertyCharFilter(field_name='species', lookup_expr='icontains')
subspecies = PropertyCharFilter(field_name='subspecies',
lookup_expr='icontains')
scientific_name_author = PropertyCharFilter(
field_name='scientific_name_author', lookup_expr='icontains')
name_publishedin_year = PropertyRangeFilter(
field_name='name_publishedin_year', lookup_expr='range')
actual_dist_year = PropertyRangeFilter(field_name='actual_dist_year',
lookup_expr='range')
japanese_name = PropertyCharFilter(field_name='japanese_name',
lookup_expr='icontains')
change_genus_brackets = PropertyBooleanFilter(
field_name='change_genus_brackets')
unknown_author_brackets = PropertyBooleanFilter(
field_name='unknown_author_brackets')
unknown_name_publishedin_year_brackets = PropertyBooleanFilter(
field_name='unknown_name_publishedin_year_brackets')
class Meta:
model = Specimen
fields = [
'default_taxon_info__kingdom', 'default_taxon_info__phylum',
'default_taxon_info__class_name', 'default_taxon_info__order',
'default_taxon_info__suborder', 'default_taxon_info__family',
'default_taxon_info__subfamily', 'default_taxon_info__tribe',
'default_taxon_info__subtribe', 'default_taxon_info__genus',
'default_taxon_info__subgenus', 'default_taxon_info__species',
'default_taxon_info__subspecies',
'default_taxon_info__scientific_name_author',
'default_taxon_info__name_publishedin_year',
'default_taxon_info__actual_dist_year',
'default_taxon_info__change_genus_brackets',
'default_taxon_info__unknown_author_brackets',
'default_taxon_info__unknown_name_publishedin_year_brackets',
'default_taxon_info__japanese_name',
'default_taxon_info__distribution', 'default_taxon_info__note',
'custom_taxon_info__kingdom', 'custom_taxon_info__phylum',
'custom_taxon_info__class_name', 'custom_taxon_info__order',
'custom_taxon_info__suborder', 'custom_taxon_info__family',
'custom_taxon_info__subfamily', 'custom_taxon_info__tribe',
'custom_taxon_info__subtribe', 'custom_taxon_info__genus',
'custom_taxon_info__subgenus', 'custom_taxon_info__species',
'custom_taxon_info__subspecies',
'custom_taxon_info__scientific_name_author',
'custom_taxon_info__name_publishedin_year',
'custom_taxon_info__actual_dist_year',
'custom_taxon_info__change_genus_brackets',
'custom_taxon_info__unknown_author_brackets',
'custom_taxon_info__unknown_name_publishedin_year_brackets',
'custom_taxon_info__japanese_name',
'custom_taxon_info__distribution', 'custom_taxon_info__note',
'collect_point_info__contient', 'collect_point_info__island_group',
'collect_point_info__island', 'collect_point_info__country',
'collect_point_info__state_provice', 'collect_point_info__county',
'collect_point_info__municipality',
'collect_point_info__verbatim_locality',
'collect_point_info__japanese_place_name',
'collect_point_info__japanese_place_name_detail',
'collect_point_info__coordinate_precision',
'collect_point_info__minimum_elevation',
'collect_point_info__maximum_elevation',
'collect_point_info__minimum_depth',
'collect_point_info__maximum_depth', 'collect_point_info__note',
'tour__title', 'collection_settings_info__collection_name',
'collection_settings_info__institution_code', 'collection_code',
'identified_by', 'date_identified', 'collecter', 'year', 'month',
'day', 'sex', 'preparation_type', 'disposition',
'sampling_protocol', 'sampling_effort', 'lifestage',
'establishment_means', 'rights', 'note', 'kingdom', 'phylum',
'class_name', 'order', 'suborder', 'family', 'subfamily', 'tribe',
'subtribe', 'genus', 'subgenus', 'species', 'subspecies',
'scientific_name_author', 'name_publishedin_year',
'actual_dist_year', 'allow_kojin_shuzo', 'published_kojin_shuzo',
'japanese_name', 'change_genus_brackets',
'unknown_author_brackets',
'unknown_name_publishedin_year_brackets', 'date_last_modified'
]
property_fields = [
('collect_point_info__longitude', PropertyRangeFilter, ['range']),
('collect_point_info__latitude', PropertyRangeFilter, ['range']),
]
filter_overrides = {
models.CharField: {
'filter_class': filters.CharFilter,
'extra': lambda f: {
'lookup_expr': 'icontains',
},
},
models.TextField: {
'filter_class': filters.CharFilter,
'extra': lambda f: {
'lookup_expr': 'icontains',
},
},
models.IntegerField: {
'filter_class': filters.RangeFilter,
},
models.FloatField: {
'filter_class': filters.RangeFilter,
},
models.DateField: {
'filter_class': filters.DateFromToRangeFilter,
},
models.DateTimeField: {
'filter_class': filters.DateFromToRangeFilter,
},
models.BooleanField: {
'filter_class': filters.BooleanFilter,
}
}
class RequirementFilter(filters.FilterSet):
REQ_STATUS = (
('open', 'Open'),
('cancelled', 'Cancelled'),
('fulfilled', 'Fulfilled'),
('unverified', 'Unverified'),
('lapsed', 'Lapsed'),
)
id = filters.NumberFilter(name="id", label="ID", lookup_expr="exact")
id_range = filters.RangeFilter(name="id", label="ID Between")
client = filters.CharFilter(name="client__name__username", label=" Client", lookup_expr='icontains')
client_null = filters.BooleanFilter(name="client", label="Is Client Null", lookup_expr="isnull")
from_shipment_date = filters.DateFilter(field_name="from_shipment_date", label="from_shipment_date")
from_shipment_date_between = filters.DateFromToRangeFilter(field_name="from_shipment_date",
label="from_shipment_date Between")
from_shipment_date_null = filters.BooleanFilter(field_name="from_shipment_date", label="Is from_shipment_date Null",
lookup_expr="isnull")
to_shipment_date = filters.DateFilter(field_name="to_shipment_date", label="to_shipment_date")
to_shipment_date_between = filters.DateFromToRangeFilter(field_name="to_shipment_date",
label="to_shipment_date Between")
to_shipment_date_null = filters.BooleanFilter(field_name="to_shipment_date", label="Is to_shipment_date Null",
lookup_expr="isnull")
from_city = filters.CharFilter(field_name="from_city__name", label="From City", lookup_expr="icontains")
from_city_null = filters.BooleanFilter(field_name="from_city", label="Is From City Null",
lookup_expr="isnull")
to_city = filters.CharFilter(field_name="to_city__name", label="to_city", lookup_expr="icontains")
to_city_null = filters.BooleanFilter(field_name="to_city", label="Is to_city Null", lookup_expr="isnull")
aaho_office = filters.CharFilter(name="aaho_office__branch_name", label="Aaho Office", lookup_expr='icontains')
aaho_office_id = filters.NumberFilter(name="aaho_office__id", label="Aaho Office ID", lookup_expr='exact')
aaho_office_null = filters.BooleanFilter(name="aaho_office", label="Is Aaho Office Null", lookup_expr="isnull")
tonnage = filters.NumberFilter(field_name="tonnage", label="tonnage")
tonnage_range = filters.NumericRangeFilter(field_name="tonnage", label="tonnage_Range")
tonnage_null = filters.BooleanFilter(field_name="tonnage", label="Is tonnage Null", lookup_expr="isnull")
no_of_vehicles = filters.NumberFilter(field_name="no_of_vehicles", label="no_of_vehicles")
no_of_vehicles_range = filters.NumericRangeFilter(field_name="no_of_vehicles", label="no_of_vehicles_Range")
no_of_vehicles_null = filters.BooleanFilter(field_name="no_of_vehicles", label="Is no_of_vehicles Null",
lookup_expr="isnull")
rate = filters.NumberFilter(field_name="rate", label="rate")
rate_range = filters.NumericRangeFilter(field_name="rate", label="rate_Range")
rate_null = filters.BooleanFilter(field_name="rate", label="Is rate Null", lookup_expr="isnull")
material = filters.CharFilter(name="material", label="Material", lookup_expr='icontains')
material_null = filters.BooleanFilter(name="material", label="Is Material Null",
lookup_expr="isnull")
type_of_vehicle = filters.CharFilter(name="type_of_vehicle__vehicle_type", label="Vehicle Type",
lookup_expr='icontains')
type_of_vehicle_null = filters.BooleanFilter(name="type_of_vehicle", label="Is Vehicle Type Null",
lookup_expr="isnull")
status = filters.ChoiceFilter(name="req_status", label="Req Status", choices=REQ_STATUS)
req_status_null = filters.BooleanFilter(name="req_status", label="Is Req Status Null", lookup_expr="isnull")
created_by = filters.CharFilter(name="created_by__username", label="Created By name", lookup_expr="icontains")
created_by_null = filters.BooleanFilter(name="created_by", label="Is Created By Null", lookup_expr="isnull")
created_on = filters.IsoDateTimeFilter(name="created_on", label="Created on")
created_between = filters.DateTimeFromToRangeFilter(field_name="created_on", label="Created Between")
class Meta:
model = Requirement
fields = []
class ExpensesFilter(filters.FilterSet):
created_at = filters.DateFromToRangeFilter()
class Meta:
model = CashRecord
fields = ['created_at', 'rama']
class ShiftFilter(filters.FilterSet):
date = filters.DateFromToRangeFilter()
class Meta:
model = Shift
fields = ['rama', 'date']
class OrderDateFilter(filters.FilterSet):
order_date = filters.DateFromToRangeFilter()
class Meta:
model = NewOrder
fields = ['order_date']
class PepFilterSet(filters.FilterSet):
fullname = filters.CharFilter(
lookup_expr='search',
help_text=
'Filter by full name "last name first name middle name" in Ukrainian.',
)
fullname_transcriptions_eng = filters.CharFilter(
lookup_expr='search',
help_text='Filter by full name in English transcription.',
)
name_search = filters.CharFilter(
label=_('Options for writing full name'),
method='filter_name_search',
help_text=
'Search by name in fields fullname and fullname_transcriptions_eng.',
)
updated_at = filters.DateFromToRangeFilter(
help_text=
'You can use key "updated_at_before" to select objects before the specified date and '
'"updated_at_after" key to select objects after the specified date. '
'Date must be in YYYY-MM-DD format.', )
updated_at_date = filters.DateFilter(
field_name='updated_at',
lookup_expr='date',
help_text='You can filter updates for a specific date, '
'such as February 25, 2020 - updated_at_date = 2020-02-25',
)
is_pep = filters.BooleanFilter(
widget=ValidatedBooleanWidget,
help_text=
'Boolean type. Can be true or false. True - person is politically exposed person,'
' false - person is not politically exposed person.',
)
is_dead = filters.BooleanFilter(
widget=ValidatedBooleanWidget,
help_text=
'Boolean type. Can be true or false. True - person is dead, false - person is alive.',
)
pep_type = filters.ChoiceFilter(
choices=Pep.TYPES,
help_text=
'Filter by type of pep. Can be national politically exposed person '
'(pep_type=national PEP), foreign politically exposed person (pep_type='
'foreign PEP), having political functions in international organization '
'(pep_type=PEP with political functions in international organization), '
'associated person (pep_type=associated person with PEP), family member '
'(pep_type=member of PEP`s family).',
)
related_company = filters.CharFilter(
label=_("Associated company`s number (provide a number)"),
method='filter_related_company',
help_text='Filter by related company (provide EDRPOU number).',
)
last_job_title = filters.CharFilter(
lookup_expr='icontains',
help_text='Filter by title of the last job in Ukrainian.',
)
last_employer = filters.CharFilter(
lookup_expr='icontains',
help_text='Filter by last employer in Ukrainian.',
)
date_of_birth = filters.CharFilter(
lookup_expr='icontains',
help_text='Filter by date_of_birth, string contains type. '
'Examples: date_of_birth=1964, date_of_birth=1964-02, '
'date_of_birth=1964-02-06',
)
o = filters.OrderingFilter(
fields=(
('fullname', 'fullname'),
('is_pep', 'is_pep'),
('pep_type', 'pep_type'),
('last_job_title', 'last_job_title'),
('last_employer', 'last_employer'),
),
help_text=
'Sort by fields: fullname, is_pep, pep_type, last_job_title, last_employer.'
)
def filter_name_search(self, queryset, name, value):
return queryset.filter(
Q(fullname__search=value)
| Q(fullname_transcriptions_eng__search=value))
def filter_related_company(self, queryset, value, company_number):
peps_id = CompanyLinkWithPep.objects.filter(
company__edrpou=company_number).values_list('pep_id', flat=True)
return queryset.filter(id__in=peps_id)
class Meta:
model = Pep
fields = {}
class AdvertisementFilter(filters.FilterSet):
"""Фильтры для объявлений."""
# TODO: задайте требуемые фильтры
created_at = filters.DateFromToRangeFilter()
creator = filters.NumberFilter(lookup_expr='exact')
class OrderFilterSet(filters.FilterSet):
id = filters.ModelMultipleChoiceFilter(field_name='id',
to_field_name='id',
queryset=Order.objects.all())
name = filters.CharFilter(lookup_expr='icontains')
created_at = filters.DateFromToRangeFilter()
class DocumentFilter(filters.FilterSet):
directory = filters.ModelChoiceFilter(
queryset=(
CollectionDirectory.objects.all()
.select_related('collection')
),
null_label='',
null_value=NULL_VALUE,
method='filter_directory',
)
collection = filters.ModelChoiceFilter(
queryset=DocumentCollection.objects.all(),
method='filter_collection',
)
portal = filters.ModelChoiceFilter(
queryset=DocumentPortal.objects.filter(public=True),
to_field_name='pk',
method='filter_portal',
)
ids = filters.CharFilter(
method='filter_ids'
)
created_at = filters.DateFromToRangeFilter(
method='filter_created_at',
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
request = kwargs.get('request')
if request is None:
request = self.view.request
self.request = request
def filter_ids(self, qs, name, value):
try:
ids = [
int(x) for x in value.split(',') if x
]
except ValueError:
ids = None
if ids:
qs = qs.filter(id__in=ids)
return qs
def filter_directory(self, qs, name, directory):
if NULL_VALUE == directory:
return qs.filter(
filingcabinet_collectiondocument__directory__isnull=True
)
if not directory.collection.can_read(self.request):
return qs.none()
return qs.filter(
filingcabinet_collectiondocument__directory=directory
).order_by(
'filingcabinet_collectiondocument__order'
)
def filter_collection(self, qs, name, collection):
if not collection.can_read(self.request):
return qs.none()
qs = qs.filter(
filingcabinet_collectiondocument__collection=collection
).order_by(
'filingcabinet_collectiondocument__order'
)
data_filters = collection.settings.get('filters', [])
qs = self.apply_data_filters(qs, data_filters)
return qs
def filter_portal(self, qs, name, portal):
qs = qs.filter(portal=portal)
qs = self.apply_data_filters(qs, portal.settings.get('filters', []))
return qs
def apply_data_filters(self, qs, filters):
for filt in filters:
if not filt['key'].startswith('data.'):
continue
val = self.request.GET.get(filt['key'])
if not val:
continue
data_type = filt.get('datatype')
if data_type:
try:
if data_type == 'int':
val = int(val)
except ValueError:
continue
filt_key = filt['key'].replace('.', '__')
qs = qs.filter(**{filt_key: val})
return qs
def filter_created_at(self, qs, name, value):
range_kwargs = {}
if value.start is not None:
range_kwargs['gte'] = value.start
if value.stop is not None:
range_kwargs['lte'] = value.stop
for comp, val in range_kwargs.items():
qs = qs.filter(
Q(**{
'published_at__isnull': False,
'published_at__{}'.format(comp): val
}) |
Q(**{
'published_at__isnull': True,
'created_at__{}'.format(comp): val
})
)
return qs
class FacilityPatientStatsHistoryFilterSet(filters.FilterSet):
entry_date = filters.DateFromToRangeFilter(field_name="entry_date")
class DispatchByDateFilter(filters.FilterSet):
dispatch_by_date = filters.DateFromToRangeFilter()
class Meta:
model = NewOrder
fields = ['dispatch_by_date']
