class SeveralFieldsFilter(FilterSet):
text = filters.CharFilter(lookup_expr='icontains')
decimal = filters.NumberFilter(lookup_expr='lt')
date = filters.DateFilter(lookup_expr='gt')
class Meta:
model = FilterableItem
fields = ['text', 'decimal', 'date']
class ResultSetFilter(filterset.FilterSet):
election_id = filters.CharFilter(field_name="ballot__election__slug")
election_date = filters.DateFilter(
field_name="ballot__election__election_date"
)
class Meta:
model = ResultSet
fields = ["election_date", "election_id"]
class CollectionImportFilter(filterset.FilterSet):
namespace = filters.CharFilter(field_name='namespace__name')
created = filters.DateFilter(field_name='created_at')
sort = OrderingFilter(fields=(('created_at', 'created'), ))
class Meta:
model = models.CollectionImport
fields = ['namespace', 'name', 'version']
class ShiftFilter(FilterSet):
date_start__lte = filters.DateFilter(name='date_start',
lookup_expr='date__lte')
date_start__gte = filters.DateFilter(name='date_start',
lookup_expr='date__gte')
date_end__lte = filters.DateFilter(name='date_end',
lookup_expr='date__lte')
date_end__gte = filters.DateFilter(name='date_end',
lookup_expr='date__gte')
class Meta:
model = Shift
fields = (
'date_start__lte',
'date_start__gte',
'date_end__lte',
'date_end__gte',
)
class AppStatFilter(django_filters.FilterSet):
date_from = filters.DateFilter(field_name='date', lookup_expr='gte')
date_to = filters.DateFilter(field_name='date', lookup_expr='lte')
os = filters.CharFilter(method="filter_os")
channel = filters.CharFilter(lookup_expr='iexact')
country = filters.CharFilter(lookup_expr='iexact')
group_by = filters.MultipleChoiceFilter(choices=GROUP_BY_CHOICES,
method='group_the_query')
o = filters.OrderingFilter(fields=('date', 'channel', 'country', 'os',
'impressions', 'clicks', 'installs',
'spend', 'revenue', 'cpi'), )
@staticmethod
def filter_os(qs, field_name, value):
if value.lower() == 'android':
value = AppStat.ANDROID
elif value.lower() == 'ios':
value = AppStat.IOS
else:
value = None
return qs.filter(os=value)
def group_the_query(self, qs, field_name, group_by_fields):
can_display_fields = list(
set(self.data) & set(['date', 'os', 'channel', 'country']))
group_by_fields = group_by_fields + can_display_fields
return qs.values(*group_by_fields).annotate(
impressions=models.Sum('impressions'),
clicks=models.Sum('clicks'),
installs=models.Sum('installs'),
spend=models.Sum('spend'),
revenue=models.Sum('revenue'),
cpi=models.ExpressionWrapper(
models.F('spend') / models.F('installs'),
output_field=models.FloatField())).order_by(*group_by_fields)
class Meta:
model = AppStat
fields = '__all__'
class CollectionImportFilter(filterset.FilterSet):
namespace = filters.CharFilter(field_name='galaxy_import__namespace__name')
name = filters.CharFilter(field_name='galaxy_import__name')
version = filters.CharFilter(field_name='galaxy_import__version')
created = filters.DateFilter(field_name='galaxy_import__created_at')
versioning_class = versioning.UIVersioning
sort = OrderingFilter(fields=(('galaxy_import__created_at', 'created'), ))
class Meta:
model = PulpCollectionImport
fields = ['namespace', 'name', 'version']
class PlanFilter(django_filters.FilterSet):
"""plan filter"""
name = django_filters.CharFilter(
name='name',
lookup_expr='exact',
)
cpu = django_filters.MultipleChoiceFilter(
name='cpu',
choices=range(4),
)
memory = django_filters.MultipleChoiceFilter(
name='memory',
choices=range(8),
)
disk = django_filters.MultipleChoiceFilter(
name='disk',
choices=range(4),
)
instance = django_filters.MultipleChoiceFilter(
name='instance',
choices=range(1, 4),
)
price = django_filters.MultipleChoiceFilter(
name='price',
choices=Plans.CHOICE,
)
#the time the plan created
start_date = filters.DateFilter(name='created', lookup_expr='gte')
end_date = filters.DateFilter(name='created', lookup_expr='lte')
class Meta:
model = Plans
fields = ('start_date', 'end_date')
class ProductFilter(django_filters.FilterSet):
"""product filter set"""
name = django_filters.CharFilter(name='product_name', lookup_expr='exact')
plan = django_filters.ModelMultipleChoiceFilter(
name='plans__pk',
queryset=Plans.objects.all(),
to_field_name='pk',
label='name',
)
type = django_filters.MultipleChoiceFilter(
name='product_type',
choices=Products.TYPE_CHOICE,
)
# date = django_filters.DateFromToRangeFilter(
# name = "created",
# widget=RangeWidget(attrs={'display':'inline'}),
# )
start_date = filters.DateFilter(name='created', lookup_expr='gte')
end_date = filters.DateFilter(name='created', lookup_expr='lte')
q = django_filters.CharFilter(
method='search',
label='Search',
)
class Meta:
model = Products
fields = ['start_date', 'end_date']
def search(self, queryset, name, value):
if not value.strip():
return queryset
qs_filter = (Q(product_name__icontains=value)
| Q(product_type__icontains=value))
return queryset.filter(qs_filter)
class HistoryFilter(FilterSet):
date = filters.DateFilter(field_name='date__date',
help_text='date of change | '
'format: %Y-%m-%d %H:%M:%S')
feature_id = filters.NumberFilter(field_name='feature_id',
help_text='id of feature')
user_id = filters.NumberFilter(field_name='user_id',
help_text="id of user which changed")
attribute = filters.CharFilter(field_name='attribute',
help_text="name of changeable attribute")
class Meta:
model = History
fields = ['feature_id', 'user_id', 'date', 'attribute']
class ItemFilter(FilterSet):
name = filters.get_model_field(Item, 'name')
created_at = filters.DateFilter(label='日(yyyy-mm-dd)',
lookup_expr='contains')
memo = filters.CharFilter(label='備考', lookup_expr='contains')
order_by = MyOrderingFilter(fields=(('name', 'name'), ),
field_labels={
'name': '氏名',
},
label='並び順')
class Meta:
model = Item
fields = ('name', 'memo', 'created_at')
class ResultsFilterMixin(filterset.FilterSet):
election_id = filters.CharFilter(
field_name="ballot__election__slug",
label="Election Slug",
help_text="An election slug, used to get all "
"results for a given election",
)
election_date = filters.DateFilter(
field_name="ballot__election__election_date",
label="Election Date",
help_text="Election Date in ISO format",
)
last_updated = filters.DateTimeFilter(
field_name="modified",
lookup_expr="gt",
label="Last updated",
help_text="An ISO datetime",
)
class RainfallRecordFilter(FilterSet):
start_dt = filters.DateFilter(field_name="ts", lookup_expr="gte")
end_dt = filters.DateFilter(field_name="ts", lookup_expr="lte")
class ObjectRecordFilterSet(FilterSet):
type = ObjectTypeFilter(
field_name="object__object_type",
help_text=_("Url reference to OBJECTTYPE in Objecttypes API"),
queryset=ObjectType.objects.all(),
min_length=1,
max_length=1000,
)
date = filters.DateFilter(
method="filter_date",
help_text=_(
"Display record data for the specified material date, i.e. the specified "
"date would be between `startAt` and `endAt` attributes. The default value is today"
),
)
registrationDate = filters.DateFilter(
method="filter_registration_date",
help_text=_(
"Display record data for the specified registration date, i.e. the specified "
"date would be between `registrationAt` attributes of different records"
),
)
data_attrs = filters.CharFilter(
method="filter_data_attrs",
validators=[validate_data_attrs],
help_text=_(
"""Only include objects that have attributes with certain values.
Data filtering expressions are comma-separated and are structured as follows:
A valid parameter value has the form `key__operator__value`.
`key` is the attribute name, `operator` is the comparison operator to be used and `value` is the attribute value.
Note: Values can be string, numeric, or dates (ISO format; YYYY-MM-DD).
Valid operator values are:
%(operator_choices)s
`value` may not contain double underscore or comma characters.
`key` may not contain comma characters and includes double underscore only if it indicates nested attributes.
Example: in order to display only objects with `height` equal to 100, query `data_attrs=height__exact__100`
should be used. If `height` is nested inside `dimensions` attribute, query should look like
`data_attrs=dimensions__height__exact__100`
"""
)
% {"operator_choices": display_choice_values_for_help_text(Operators)},
)
class Meta:
model = ObjectRecord
fields = ("type", "data_attrs", "date", "registrationDate")
form = ObjectRecordFilterForm
def filter_data_attrs(self, queryset, name, value: str):
parts = value.split(",")
for value_part in parts:
variable, operator, str_value = value_part.rsplit("__", 2)
real_value = string_to_value(str_value)
if operator == "exact":
# for exact operator try to filter on string and numeric values
in_vals = [str_value]
if real_value != value:
in_vals.append(real_value)
queryset = queryset.filter(**{f"data__{variable}__in": in_vals})
elif operator == "icontains":
# icontains treats everything like strings
queryset = queryset.filter(
**{f"data__{variable}__icontains": str_value}
)
else:
# gt, gte, lt, lte operators
queryset = queryset.filter(
**{f"data__{variable}__{operator}": real_value}
)
return queryset
def filter_date(self, queryset, name, value: date):
return queryset.filter_for_date(value)
def filter_registration_date(self, queryset, name, value: date):
return queryset.filter_for_registration_date(value)
class ObjectFilterSet(FilterSet):
type = filters.CharFilter(field_name="object_type",
help_text=get_help_text("core.Object",
"object_type"))
date = filters.DateFilter(
method="filter_date",
help_text=
_("Display record data for the specified formal date, i.e. the specified "
"date would be between `startAt` and `endAt` attributes. The default value is today"
),
)
registrationDate = filters.DateFilter(
method="filter_registration_date",
help_text=
_("Display record data for the specified registration date, i.e. the specified "
"date would be between `registrationAt` attributes of different records"
),
)
data_attrs = filters.CharFilter(
method="filter_data_attrs",
validators=[validate_data_attrs],
help_text=_(
"""Only include objects that have attributes with certain values.
Data filtering expressions are comma-separated and are structured as follows:
A valid parameter value has the form `key__operator__value`.
`key` is the attribute name, `operator` is the comparison operator to be used and `value` is the attribute value.
Note: Values can be string or numeric. Dates are not supported.
Valid operator values are:
%(operator_choices)s
`value` may not contain double underscore or comma characters.
`key` may not contain comma characters and includes double underscore only if it indicates nested attributes.
Example: in order to display only objects with `height` equal to 100, query `data_attrs=height__exact__100`
should be used. If `height` is nested inside `dimensions` attribute, query should look like
`data_attrs=dimensions__height__exact__100`
""") % {"operator_choices": display_choice_values_for_help_text(Operators)},
)
class Meta:
model = Object
fields = ("type", "data_attrs", "date", "registrationDate")
form = ObjectFilterForm
def filter_data_attrs(self, queryset, name, value):
parts = value.split(",")
for value_part in parts:
variable, operator, val = value_part.rsplit("__", 2)
val_numeric = float(val) if is_number(val) else None
if operator == "exact":
# for exact operator try to filter on string and numeric values
in_vals = [val]
if is_number(val):
in_vals.append(val_numeric)
queryset = queryset.filter(
**{f"records__data__{variable}__in": in_vals})
else:
# only numeric
queryset = queryset.filter(
**{f"records__data__{variable}__{operator}": val_numeric})
return queryset
def filter_date(self, queryset, name, value):
return queryset.filter_for_date(value)
def filter_registration_date(self, queryset, name, value):
return queryset.filter_for_registration_date(value)
