class BaseAPIFilterSet(FilterSet):
created_on = DateTimeFromToRangeFilter()
updated_on = DateTimeFromToRangeFilter()
created_by = NullableUUIDFilter()
updated_by = NullableUUIDFilter()
class Meta:
fields = ["created_on", "updated_on", "created_by", "updated_by"]
class ReadingEntryFilter(filters.FilterSet):
read = DateTimeFromToRangeFilter()
created_at = DateTimeFromToRangeFilter()
feed = NumberFilter(name='article__feed')
class Meta:
model = ReadingEntry
fields = ['read', 'created_at', 'feed']
class OrderFilter(filters.FilterSet):
"""Фильтры для товаров."""
created_at = DateTimeFromToRangeFilter()
updated_at = DateTimeFromToRangeFilter()
class Meta:
model = Order
fields = ['status', 'created_at', 'updated_at', 'amount']
class PostFilter(FilterSet):
published_date = DateTimeFromToRangeFilter(widget=RangeWidget(
attrs={"placeholder": "dd/mm/yyyy hh:mm"}))
updated_date = DateTimeFromToRangeFilter(widget=RangeWidget(
attrs={"placeholder": "dd/mm/yyyy hh:mm"}))
class Meta:
model = Post
fields = ("title", "slug", "author__name", "published_date",
"updated_date")
class RoleFilter(FilterSet):
start_date = DateTimeFromToRangeFilter()
end_date = DateTimeFromToRangeFilter()
is_active = CharFilter(method="filter_is_active")
permission = MultipleChoiceFilter(
choices=zip(Role.PERMISSION_NAMES, Role.PERMISSION_NAMES),
method="filter_permission",
)
class Meta:
model = Role
fields = (
"start_date",
"end_date",
"user",
"association",
"is_active",
"permission",
)
def filter_is_active(self, queryset, _, value):
condition = Q(start_date__lte=date.today()) & (
Q(end_date__isnull=True) | Q(end_date__gt=date.today())
)
if value.lower() == "true" or len(value) == 0:
return queryset.filter(condition)
else:
return queryset.exclude(condition)
def filter_permission(self, queryset, _, permissions_filter):
"""Filter by active permission."""
# No filter or every filter.
if (
len(permissions_filter) == 0
or len(permissions_filter) == Role.PERMISSION_NAMES
):
return queryset
# Looks like the canonical way to get an "always False" condition:
# https://stackoverflow.com/questions/35893867/always-false-q-object
condition = Q(pk__in=[])
for permission_name in Role.PERMISSION_NAMES:
if permission_name in permissions_filter:
condition |= Q(
**{
f"{permission_name}_permission": True,
"start_date__lte": date.today(),
}
) & (Q(end_date__isnull=True) | Q(end_date__gt=date.today()))
return queryset.filter(condition).distinct()
class vulnFilter(FilterSet):
vulndb_published_date = DateTimeFromToRangeFilter()
vulndb_last_modified = DateTimeFromToRangeFilter()
cve = CharFilter(field_name='nvds__id')
tag = ModelMultipleChoiceFilter(field_name='tags__name',
to_field_name='name',
queryset=Tag.objects.all(),
conjoined=True)
class Meta:
model = Vuln
fields = ['vulndb_published_date', 'vulndb_last_modified']
class BaseAPIFilterSet(FilterSet):
created_on = DateTimeFromToRangeFilter()
updated_on = DateTimeFromToRangeFilter()
created_by = NullableUUIDFilter()
updated_by = NullableUUIDFilter()
class Meta:
fields = [
'created_on',
'updated_on',
'created_by',
'updated_by',
]
class SentMessageFilter(FilterSet):
prefix = 'sent'
BOOLE_CHOICES = ((True, 'Only Archived'), (False, 'Only Not Archived'))
time_sent = DateTimeFromToRangeFilter()
recipient = CharFilter(field_name='recipient__user__name',
label='To',
method='filter_recipient',
lookup_expr='icontains')
unread = ChoiceFilter(field_name='unread',
label='Read?',
choices=((True, 'Unread Only'), (False, 'Read Only')))
subject = CharFilter(field_name='subject', lookup_expr='icontains')
high_priority = ChoiceFilter(label='High Pri?',
choices=((True, 'High Pri'), (False, 'Normal')))
def filter_recipient(self, queryset, name, value):
return queryset.annotate(slug=Concat(
'recipient__user__username',
Value('-'),
'recipient__user__first_name',
Value(' '),
'recipient__user__last_name',
)).filter(slug__icontains=value)
def __init__(self, data=None, *args, **kwargs):
newdict = data.dict()
super(SentMessageFilter, self).__init__(newdict, *args, **kwargs)
self.filters['high_priority'].extra.update({'empty_label': 'Any Pri'})
self.filters['unread'].extra.update({'empty_label': 'Read/Unread'})
class Meta:
fields = ['time_sent', 'recipient', 'subject', 'unread', 'high_priority']
class PhotosFilter(django_filters.FilterSet):
start_date = DateTimeFromToRangeFilter(field_name='date_taken')
class Meta:
model = Photo
fields = '__all__'
exclude = ['image', 'name', 'date_taken']
class EmailFilter(filters.FilterSet):
date = DateTimeFromToRangeFilter()
sent = BooleanFilter(field_name='sent_date', lookup_expr='isnull', exclude=True, label="Email Sent?")
class Meta:
model = Email
fields = ['date', 'sent_date', 'sent']
class AllFiltersFilterSet(FilterSet):
number_AllValuesFilter = AllValuesFilter(field_name='number', lookup_expr='exact')
number_AllValuesMultipleFilter_OR = AllValuesMultipleFilter(field_name='number', lookup_expr='exact', conjoined=False) # OR
number_AllValuesMultipleFilter_AND = AllValuesMultipleFilter(field_name='number', lookup_expr='exact', conjoined=True) # AND
number_BaseCSVFilterNumber = BaseCSVFilterNumber(field_name='number', lookup_expr='in')
number_BaseInFilterNumber = BaseInFilterNumber(field_name='number', lookup_expr='in')
number_BaseRangeFilterNumber = BaseRangeFilterNumber(field_name='number', lookup_expr='range')
is_true_BooleanFilter = BooleanFilter(field_name='is_true', lookup_expr='exact')
text_CharFilter = CharFilter(field_name='text', lookup_expr='exact')
number_ChoiceFilter = ChoiceFilter(field_name='number', lookup_expr='exact', choices=NUMBER_CHOICES)
date_DateFilter = DateFilter(field_name='date', lookup_expr='exact')
date_DateFromToRangeFilter = DateFromToRangeFilter(field_name='date', lookup_expr='range')
date_DateRangeFilter = DateRangeFilter(field_name='date', lookup_expr='exact')
date_time_DateTimeFilter = DateTimeFilter(field_name='date_time', lookup_expr='exact')
date_time_DateTimeFromToRangeFilter = DateTimeFromToRangeFilter(field_name='date_time', lookup_expr='range')
duration_DurationFilter = DurationFilter(field_name='duration', lookup_expr='exact')
iso_date_time_IsoDateTimeFilter = IsoDateTimeFilter(field_name='iso_date_time', lookup_expr='lt')
iso_date_time_IsoDateTimeFromToRangeFilter = IsoDateTimeFromToRangeFilter(field_name='iso_date_time', lookup_expr='range')
number_MultipleChoiceFilter_OR = MultipleChoiceFilter(field_name='number', lookup_expr='exact', conjoined=False, choices=NUMBER_CHOICES)
number_MultipleChoiceFilter_AND = MultipleChoiceFilter(field_name='number', lookup_expr='exact', conjoined=True, choices=NUMBER_CHOICES)
number_NumberFilter = NumberFilter(field_name='number', lookup_expr='exact')
number_OrderingFilter = OrderingFilter(fields=('number', 'number'))
number_RangeFilter = RangeFilter(field_name='number', lookup_expr='range')
time_TimeFilter = TimeFilter(field_name='time', lookup_expr='exact')
time_TimeRangeFilter = TimeRangeFilter(field_name='time', lookup_expr='range')
number_TypedChoiceFilter = TypedChoiceFilter(field_name='number', lookup_expr='exact', choices=NUMBER_CHOICES)
text_TypedMultipleChoiceFilter_OR = TypedMultipleChoiceFilter(field_name='number', lookup_expr='exact', conjoined=False, choices=NUMBER_CHOICES)
text_TypedMultipleChoiceFilter_AND = TypedMultipleChoiceFilter(field_name='number', lookup_expr='exact', conjoined=True, choices=NUMBER_CHOICES)
uuid_UUIDFilter = UUIDFilter(field_name='uuid', lookup_expr='exact')
number_LookupChoiceFilter = LookupChoiceFilter(field_name='number')
class Meta:
model = BenchmarkModel
exclude = ['number', 'text', 'is_true', 'date', 'date_time', 'duration']
class DateTimeFromToRangeFilterSet(FilterSet):
date_time = DateTimeFromToRangeFilter(field_name='date_time',
lookup_expr=lookup_xpr)
class Meta:
model = DateTimeFromToRangeFilterModel
fields = ['date_time']
class OrderFilter(filters.FilterSet):
member = CharFilter(field_name='member__name', lookup_expr='contains')
sale_time = DateTimeFromToRangeFilter(field_name='sale_time')
class Meta:
model = Order
fields = ['sale_time', 'member']
class ReviewFilter(filters.FilterSet):
"""Фильтры для товаров."""
created_at = DateTimeFromToRangeFilter()
class Meta:
model = Review
fields = ['creator', 'product', 'created_at']
class RoleFilter(FilterSet):
start_date = DateTimeFromToRangeFilter()
end_date = DateTimeFromToRangeFilter()
is_active = CharFilter(method="filter_is_active")
class Meta:
model = Role
fields = ("start_date", "end_date", "user", "association", "is_active")
def filter_is_active(self, queryset, _, value):
condition = Q(start_date__lte=date.today()) & (
Q(end_date__isnull=True) | Q(end_date__gt=date.today()))
if value.lower() == "true" or len(value) == 0:
return queryset.filter(condition)
else:
return queryset.exclude(condition)
class WeatherFilter(django_filters.rest_framework.FilterSet):
datetime = DateTimeFromToRangeFilter(
lookup_expr=("icontains"),
widget=RangeWidget(attrs={"type": "datetime-local"}))
class Meta:
model = WeatherForecast
fields = ("datetime", )
class threatAttrFilter(FilterSet):
timestamp = DateTimeFromToRangeFilter()
value = CharFilter(field_name='value', lookup_expr='iexact')
type = CharFilter(field_name='type')
class Meta:
model = Attribute
fields = ['id', 'timestamp', 'event__id']
class PropertyDateTimeFromToRangeFilterSet(PropertyFilterSet):
date_time = DateTimeFromToRangeFilter(field_name='date_time',
lookup_expr=lookup_xpr)
prop_date_time = PropertyDateTimeFromToRangeFilter(
field_name='prop_date_time', lookup_expr=lookup_xpr)
class Meta:
model = DateTimeFromToRangeFilterModel
fields = ['prop_date_time']
class CostFilter(filters.FilterSet):
name = CharFilter(field_name='name', lookup_expr='contains')
costtype = CharFilter(field_name='costtype__name', lookup_expr='contains')
buy_time = DateTimeFromToRangeFilter(field_name='buy_time')
price = RangeFilter(field_name='_price')
class Meta:
model = Cost
fields = ['name', 'costtype', 'buy_time', '_price']
class CryptoCurrencyFilter(FilterSet):
created_at = DateTimeFromToRangeFilter(name='created_at')
class Meta:
model = CryptoCurrency
fields = [
'bot',
'created_at',
]
class FullReceivedMessageFilter(FilterSet):
prefix = 'received'
BOOLE_CHOICES = ((True, 'Only Archived'), (False, 'Only Not Archived'))
HANDLED_CHOICES = ((True, 'Only Handled'), (False, 'Only Unhandled'))
time_sent = DateTimeFromToRangeFilter()
sender = CharFilter(field_name='sender__user__name',
label='Frxom',
method='filter_sender',
lookup_expr='icontains')
unread = ChoiceFilter(field_name='unread',
label='Read?',
choices=((True, 'Unread Only'), (False, 'Read Only')))
archived = ChoiceFilter(field_name='archived',
label='Archived?',
choices=BOOLE_CHOICES,
initial=False)
subject = CharFilter(field_name='subject', lookup_expr='icontains')
handled = ChoiceFilter(field_name='handled', label='Handled?', choices=HANDLED_CHOICES)
high_priority = ChoiceFilter(label='High Pri?',
choices=((True, 'High Pri'), (False, 'Normal')))
def filter_recipient(self, queryset, name, value):
return queryset.annotate(slug=Concat(
'recipient__user__username',
Value('-'),
'recipient__user__first_name',
Value(' '),
'recipient__user__last_name',
)).filter(slug__icontains=value)
def filter_sender(self, queryset, name, value):
return queryset.annotate(slug=Concat(
'sender__user__username',
Value('-'),
'sender__user__first_name',
Value(' '),
'sender__user__last_name',
)).filter(slug__icontains=value)
def __init__(self, data=None, *args, **kwargs):
newdict = data.dict()
if len(newdict) == 0:
newdict[f'{self.prefix}-archived'] = False
super(FullReceivedMessageFilter, self).__init__(newdict, *args, **kwargs)
self.filters['high_priority'].extra.update({'empty_label': 'Any Pri'})
self.filters['unread'].extra.update({'empty_label': 'Read/Unread'})
self.filters['archived'].extra.update({'empty_label': 'Archived?'})
self.filters['handled'].extra.update({'empty_label': 'Handled?'})
class Meta:
fields = [
'time_sent', 'sender', 'subject', 'unread', 'high_priority', 'handled', 'archived'
]
class RequestFilter(django_filters.FilterSet):
created = DateFilter(field_name='created',
lookup_expr='icontains',
label='Created',
widget=DateInput(attrs={'type': 'date'}))
created_range = DateTimeFromToRangeFilter(
field_name='created',
lookup_expr='icontains',
label='Created Range',
widget=RangeWidget(attrs={'type': 'datetime-local'}))
fulfilled = DateFilter(field_name='fulfilled',
lookup_expr='icontains',
label='Fulfilled',
widget=DateInput(attrs={'type': 'date'}))
fulfilled_range = DateTimeFromToRangeFilter(
field_name='fulfilled',
lookup_expr='icontains',
label='Fulfilled Range',
widget=RangeWidget(attrs={'type': 'datetime-local'}))
reopened = NumberFilter(field_name='reopened',
lookup_expr='exact',
label='Reopened Count')
reopened_range = RangeFilter(field_name='reopened',
lookup_expr='icontains',
label='Reopened Count Range')
#Set choices for select fields
assignee = MultipleChoiceFilter(choices=get_all_customer_choices())
assignment_group = MultipleChoiceFilter(
choices=get_assignment_group_choices())
customer = MultipleChoiceFilter(choices=get_all_customer_choices())
location = MultipleChoiceFilter(choices=get_all_location_choices())
priority = MultipleChoiceFilter(choices=get_priority_choices())
status = MultipleChoiceFilter(choices=get_status_choices(
ticket_type=TicketType.objects.get(name='Request')))
class Meta:
model = Request
fields = '__all__'
exclude = [
'sysID',
'ticket_type',
]
class DadoFilter(django_filters.FilterSet):
date_range = DateTimeFromToRangeFilter(
field_name='date',
widget=RangeWidget(attrs={'placeholder': 'DD/MM/YYYY hh:mm'}))
sensor = ModelChoiceFilter(queryset=dispositivo)
class Meta:
model = Dado
fields = ['valor_char', 'valor_int']
class threatEventFilter(FilterSet):
publish_timestamp = DateTimeFromToRangeFilter()
attr = CharFilter(method='getEventsByAttribute', label='attr')
class Meta:
model = Event
fields = ['id', 'publish_timestamp', 'threat_level_id']
def getEventsByAttribute(self, queryset, name, value):
events = Attribute.objects.filter(
Q(value__icontains=value)).values_list('event')
return queryset.filter(id__in=events)
class StudyRequestFilter(django_filters.FilterSet):
SPECIALIST_CHOICES = [(m.id, m.last_name + m.first_name) for m in AdvUser.objects.filter(groups__name='Manager')]
STATUS_CHOICES = (
('Ready', 'Ready'),
('In Progress', 'In Progress'),
('Denial', 'Denial'),
)
enter_date = DateTimeFromToRangeFilter(widget=RangeWidget(attrs={'class': 'form-control mb-2', 'placeholder': 'dd.mm.yyyy'}))
specialist = django_filters.ChoiceFilter(choices=SPECIALIST_CHOICES, widget=widgets.Select(attrs = {'class': 'form-control mb-2', 'placeholder': 'Специалист'}))
status = django_filters.ChoiceFilter(choices=STATUS_CHOICES, widget=widgets.Select(attrs = {'class': 'form-control mb-2', 'placeholder': 'Статус'}))
class Meta:
model = StudyRequest
fields = ['enter_date', 'specialist', "status"]
class EventFilter(FilterSet):
# https://django-filter.readthedocs.io/en/latest/guide/usage.html#declaring-filters
start = DateTimeFromToRangeFilter(field_name="occurrences__start")
category = ModelMultipleChoiceFilter(
field_name="categories__name",
to_field_name="name",
queryset=EventCategory.objects.all(),
)
tag = ModelMultipleChoiceFilter(field_name="tags__name",
to_field_name="name",
queryset=Tag.objects.all())
class Meta:
model = Event
fields = ["occurrences__start", "category", "tag"]
class CurrencyHistoryFilterSet(rest_framework.FilterSet):
"""Currency History FilterSet"""
hour: rest_framework.NumberFilter = rest_framework.NumberFilter(
method="filter_hour",
label="Hour",
)
date_range: DateTimeFromToRangeFilter = DateTimeFromToRangeFilter(
method="filter_date_range",
label="Date range",
widget=DateRangeWidget(attrs={"type": "date"}),
)
date_: rest_framework.DateFilter = rest_framework.DateFilter(
method="filter_date",
label="Date",
)
class Meta:
"""Meta."""
model: Type[CurrencyHistory] = CurrencyHistory
fields: Dict[str, List[str]] = {
"currency": ["exact"],
}
def filter_hour(self, queryset: QuerySet, name: str,
value: int) -> QuerySet:
"""Filter history by hour"""
return queryset.filter(creation_date__hour=value)
def filter_date_range(self, queryset: QuerySet, name: str,
value: slice) -> QuerySet:
"""Filter history between to dates"""
return queryset.filter(creation_date__gte=value.start,
creation_date__lte=value.stop)
def filter_date(self, queryset: QuerySet, name: str,
value: date) -> QuerySet:
"""Filter history by date"""
return queryset.filter(
creation_date__day=value.day,
creation_date__year=value.year,
creation_date__month=value.month,
)
class StudyRequestFilter(django_filters.FilterSet):
SPECIALIST_CHOICES = [(m.id, m.last_name + m.first_name) for m in AdvUser.objects.filter(groups__name='Manager')]
STATUS_CHOICES = (
('Ready', 'Готов к договору'),
('In Progress', 'В процессе'),
('Denial', 'Отказ'),
)
enter_date = DateTimeFromToRangeFilter(widget=RangeWidget(attrs={'type': 'date',
'class': 'main-header__button-change-speciality'}))
specialist = django_filters.ChoiceFilter(
choices=SPECIALIST_CHOICES, widget=widgets.Select(attrs = {'class': 'main-header__button-change-speciality',
'placeholder': 'Специалист'}))
status = django_filters.ChoiceFilter(
choices=STATUS_CHOICES, widget=widgets.Select(attrs = {'class': 'main-header__button-change-speciality',
'placeholder': 'Статус'}))
class Meta:
model = StudyRequest
fields = ['enter_date', 'specialist', "status"]
class ObservationFilter(FilterSet):
"""
Defines the available fields for filtering the list of ``ObservationRecord`` objects.
"""
ordering = OrderingFilter(fields=[
'scheduled_start', 'scheduled_end', 'status', 'created', 'modified'
])
scheduled_start = DateTimeFromToRangeFilter()
scheduled_end = DateTimeFromToRangeFilter
observationgroup = ModelMultipleChoiceFilter(
label='Observation Groups', queryset=ObservationGroup.objects.all())
class Meta:
model = ObservationRecord
fields = [
'ordering', 'observation_id', 'target_id', 'observationgroup',
'facility', 'status'
]
class UserFilterAPI(FilterSet):
date_joined = DateTimeFromToRangeFilter(
label='Date joined range',
field_name='created',
lookup_expr='date',
widget=DateRangeWidget(attrs={
'class': 'form-control datetimepicker-input',
'type': 'date',
}))
is_active = BooleanFilter()
user_id = BaseInFilter(field_name='id', label='User id')
class Meta:
model = User
fields = {
'email': ['icontains'],
'first_name': ['icontains'],
'last_name': ['icontains'],
}