class UserFilter(django_filters.FilterSet):
name_email = CharFilter(method='get_name_email')
status = CharFilter(method='get_status')
roles = CommaSeparatedListFilter(name='prp_roles__role')
partners = CommaSeparatedListFilter(name='partner_id')
clusters = CommaSeparatedListFilter(name='prp_roles__cluster_id')
workspaces = CommaSeparatedListFilter(name='prp_roles__workspace_id')
class Meta:
model = User
fields = []
def get_name_email(self, queryset, name, value):
queryset = queryset.annotate(
name=Concat('first_name', Value(' '), 'last_name'))
return queryset.filter(
Q(name__icontains=value) | Q(email__icontains=value))
def get_status(self, queryset, name, value):
statuses = parse.unquote(value).split(',')
status_to_q = {
USER_STATUS_TYPES.active:
Q(is_active__isnull=False,
last_login__isnull=False,
prp_roles__isnull=False),
USER_STATUS_TYPES.invited:
Q(is_active__isnull=False,
last_login__isnull=True,
prp_roles__isnull=False),
USER_STATUS_TYPES.incomplete:
Q(prp_roles__isnull=True)
}
return queryset.filter(
reduce(operator.or_,
[status_to_q.get(status, Q()) for status in statuses]))
class PartnerProjectFilter(filters.FilterSet):
partner = CharFilter(method='get_partner')
title = CharFilter(method='get_title')
location = CharFilter(method='get_location')
status = ChoiceFilter(choices=PARTNER_PROJECT_STATUS)
start_date = DateFilter(method='get_start_date')
end_date = DateFilter(method='get_end_date')
cluster_id = CharFilter(method='get_cluster_id')
class Meta:
model = PartnerProject
fields = ['title', 'location', 'status', 'start_date', 'end_date']
def get_partner(self, queryset, name, value):
return queryset.filter(partner_id=value)
def get_title(self, queryset, name, value):
return queryset.filter(title__icontains=value)
def get_location(self, queryset, name, value):
return queryset.filter(locations__id=value)
def get_start_date(self, queryset, name, value):
return queryset.filter(start_date__gte=value)
def get_end_date(self, queryset, name, value):
return queryset.filter(end_date__lte=value)
def get_cluster_id(self, queryset, name, value):
return queryset.filter(clusters__in=[value])
class ProgrammeDocumentIndicatorFilter(django_filters.FilterSet):
pd_statuses = ChoiceFilter(choices=PD_STATUS, method='get_status')
pds = CharFilter(method='get_programme_document')
location = CharFilter(method='get_locations')
blueprint__title = CharFilter(method='get_blueprint_title')
incomplete = CharFilter(method='get_incomplete')
class Meta:
model = Reportable
fields = (
'id',
'blueprint__title',
)
def get_status(self, queryset, name, value):
return queryset.filter(
lower_level_outputs__cp_output__programme_document__status=value)
def get_programme_document(self, queryset, name, value):
return queryset.filter(
lower_level_outputs__cp_output__programme_document_id=value)
def get_locations(self, queryset, name, value):
return queryset.filter(locations=value)
def get_blueprint_title(self, queryset, name, value):
return queryset.filter(blueprint__title__contains=value)
def get_incomplete(self, queryset, name, value):
return queryset.filter(
lower_level_outputs__cp_output__programme_document__progress_reports__indicator_reports__submission_date__isnull
=True) if value == "1" else queryset
class ProgrammeDocumentIndicatorFilter(django_filters.FilterSet):
pd_statuses = CommaSeparatedListFilter(name='lower_level_outputs__cp_output__programme_document__status')
pds = CommaSeparatedListFilter(name='lower_level_outputs__cp_output__programme_document_id')
location = CharFilter(method='get_locations')
blueprint__title = CharFilter(method='get_blueprint_title')
incomplete = CharFilter(method='get_incomplete')
report_partner_external = CommaSeparatedListFilter(
name='indicator_reports__progress_report__programme_document__partner__external_id'
)
report_status = CommaSeparatedListFilter(
name='indicator_reports__progress_report__status'
)
report_type = CommaSeparatedListFilter(
name='indicator_reports__progress_report__report_type'
)
cp_output = CommaSeparatedListFilter(name='lower_level_outputs__cp_output__external_cp_output_id')
report_section = CommaSeparatedListFilter(
name='lower_level_outputs__cp_output__programme_document__sections__external_id')
pd_ref_title = CharFilter(name='pd ref title', method='get_pd_ref_title',
label='PD/Ref # title')
unicef_focal_points = CharFilter(method='get_unicef_focal_points')
class Meta:
model = Reportable
fields = (
'id', 'blueprint__title',
)
def get_locations(self, queryset, name, value):
return queryset.filter(locations=value)
def get_blueprint_title(self, queryset, name, value):
return queryset.filter(blueprint__title__icontains=value)
def get_incomplete(self, queryset, name, value):
if value == Boolean.TRUE:
return queryset.filter(
lower_level_outputs__cp_output__programme_document__progress_reports__indicator_reports__submission_date__isnull=True # noqa: E501
)
return queryset
def get_activepdsonly(self, queryset, name, value):
if value == Boolean.TRUE:
return queryset.filter(lower_level_outputs__cp_output__programme_document__status=PD_STATUS.active)
return queryset
def get_pd_ref_title(self, queryset, name, value):
return queryset.filter(
Q(lower_level_outputs__cp_output__programme_document__reference_number__icontains=value) |
Q(lower_level_outputs__cp_output__programme_document__title__icontains=value)
)
def get_unicef_focal_points(self, queryset, name, value):
return queryset.filter(
lower_level_outputs__cp_output__programme_document__unicef_focal_point__email__in=parse.unquote(
value).split(',') # noqa: E501
).distinct()
class F(FilterSet):
username = CharFilter(label='Filter for users with username')
exclude_username = CharFilter(field_name='username', lookup_expr='iexact', exclude=True)
class Meta:
model = User
fields = {
'status': ['exact', 'lt', 'gt'],
'favorite_books__title': ['iexact', 'in'],
'manager_of__users__username': ['exact'],
}
class PartnerIDManagementFilter(django_filters.FilterSet):
partner_type = CharFilter(field_name='partner_type')
clusters = CommaSeparatedListFilter(field_name='clusters__id')
title = CharFilter(method='get_title')
class Meta:
model = Partner
fields = ['partner_type', 'clusters', 'title']
def get_title(self, queryset, name, value):
return queryset.filter(
Q(title__icontains=value) | Q(short_title__icontains=value)
| Q(alternate_title__icontains=value))
class ClusterObjectiveFilter(django_filters.FilterSet):
ref_title = CharFilter(method='get_reference_number_title')
cluster_id = CharFilter(method='get_cluster_id')
class Meta:
model = ClusterObjective
fields = ['ref_title', 'cluster_id']
def get_reference_number_title(self, queryset, name, value):
return queryset.filter(title__icontains=value)
def get_cluster_id(self, queryset, name, value):
return queryset.filter(cluster_id=value)
class EventSearchFilter(django_filters.FilterSet):
ownership = MultipleChoiceFilter(choices=[('admin','Created'), ('joined',' Joined')], widget=forms.CheckboxSelectMultiple )
location = ChoiceFilter(name='location',choices=[('Venue','Venue'), ('Online','Online')], widget=forms.Select(attrs={'class': 'selects'}))
city = CharFilter(name="city", lookup_expr="icontains", widget=forms.TextInput(attrs={'placeholder': 'City'}))
state = CharFilter(name="state", lookup_expr="icontains", widget=forms.TextInput(attrs={'placeholder': 'State'}))
country = CharFilter(name="india", lookup_expr="icontains", widget=forms.TextInput(attrs={'placeholder': 'India'}))
category = ChoiceFilter(name="category",choices=[('Adventure','Adventure'), ('Business & Tech','Business & Tech'), ('Entertainment','Entertainment'), ('Social','Social'), ('Sports','Sports'), ('Talks','Talks')], widget=forms.Select(attrs={'class': 'selects'}))
gender = ChoiceFilter(name='gender',choices=[('Male','Male'), ('Female','Female'), ('Others','Others'), ('Any', 'Any')], widget=forms.Select(attrs={'class': 'selects'}))
age_group = ChoiceFilter(name='age',choices=[('Under 18','Under 18'), ('18-30','18-30'), ('30-50','30-50'), ('Above 50','Above 50')], widget=forms.Select(), lookup_expr="icontains", label='Age Group')
year = NumberFilter(label='Start Date', name='start_date',lookup_expr='year', widget=forms.NumberInput(attrs={'class': 'form_inps', 'placeholder': 'Year'}) )
month = NumberFilter(label='Start Date', name='start_date',lookup_expr='month', widget=forms.NumberInput(attrs={'class': 'form_inps', 'placeholder': 'Month'}) )
day = NumberFilter(label='Start Date', name='start_date',lookup_expr='day', widget=forms.NumberInput(attrs={'class': 'form_inps', 'placeholder': 'Day'}) )
class Meta:
model = Event
fields = ['ownership']
class CandidateFilter(FilterSet):
name = CharFilter(method='name_filter')
status = ChoiceFilter(choices=Candidate.CANDIDATE_STATUS, help_text="")
def __init__(self, *args, **kwargs):
super(CandidateFilter, self).__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.form_method = 'get'
layout = Div(Div(Field('name'), css_class='col-xs-12 col-md-6'),
Div(Field('status'), css_class='col-xs-12 col-md-6'))
self.helper.layout = Layout(*layout)
self.helper.add_input(Submit('submit', 'Filter', css_class='btn-info'))
class Meta:
model = Candidate
fields = ['name', 'status']
def name_filter(self, queryset, name, value):
if value:
return queryset.filter(
reduce(or_, (Q(first_name__icontains=name)
| Q(last_name__icontains=name)
for name in value.split())))
else:
return queryset
class F(FilterSet):
account = CharFilter(name='username')
class Meta:
model = User
fields = ['account', 'status']
order_by = True
class F(FilterSet):
username = CharFilter()
class Meta:
model = Book
fields = ('username', 'title', 'price')
exclude = ('title', )
class F(FilterSet):
username = CharFilter(label='Account')
class Meta:
model = User
fields = ['username', 'status']
order_by = True
class UsersFilter(FilterSet):
"""Filter for users"""
attributes = CharFilter(
field_name="attributes",
lookup_expr="",
label="Attributes",
method="filter_attributes",
)
is_superuser = BooleanFilter(field_name="ak_groups",
lookup_expr="is_superuser")
# pylint: disable=unused-argument
def filter_attributes(self, queryset, name, value):
"""Filter attributes by query args"""
try:
value = loads(value)
except ValueError:
raise ValidationError(detail="filter: failed to parse JSON")
if not isinstance(value, dict):
raise ValidationError(
detail="filter: value must be key:value mapping")
qs = {}
for key, _value in value.items():
qs[f"attributes__{key}"] = _value
return queryset.filter(**qs)
class Meta:
model = User
fields = [
"username", "name", "is_active", "is_superuser", "attributes"
]
class QuestionStatementFilter(FilterSet):
version = CharFilter(label="version", method="get_version")
class Meta:
model = QuestionStatement
fields = {
"statement": ["exact"],
"question": ["exact"],
"is_active": ["exact"],
"question_group": ["exact"],
}
def get_version(self, queryset, name, value):
if value == "latest":
draft_question_statements = queryset.filter(version="draft")
draft_statements = draft_question_statements.values_list(
"statement", flat=True)
queryset_id = list(
draft_question_statements.values_list("id", flat=True))
queryset_id.extend(
list(
queryset.filter(is_active=True).exclude(
statement__in=draft_statements).values_list(
"id", flat=True)))
return queryset.filter(id__in=queryset_id)
return queryset.filter(version=value)
class F(FilterSet):
username = CharFilter(action=lambda qs, value: (qs.filter(
**{'username__startswith': value})))
class Meta:
model = User
fields = ['username']
class F(FilterSet):
invalid = CharFilter(method=lambda *args: None)
class Meta:
model = User
fields = ['username', 'invalid']
logic_fields = ['invalid']
class WorkerFilter(filters.FilterSet):
health = CharFilter(method="filter_health")
state = CharFilter(method="filter_state")
def filter_health(self, queryset, name, value):
try:
value = Worker.HEALTH_REVERSE[value]
except KeyError:
raise ValidationError(
"Select a valid choice. %s is not one of the available choices: %s"
% (value, list(zip(*Worker.HEALTH_CHOICES))[1])
)
return queryset.filter(health=value)
def filter_state(self, queryset, name, value):
try:
value = Worker.STATE_REVERSE[value]
except KeyError:
raise ValidationError(
"Select a valid choice. %s is not one of the available choices: %s"
% (value, list(zip(*Worker.STATE_CHOICES))[1])
)
return queryset.filter(state=value)
class Meta:
model = Worker
fields = {
"hostname": [
"exact",
"in",
"contains",
"icontains",
"startswith",
"endswith",
],
"description": [
"exact",
"in",
"contains",
"icontains",
"startswith",
"endswith",
],
"last_ping": ["exact", "lt", "gt"],
"state": ["exact"],
"health": ["exact"],
}
class BaseFilter(django_filters.FilterSet):
name = CharFilter(lookup_expr='contains')
status = ChoiceFilter(choices=Base.STATUS)
class Meta:
exclude = [
'id', 'tags', 'description', 'pin', 'documentation', 'comment'
]
class Meta:
last_name = CharFilter()
model = Teacher
fields = {
'last_name': ['icontains'],
'subject_taught': ['icontains'],
}
class F(FilterSet):
username = CharFilter()
class Meta:
model = Book
fields = {'id': ['exact'],
'username': ['exact'],
}
class TersangkaDateFilter(FilterSet):
created = DateFromTo()
nama_tersangka = CharFilter(lookup_expr='startswith')
class Meta:
model = Tersangka
fields = [
'no_penangkapan_id__id'
]
class ClusterActivityFilter(django_filters.FilterSet):
title = CharFilter(method='get_title')
cluster_id = CharFilter(method='get_cluster_id')
cluster_objective_id = CharFilter(method='get_cluster_objective_id')
class Meta:
model = ClusterActivity
fields = ['title', 'cluster_id', 'cluster_objective_id']
def get_title(self, queryset, name, value):
return queryset.filter(title__icontains=value)
def get_cluster_id(self, queryset, name, value):
return queryset.filter(cluster_objective__cluster_id=value)
def get_cluster_objective_id(self, queryset, name, value):
return queryset.filter(cluster_objective=value)
class OrderFilter(django_filters.FilterSet):
start_date = DateFilter(field_name="date_created", lookup_expr='gte')
end_date = DateFilter(field_name="date_created", lookup_expr='lte')
note = CharFilter(field_name='note', lookup_expr='icontains')
class Meta:
model = Order
fields = '__all__'
exclude = ['customer', 'date_created']
class LocationFilter(django_filters.FilterSet):
loc_type = NumberFilter(method='get_loc_type')
cluster_objectives = CharFilter(method='get_cluster_objectives')
title = CharFilter(method='get_title')
class Meta:
model = Location
fields = ['loc_type', 'cluster_objectives', 'title']
def get_loc_type(self, queryset, name, value):
return queryset.filter(gateway__admin_level=value)
def get_cluster_objectives(self, queryset, name, value):
return queryset.filter(
gateway__country__workspaces__response_plans__clusters__cluster_objectives__in=value.split(','))
def get_title(self, queryset, name, value):
return queryset.filter(title__icontains=value)
class PenangkapanDateFilter(FilterSet):
created = DateFromTo()
no_penangkapan = CharFilter(lookup_expr='startswith')
class Meta:
model = Penangkapan
fields = [
'id', 'no_penangkapan', 'no_lkn__LKN', 'no_lkn', 'created'
]
class LknDateFilter(FilterSet):
tgl_dibuat = DateFromTo()
LKN = CharFilter(lookup_expr='startswith')
class Meta:
model = BerkasLKN
fields = {
'LKN'
}
class PartnerActivityFilter(django_filters.FilterSet):
partner = CharFilter(method='get_partner')
project = CharFilter(method='get_project')
cluster_id = CharFilter(method='get_cluster_id')
activity = CharFilter(method='get_activity')
custom = TypedChoiceFilter(
field_name='custom',
choices=Boolean.CHOICES,
coerce=strtobool,
method='get_custom',
label='Show only custom activities',
)
status = ChoiceFilter(choices=PARTNER_PROJECT_STATUS)
location = CharFilter(method='get_location')
class Meta:
model = PartnerActivity
fields = [
'partner', 'project', 'cluster_id', 'activity', 'custom', 'status',
'location'
]
def get_partner(self, queryset, name, value):
return queryset.filter(partner=value)
def get_project(self, queryset, name, value):
return queryset.filter(projects=value)
def get_cluster_id(self, queryset, name, value):
return queryset.filter(
Q(cluster_activity__cluster_objective__cluster__id=value)
| Q(cluster_objective__cluster__id=value))
def get_activity(self, queryset, name, value):
return queryset.filter(title__icontains=value)
def get_custom(self, queryset, name, value):
if value:
return queryset.filter(cluster_activity=None)
return queryset
def get_location(self, queryset, name, value):
return queryset.filter(locations__id=value)
class F(FilterSet):
f = CharFilter(method='filter_f')
class Meta:
model = User
fields = []
def filter_f(inner_self, qs, name, value):
self.assertIsInstance(inner_self, F)
self.assertIs(inner_self.request, request)
class TestFilterSet(FilterSet):
custom__filter = CharFilter()
class Meta:
model = TestModel
fields = {
'id': ['exact'],
'name': ['exact', 'iexact', 'contains', 'icontains', 'startswith'],
'is_active': ['exact']
}
class BBDateFilter(FilterSet):
created = DateFromTo()
sp_sita = CharFilter(lookup_expr='startswith')
class Meta:
model = BarangBukti
fields = [
'milik_tersangka_id__no_penangkapan_id__id',
'sp_sita'
]
