class UserProfileFilter(django_filters.FilterSet):
city = django_filters.CharFilter(name='geo_city__name')
region = django_filters.CharFilter(name='geo_region__name')
country = django_filters.CharFilter(name='geo_country__name')
country_code = django_filters.CharFilter(name='geo_country__code')
username = django_filters.CharFilter(name='user__username')
email = django_filters.MethodFilter(action='filter_emails')
language = django_filters.CharFilter(name='language__code')
account = django_filters.CharFilter(name='externalaccount__identifier',
distinct=True)
group = django_filters.MethodFilter(action='filter_group')
skill = django_filters.CharFilter(name='skills__name')
class Meta:
model = UserProfile
fields = ('is_vouched', 'city', 'region', 'country', 'country_code',
'username', 'email', 'ircname', 'full_name', 'account',
'group', 'skill')
def filter_emails(self, queryset, value):
"""Return users with email matching either primary or alternate email address"""
qs = ExternalAccount.objects.filter(type=ExternalAccount.TYPE_EMAIL,
identifier=value)
users = qs.values_list('user__id', flat=True)
query = Q(id__in=users) | Q(user__email=value)
return queryset.filter(query).distinct()
def filter_group(self, queryset, value):
membership = GroupMembership.MEMBER
return queryset.filter(groups__name=value,
groupmembership__status=membership)
class MigrationFilter(django_filters.FilterSet):
"""Migration filter to allow lookups for case, status, ci_project."""
case = django_filters.NumberFilter(name="case__id", lookup_type='exact')
release = django_filters.NumberFilter(name="case__release__number", lookup_type='lte')
reviewed = django_filters.BooleanFilter(name="reviewed", lookup_type='exact')
status = django_filters.CharFilter(name="reports__status")
exclude_status = django_filters.MethodFilter(action="filter_exclude_status")
ci_project = django_filters.CharFilter(
name="case__ci_project__name", lookup_type='exact')
instance = django_filters.MethodFilter(action="filter_instance")
class Meta:
model = Migration
fields = [
'uid', 'case', 'release', 'category', 'ci_project', 'instance', 'status', 'exclude_status', 'reviewed']
def filter_exclude_status(self, queryset, value):
"""Implement ``exclude`` filter by status."""
if not self.form.cleaned_data['instance']:
raise exceptions.ValidationError('Instance is required to exclude status')
return queryset.filter(
Q(reports__status__gt=value) | Q(reports__status__lt=value) |
Q(reports__isnull=True))
def filter_instance(self, queryset, value):
"""Implement filter by instance."""
return queryset.filter(
Q(reports__instance__name=value) | Q(reports__isnull=True) | Q(case__ci_project__instances__name=value))
class ProductFilter(django_filters.FilterSet):
group = django_filters.MethodFilter()
group_id = django_filters.MethodFilter()
band = django_filters.MethodFilter()
class_name = django_filters.MethodFilter()
process = django_filters.MethodFilter()
class Meta:
model = Product
fields = [
'id', 'prd_name', 'prd_display_name', 'prd_class', 'prd_filter',
'band', 'group', 'group_id', 'releases', 'tags', 'class_name'
]
def filter_group(self, queryset, value):
return queryset.filter(prd_class__pcl_group__pgr_name=str(value))
def filter_group_id(self, queryset, value):
return queryset.filter(prd_class__pcl_group__pk=str(value))
def filter_band(self, queryset, value):
return queryset.filter(prd_filter__filter=str(value))
def filter_class_name(self, queryset, value):
return queryset.filter(prd_class__pcl_name=str(value))
def filter_process(self, queryset, value):
return queryset.filter(prd_process_id__epr_original_id=str(value))
class PatchFilter(django_filters.FilterSet):
def filter_submitter(self, queryset, submitter):
try:
submitter = int(submitter)
queryset = queryset.filter(submitter=submitter)
except ValueError:
if submitter == 'self' and self.request.user.is_authenticated():
people = Person.objects.filter(user=self.request.user)
queryset = queryset.filter(submitter__in=people)
return queryset
def filter_state(self, queryset, state_names):
if not state_names:
return queryset
try:
states = map(State.from_string, state_names.split(','))
return queryset.filter(state__in=states)
except State.DoesNotExist:
return queryset
submitted_since = django_filters.CharFilter(name='date', lookup_type='gt')
updated_since = django_filters.CharFilter(name='last_updated',
lookup_type='gt')
submitted_before = django_filters.CharFilter(name='date',
lookup_type='lte')
updated_before = django_filters.CharFilter(name='last_updated',
lookup_type='lte')
submitter = django_filters.MethodFilter()
name = django_filters.CharFilter(lookup_type='icontains')
state = django_filters.MethodFilter()
class Meta:
model = Patch
fields = ['project']
class ChangesetFilterSet(django_filters.FilterSet):
author = django_filters.MethodFilter(action='filter_author',
widget=SelectMultiple)
resource = django_filters.MethodFilter(action='filter_resource',
widget=SelectMultiple)
changed_since = django_filters.MethodFilter(action='filter_committed_since',
widget=widgets.DateTimeInput)
changed_until = django_filters.MethodFilter(action='filter_committed_until',
widget=widgets.DateTimeInput)
comment = django_filters.CharFilter(name="comment", lookup_type="contains")
@value_is_not_empty
def filter_author(self, qs, value):
return qs.filter(author__username__in=value).distinct()
@value_is_not_empty
def filter_resource(self, qs, value):
return qs.filter(change__target_class__in=value).distinct()
@value_is_not_empty
def filter_committed_since(self, qs, value):
return qs.filter(committed_on__gte=value).distinct()
@value_is_not_empty
def filter_committed_until(self, qs, value):
return qs.filter(committed_on__lte=value).distinct()
class Meta:
model = models.Changeset
fields = ('author', 'resource', 'changed_since', 'changed_until', 'comment')
class CardFilter(django_filters.FilterSet):
is_event = django_filters.MethodFilter(action='filter_is_event')
ids = django_filters.MethodFilter(action='filter_ids')
for_trivia = django_filters.MethodFilter(action='filter_for_trivia')
rarity = CommaSeparatedValueFilter(name='rarity', lookup_type='in')
def filter_for_trivia(self, queryset, value):
return queryset.filter(
Q(idol__hobbies__isnull=False)
| Q(idol__favorite_food__isnull=False)
| Q(idol__least_favorite_food__isnull=False))
def filter_is_event(self, queryset, value):
return queryset.filter(
event__isnull=(False if value.title() == 'True' else True))
def filter_ids(self, queryset, value):
return queryset.filter(id__in=value.split(','))
class Meta:
model = models.Card
fields = ('name', 'japanese_collection', 'translated_collection',
'rarity', 'attribute', 'is_promo', 'is_special',
'japan_only', 'hp', 'skill', 'center_skill', 'is_event',
'ids')
class AreaListFilter(django_filters.FilterSet):
# name = django_filters.CharFilter(lookup_expr='icontains') no name field in area class
site__province__region__name = django_filters.ModelMultipleChoiceFilter(
queryset=DC_region.objects.all(), label='Region', help_text=False)
site__province = django_filters.ModelMultipleChoiceFilter(
queryset=DC_province.objects.all(), label='District', help_text=False)
area_type = django_filters.ModelMultipleChoiceFilter(
queryset=DC_area_areatype.objects.all(), help_text=False)
site__name = django_filters.CharFilter(lookup_expr='icontains',
help_text=False)
period = django_filters.MethodFilter(action='my_custom_filter',
help_text=False)
period__cs_name = django_filters.MethodFilter(
action='my_custom_filter_csname',
label='Period Chronological system',
help_text=False)
period__start_date1_BC = django_filters.NumberFilter(
lookup_expr='lte',
label='Period start date 1 BC',
help_text='Lesser than or equal to')
period__end_date1_BC = django_filters.NumberFilter(
lookup_expr='gte',
label='Period end date 1 BC',
help_text='Greater than or equal to')
class Meta:
model = Area
fields = ['area_type']
def my_custom_filter(self, queryset, value):
return queryset.filter(period__period_name__icontains=value).distinct()
def my_custom_filter_csname(self, queryset, value):
return queryset.filter(period__cs_name__icontains=value).distinct()
class CircuitFilter(ResourceFilter):
"""Filter for Circuit objects."""
endpoint_a = django_filters.MethodFilter()
endpoint_z = django_filters.MethodFilter()
class Meta:
model = models.Circuit
fields = ['endpoint_a', 'endpoint_z', 'name', 'attributes']
# FIXME(jathan): The copy/pasted methods can be ripped out once we upgrade
# filters in support of the V2 API. For now this is quicker and easier.
def filter_endpoint_a(self, queryset, value):
"""Overload to use natural key."""
if isinstance(value, int):
value = str(value)
if value.isdigit():
return queryset.filter(endpoint_a=value)
else:
return queryset.filter(endpoint_a__name_slug=value)
def filter_endpoint_z(self, queryset, value):
"""Overload to use natural key."""
if isinstance(value, int):
value = str(value)
if value.isdigit():
return queryset.filter(endpoint_z=value)
else:
return queryset.filter(endpoint_z__name_slug=value)
class QuestionFilter(django_filters.FilterSet):
product = django_filters.CharFilter(name='product__slug')
creator = django_filters.CharFilter(name='creator__username')
involved = django_filters.MethodFilter(action='filter_involved')
is_solved = django_filters.MethodFilter(action='filter_is_solved')
metadata = django_filters.MethodFilter(action='filter_metadata')
class Meta(object):
model = Question
fields = [
'creator',
'created',
'involved',
'is_archived',
'is_locked',
'is_spam',
'is_solved',
'locale',
'num_answers',
'product',
'title',
'topic',
'updated',
'updated_by',
]
def filter_involved(self, queryset, value):
creator_filter = Q(creator__username=value)
answer_creator_filter = Q(answers__creator__username=value)
return queryset.filter(creator_filter | answer_creator_filter)
def filter_is_solved(self, queryset, value):
field = serializers.BooleanField()
value = field.from_native(value)
filter = Q(solution=None)
if value:
filter = ~filter
return queryset.filter(filter)
def filter_metadata(self, queryset, value):
invalid_exc = GenericAPIException(
400, 'metadata must be a JSON object of strings.')
try:
value = json.loads(value)
except ValueError:
raise invalid_exc
def is_string(v):
return isinstance(v, six.string_types)
if not (isinstance(value, dict) and all(
isinstance(v, six.string_types) for v in value.values())):
raise invalid_exc
for name, value in value.items():
queryset = queryset.filter(metadata_set__name=name,
metadata_set__value=value)
return queryset
class CategoryFilter(django_filters.FilterSet):
parent_category = django_filters.MethodFilter(name="parent_category", action='is_parent_category')
font_awesome_icon_class = django_filters.MethodFilter(name="font_awesome_icon_class", action='valid_font_awesome_icon')
class Meta:
model = Category
fields = ['parent_category']
def is_parent_category(self, queryset, value):
bool_val = strtobool(value)
if bool_val:
# Client wants those categories that are parents
queryset = queryset.filter(parent_category__isnull=True)
else:
# Client wants those categories that are not parents
queryset = queryset.filter(parent_category__isnull=False)
return queryset
def valid_font_awesome_icon(self, queryset, value):
bool_val = strtobool(value)
if bool_val:
# Client wants those categories that are parents
queryset = queryset.exclude(font_awesome_icon_class__exact='')
else:
# Client wants those categories that are not parents
queryset = queryset.filter(font_awesome_icon_class__exact='')
return queryset
class EventParticipationFilter(django_filters.FilterSet):
account = CommaSeparatedValueFilter(name='account', lookup_type='in')
with_ranking = django_filters.MethodFilter(action='filter_with_ranking')
with_song_ranking = django_filters.MethodFilter(
action='filter_with_song_ranking')
with_points = django_filters.MethodFilter(action='filter_with_points')
event = django_filters.CharFilter('event__japanese_name')
language = django_filters.CharFilter('account__language')
def filter_with_ranking(self, queryset, value):
return queryset.filter(
ranking__isnull=(False if value.title() == 'True' else True))
def filter_with_song_ranking(self, queryset, value):
return queryset.filter(
song_ranking__isnull=(False if value.title() == 'True' else True))
def filter_with_points(self, queryset, value):
return queryset.filter(
points__isnull=(False if value.title() == 'True' else True))
class Meta:
model = models.EventParticipation
fields = ('account', 'event', 'language', 'with_ranking',
'with_song_ranking', 'with_points')
class MailFilter(DRFFilterSet):
last_status = django_filters.CharFilter(name='curstatus')
opened = django_filters.MethodFilter(action='_opened')
clicked = django_filters.MethodFilter(action='_clicked')
to = django_filters.CharFilter(name='recipient')
delivery_status = django_filters.MultipleChoiceFilter(
name='curstatus', choices=MailStatus.STATUS_CHOICES)
class Meta:
model = Mail
# TODO: To must be recipient in v2
fields = {
'to': ['exact'],
'last_status': ['exact'],
'delivery_status': ['exact'],
'source_ref': ['exact', 'startswith'],
'source_type': ['exact']
}
order_by = True
def _opened(self, queryset, value):
# Watch out, putting the same name for method and filter field
# overwrites the field
return queryset.opened()
def _clicked(self, queryset, value):
return queryset.clicked()
class WordFilter(filters.FilterSet):
creator = filters.CharFilter(name='creator__username')
first = filters.MethodFilter(action='search_by_first_letter')
def_like = filters.MethodFilter(action='search_by_word_in_definition')
empty = filters.MethodFilter(action='search_without_definition')
random = filters.MethodFilter(action='get_random_word')
class Meta:
model = models.Word
fields = ['label', 'creator', 'first', 'def_like']
def search_by_first_letter(self, queryset, value):
return queryset.filter(label__istartswith=value)
def search_by_word_in_definition(self, queryset, value):
return queryset.filter(definitions__text__icontains=value)
def search_without_definition(self, queryset, value):
empty = True if value == 'true' else False
return queryset.filter(definitions__isnull=empty)
def get_random_word(self, queryset, value):
ids = [word.id for word in queryset.all()]
if len(ids) > 1:
return queryset.filter(id=randint(ids[0], ids[-1]))
return queryset
class ProductFilter(django_filters.FilterSet):
query = django_filters.MethodFilter()
order = django_filters.MethodFilter()
list = django_filters.MethodFilter()
mall = django_filters.MethodFilter()
class Meta:
model = Product
fields = ['query', 'order', 'list', 'mall']
def filter_query(self, queryset, value):
return queryset.filter(
Q(product__name__icontains=value)
| Q(product__mall__name__icontains=value)
| Q(tags__name__icontains=value)).distinct()
def filter_order(self, queryset, value):
if (value == 'price-high'):
self.by = queryset.order_by('-product__price')
return self.by
elif (value == 'price-low'):
return queryset.order_by('product__price')
else:
return queryset
def filter_list(self, queryset, value):
if (value == 'favorite'):
return queryset.filter(Q(is_favorite=True))
elif (value == 'archive'):
return queryset.filter(Q(is_archived=True))
else:
return queryset
class DeviceUserFilter(django_filters.FilterSet):
query = django_filters.MethodFilter(action='filter_all')
location_country_codes = django_filters.MethodFilter()
games = django_filters.MethodFilter()
end_date = django_filters.MethodFilter()
begin_date = django_filters.MethodFilter()
class Meta:
model = DeviceUser
fields = [
Field.QUERY, Field.GAMES, Field.LOCATION_COUNTRY_CODES, Field.END,
Field.BEGIN
]
def filter_all(self, queryset, values):
values = str(values).split(" ")
for value in values:
queryset = queryset.filter(
Q(email__icontains=value) | Q(gpg_id__icontains=value)
| Q(gcm_id__icontains=value))
return queryset.distinct()
def filter_games(self, queryset, values):
games_ids = str(values).split(',')
return queryset.filter(game__id__in=games_ids)
def filter_location_country_codes(self, queryset, values):
country_codes = str(values).split(',')
return queryset.filter(
environment_info__location_country_code__in=country_codes)
def filter_end_date(self, queryset, values):
local = get_localzone()
end_date = parser.parse(values).astimezone(tz=local)
return queryset.filter(last_date_played__lte=end_date)
def filter_begin_date(self, queryset, values):
local = get_localzone()
begin_date = parser.parse(values).astimezone(tz=local)
return queryset.filter(last_date_played__gte=begin_date)
@staticmethod
def create_query_for_all_fields(data):
data = ast.literal_eval(data) if isinstance(data,
(str, unicode)) else data
query_data = {}
if Field.QUERY in data:
query_data[Field.QUERY] = data[Field.QUERY]
if Field.GAMES in data:
query_data[Field.GAMES] = data[Field.GAMES]
if Field.LOCATION_COUNTRY_CODES in data:
query_data[Field.LOCATION_COUNTRY_CODES] = data[
Field.LOCATION_COUNTRY_CODES]
return query_data
class NetworkFilter(ResourceFilter):
"""Filter for Network objects."""
include_networks = django_filters.MethodFilter()
include_ips = django_filters.MethodFilter()
network_address = django_filters.CharFilter()
cidr = django_filters.MethodFilter()
root_only = django_filters.MethodFilter()
class Meta:
model = models.Network
fields = [
'include_networks', 'include_ips', 'root_only', 'cidr',
'network_address', 'prefix_length', 'ip_version', 'state',
'attributes'
]
def filter_include_networks(self, queryset, value):
"""Converts ``include_networks`` to queryset filters."""
include_ips = qpbool(self.form.cleaned_data['include_ips'])
include_networks = qpbool(value)
if not all([include_networks, include_ips]):
if include_networks:
return queryset.filter(is_ip=False)
else:
return queryset.exclude(is_ip=False)
return queryset
def filter_include_ips(self, queryset, value):
"""Converts ``include_ips`` to queryset filters."""
include_ips = qpbool(value)
include_networks = qpbool(self.form.cleaned_data['include_networks'])
if not all([include_networks, include_ips]):
if include_ips:
return queryset.filter(is_ip=True)
else:
return queryset.exclude(is_ip=True)
return queryset
def filter_cidr(self, queryset, value):
"""Converts ``cidr`` to network/prefix filter."""
if value:
network_address, _, prefix_length = value.partition('/')
else:
return queryset
return queryset.filter(network_address=network_address,
prefix_length=prefix_length)
def filter_root_only(self, queryset, value):
"""Converts ``root_only`` to null parent filter."""
if qpbool(value):
return queryset.filter(parent=None)
return queryset
class IPAddressFilter(django_filters.FilterSet):
q = django_filters.MethodFilter(
action='search',
label='Search',
)
vrf = django_filters.MethodFilter(
action='_vrf',
label='VRF',
)
# Duplicate of `vrf` for backward-compatibility
vrf_id = django_filters.MethodFilter(
action='_vrf',
label='VRF',
)
device_id = django_filters.ModelMultipleChoiceFilter(
name='interface__device',
queryset=Device.objects.all(),
label='Device (ID)',
)
device = django_filters.ModelMultipleChoiceFilter(
name='interface__device',
queryset=Device.objects.all(),
to_field_name='name',
label='Device (name)',
)
interface_id = django_filters.ModelMultipleChoiceFilter(
name='interface',
queryset=Interface.objects.all(),
label='Interface (ID)',
)
class Meta:
model = IPAddress
fields = [
'q', 'family', 'vrf_id', 'vrf', 'device_id', 'device',
'interface_id'
]
def search(self, queryset, value):
value = value.strip()
try:
query = str(IPNetwork(value))
return queryset.filter(address__net_host=query)
except AddrFormatError:
return queryset.none()
def _vrf(self, queryset, value):
if str(value) == '':
return queryset
try:
vrf_id = int(value)
except ValueError:
return queryset.none()
if vrf_id == 0:
return queryset.filter(vrf__isnull=True)
return queryset.filter(vrf__pk=value)
class ComposeFilter(django_filters.FilterSet):
release = MultiValueCaseInsensitiveFilter(name='release__release_id')
compose_id = MultiValueCaseInsensitiveFilter(name='compose_id')
compose_type = MultiValueCaseInsensitiveFilter(name='compose_type__name')
acceptance_testing = MultiValueFilter(name='acceptance_testing__name')
srpm_name = MultiValueCaseInsensitiveFilter(
name='variant__variantarch__composerpm__rpm__srpm_name', distinct=True)
rpm_name = MultiValueCaseInsensitiveFilter(
name='variant__variantarch__composerpm__rpm__name', distinct=True)
rpm_version = MultiValueCaseInsensitiveFilter(
name='variant__variantarch__composerpm__rpm__version', distinct=True)
rpm_release = MultiValueCaseInsensitiveFilter(
name='variant__variantarch__composerpm__rpm__release', distinct=True)
rpm_arch = MultiValueCaseInsensitiveFilter(
name='variant__variantarch__composerpm__rpm__arch', distinct=True)
rpm_nvr = django_filters.MethodFilter(action="filter_nvr")
rpm_nvra = django_filters.MethodFilter(action="filter_nvra")
deleted = CaseInsensitiveBooleanFilter()
compose_date = MultiValueFilter(name='compose_date')
compose_respin = MultiValueFilter(name='compose_respin')
compose_label = MultiValueFilter(name='compose_label')
# TODO: return only latest compose
@value_is_not_empty
def filter_nvr(self, qs, value):
try:
nvr = kobo.rpmlib.parse_nvr(value)
except ValueError:
raise ValidationError("Invalid NVR: %s" % value)
q = Q()
q &= Q(variant__variantarch__composerpm__rpm__name=nvr["name"])
q &= Q(variant__variantarch__composerpm__rpm__version=nvr["version"])
q &= Q(variant__variantarch__composerpm__rpm__release=nvr["release"])
return qs.filter(q).distinct()
@value_is_not_empty
def filter_nvra(self, qs, value):
try:
nvra = kobo.rpmlib.parse_nvra(value)
except ValueError:
raise ValidationError("Invalid NVRA: %s" % value)
q = Q()
q &= Q(variant__variantarch__composerpm__rpm__name=nvra["name"])
q &= Q(variant__variantarch__composerpm__rpm__version=nvra["version"])
q &= Q(variant__variantarch__composerpm__rpm__release=nvra["release"])
q &= Q(variant__variantarch__composerpm__rpm__arch=nvra["arch"])
return qs.filter(q).distinct()
class Meta:
model = Compose
fields = ('deleted', 'compose_id', 'compose_date', 'compose_respin',
'compose_label', 'release', 'compose_type',
'acceptance_testing')
class CategoryFilter(django_filters.FilterSet):
id_in = django_filters.MethodFilter()
section = django_filters.MethodFilter()
name = django_filters.MethodFilter()
search = django_filters.MethodFilter()
class Meta:
model = Category
fields = (
"id_in",
"section",
"name",
)
order_by = [
'id', '-id', 'section', '-section', 'name', '-name', 'slug',
'-slug', 'position', '-position'
]
def filter_id_in(self, queryset, value):
return queryset.filter(id__in=get_id_list(value))
def filter_section(self, queryset, value):
return queryset.filter(section=get_section(value))
def filter_name(self, queryset, value):
return queryset.filter(name__icontains=value)
def filter_search(self, queryset, value):
search_fields = (
"name",
"section__name",
)
search_terms = value.replace(',', ' ').split()
if not search_fields or not search_terms:
return queryset
orm_lookups = [
self.construct_search(six.text_type(search_field))
for search_field in search_fields
]
base = queryset
for search_term in search_terms:
queries = [
models.Q(**{orm_lookup: search_term})
for orm_lookup in orm_lookups
]
queryset = queryset.filter(reduce(operator.or_, queries))
return distinct(queryset, base)
def construct_search(self, field_name):
return "%s__icontains" % field_name
class SeriesFilter(django_filters.FilterSet):
def filter_submitter(self, queryset, submitter):
try:
submitter = int(submitter)
queryset = queryset.filter(submitter=submitter)
except ValueError:
if submitter == 'self' and self.request.user.is_authenticated():
people = Person.objects.filter(user=self.request.user)
queryset = queryset.filter(submitter__in=people)
return queryset
def filter_reviewer(self, queryset, reviewer):
try:
reviewer = int(reviewer)
queryset = queryset.filter(reviewer=reviewer)
except ValueError:
if reviewer == 'null':
queryset = queryset.filter(reviewer__isnull=True)
return queryset
def filter_test_state(self, queryset, test_states):
if not test_states:
return queryset
try:
states = map(TestState.from_string, test_states.split(','))
queryset = queryset.filter(last_revision__test_state__in=states)
except KeyError:
if test_states == 'null':
queryset = queryset.filter(
last_revision__test_state__isnull=True)
return queryset
submitted_since = django_filters.CharFilter(name='submitted',
lookup_type='gt')
updated_since = django_filters.CharFilter(name='last_updated',
lookup_type='gt')
submitted_before = django_filters.CharFilter(name='submitted',
lookup_type='lte')
updated_before = django_filters.CharFilter(name='last_updated',
lookup_type='lte')
submitter = django_filters.MethodFilter()
reviewer = django_filters.MethodFilter()
test_state = django_filters.MethodFilter()
name = django_filters.CharFilter(lookup_type='icontains')
class Meta:
model = Series
fields = ['project']
class RuneInstanceFilter(django_filters.FilterSet):
type = django_filters.MultipleChoiceFilter(
choices=RuneInstance.TYPE_CHOICES)
slot = django_filters.MultipleChoiceFilter(choices=((1, 1), (2, 2), (3, 3),
(4, 4), (5, 5), (6,
6)))
quality = django_filters.MultipleChoiceFilter(
choices=RuneInstance.QUALITY_CHOICES)
original_quality = django_filters.MultipleChoiceFilter(
choices=RuneInstance.QUALITY_CHOICES)
main_stat = django_filters.MultipleChoiceFilter(
choices=RuneInstance.STAT_CHOICES)
innate_stat = django_filters.MultipleChoiceFilter(
choices=RuneInstance.STAT_CHOICES)
substats = django_filters.MethodFilter()
substat_logic = django_filters.MethodFilter()
assigned_to = django_filters.MethodFilter(action='filter_assigned_to')
class Meta:
model = RuneInstance
fields = {
'type': ['exact'],
'level': ['gte', 'lte'],
'stars': ['gte', 'lte'],
'slot': ['exact'],
'quality': ['exact'],
'original_quality': ['exact'],
'assigned_to': ['exact'],
'main_stat': ['exact'],
'innate_stat': ['exact'],
'marked_for_sale': ['exact'],
}
def filter_substats(self, queryset, value):
any_substat = self.form.cleaned_data.get('substat_logic', False)
if len(value):
if any_substat:
return queryset.filter(substats__overlap=value)
else:
return queryset.filter(substats__contains=value)
else:
return queryset
def filter_substat_logic(self, queryset, value):
# This field is just used to alter the logic of substat filter
return queryset
def filter_assigned_to(self, queryset, value):
return queryset.filter(assigned_to__isnull=not value)
class ProtocolFilter(ResourceFilter):
"""Filter for Protocol objects."""
device = django_filters.MethodFilter()
type = django_filters.MethodFilter()
interface = django_filters.MethodFilter()
circuit = django_filters.MethodFilter()
class Meta:
model = models.Protocol
fields = ['device', 'type', 'interface', 'circuit', 'description']
def filter_device(self, queryset, value):
"""Overload to use natural key."""
if isinstance(value, int):
value = str(value)
if value.isdigit():
return queryset.filter(device=value)
else:
return queryset.filter(device__hostname=value)
def filter_type(self, queryset, value):
"""Overload to use natural key."""
if isinstance(value, int):
value = str(value)
if value.isdigit():
return queryset.filter(type=value)
else:
return queryset.filter(type__name=value)
def filter_interface(self, queryset, value):
"""Overload to use natural key."""
if isinstance(value, int):
value = str(value)
if value.isdigit():
return queryset.filter(interface=value)
else:
return queryset.filter(interface__name_slug=value)
def filter_circuit(self, queryset, value):
"""Overload to use natural key."""
if isinstance(value, int):
value = str(value)
if value.isdigit():
return queryset.filter(circuit=value)
else:
return queryset.filter(circuit__name_slug=value)
class SiteFilter(django_filters.FilterSet):
q = django_filters.MethodFilter(
action='search',
label='Search',
)
tenant_id = django_filters.ModelMultipleChoiceFilter(
name='tenant',
queryset=Tenant.objects.all(),
label='Tenant (ID)',
)
tenant = django_filters.ModelMultipleChoiceFilter(
name='tenant',
queryset=Tenant.objects.all(),
to_field_name='slug',
label='Tenant (slug)',
)
class Meta:
model = Site
fields = ['q', 'name', 'facility', 'asn']
def search(self, queryset, value):
qs_filter = Q(name__icontains=value) | Q(facility__icontains=value) | Q(physical_address__icontains=value) | \
Q(shipping_address__icontains=value) | Q(comments__icontains=value)
try:
qs_filter |= Q(asn=int(value.strip()))
except ValueError:
pass
return queryset.filter(qs_filter)
class AggregateFilter(CustomFieldFilterSet, django_filters.FilterSet):
q = django_filters.MethodFilter(
action='search',
label='Search',
)
rir_id = django_filters.ModelMultipleChoiceFilter(
name='rir',
queryset=RIR.objects.all(),
label='RIR (ID)',
)
rir = django_filters.ModelMultipleChoiceFilter(
name='rir',
queryset=RIR.objects.all(),
to_field_name='slug',
label='RIR (slug)',
)
class Meta:
model = Aggregate
fields = ['family', 'rir_id', 'rir', 'date_added']
def search(self, queryset, value):
qs_filter = Q(description__icontains=value)
try:
prefix = str(IPNetwork(value.strip()).cidr)
qs_filter |= Q(prefix__net_contains_or_equals=prefix)
except AddrFormatError:
pass
return queryset.filter(qs_filter)
class VRFFilter(CustomFieldFilterSet, django_filters.FilterSet):
q = django_filters.MethodFilter(
action='search',
label='Search',
)
name = django_filters.CharFilter(
name='name',
lookup_type='icontains',
label='Name',
)
tenant_id = django_filters.ModelMultipleChoiceFilter(
name='tenant',
queryset=Tenant.objects.all(),
label='Tenant (ID)',
)
tenant = django_filters.ModelMultipleChoiceFilter(
name='tenant',
queryset=Tenant.objects.all(),
to_field_name='slug',
label='Tenant (slug)',
)
def search(self, queryset, value):
return queryset.filter(
Q(name__icontains=value) | Q(rd__icontains=value)
| Q(description__icontains=value))
class Meta:
model = VRF
fields = ['name', 'rd']
class RackFilter(CustomFieldFilterSet, django_filters.FilterSet):
q = django_filters.MethodFilter(
action='search',
label='Search',
)
site_id = django_filters.ModelMultipleChoiceFilter(
name='site',
queryset=Site.objects.all(),
label='Site (ID)',
)
site = django_filters.ModelMultipleChoiceFilter(
name='site',
queryset=Site.objects.all(),
to_field_name='slug',
label='Site (slug)',
)
group_id = NullableModelMultipleChoiceFilter(
name='group',
queryset=RackGroup.objects.all(),
label='Group (ID)',
)
group = NullableModelMultipleChoiceFilter(
name='group',
queryset=RackGroup.objects.all(),
to_field_name='slug',
label='Group',
)
tenant_id = NullableModelMultipleChoiceFilter(
name='tenant',
queryset=Tenant.objects.all(),
label='Tenant (ID)',
)
tenant = NullableModelMultipleChoiceFilter(
name='tenant',
queryset=Tenant.objects.all(),
to_field_name='slug',
label='Tenant (slug)',
)
role_id = NullableModelMultipleChoiceFilter(
name='role',
queryset=RackRole.objects.all(),
label='Role (ID)',
)
role = NullableModelMultipleChoiceFilter(
name='role',
queryset=RackRole.objects.all(),
to_field_name='slug',
label='Role (slug)',
)
class Meta:
model = Rack
fields = ['q', 'site_id', 'site', 'u_height']
def search(self, queryset, value):
return queryset.filter(
Q(name__icontains=value) |
Q(facility_id__icontains=value) |
Q(comments__icontains=value)
)
class ReleaseFilter(django_filters.FilterSet):
release_id = filters.MultiValueFilter(name='release_id')
base_product = filters.MultiValueFilter(
name='base_product__base_product_id')
has_base_product = django_filters.MethodFilter(
action='find_has_base_product')
release_type = filters.MultiValueFilter(name='release_type__short')
product_version = filters.MultiValueFilter(
name='product_version__product_version_id')
integrated_with = filters.NullableCharFilter(
name='integrated_with__release_id')
active = filters.CaseInsensitiveBooleanFilter()
name = filters.MultiValueFilter(name='name')
short = filters.MultiValueFilter(name='short')
version = filters.MultiValueFilter(name='version')
class Meta:
model = Release
fields = ("release_id", "name", "short", "version", 'product_version',
"release_type", "base_product", 'active', 'integrated_with')
def find_has_base_product(self, queryset, value, *args, **kwargs):
"""
Make it possible to filter releases if base_product is null or not.
"""
if value == 'True':
return queryset.filter(base_product__isnull=False).distinct()
elif value == 'False':
return queryset.filter(base_product__isnull=True).distinct()
return queryset
class ExportConfigFilter(django_filters.FilterSet):
"""Filter export configurations."""
name = django_filters.CharFilter(name="name", lookup_type="icontains")
config_type = django_filters.CharFilter(name="config_type",
lookup_type="icontains")
start = django_filters.DateTimeFilter(name="created_at", lookup_type="gte")
end = django_filters.DateTimeFilter(name="created_at", lookup_type="lte")
user = django_filters.CharFilter(name="user__username",
lookup_type="exact")
published = django_filters.BooleanFilter(name="published",
lookup_type="exact")
user_private = django_filters.MethodFilter(action='user_private_filter')
class Meta:
model = ExportConfig
fields = ('name', 'config_type', 'start', 'end', 'user', 'published',
'user_private')
order_by = ('-created_at', )
def user_private_filter(self, queryset, value):
"""
Filter export configurations by user and/or published status.
Return configurations for the specified user where configurations are either published or unpublished.
OR
Return configurations for all other users and where the configuration is published.
"""
return queryset.filter(
(Q(user__username=value) |
(~Q(user__username=value) & Q(published=True))))
class JobFilter(django_filters.FilterSet):
"""Filter export results according to a range of criteria."""
name = django_filters.CharFilter(name="name", lookup_type="icontains")
description = django_filters.CharFilter(name="description",
lookup_type="icontains")
event = django_filters.CharFilter(name="event", lookup_type="icontains")
start = django_filters.DateTimeFilter(name="created_at", lookup_type="gte")
end = django_filters.DateTimeFilter(name="created_at", lookup_type="lte")
user = django_filters.CharFilter(name="user__username",
lookup_type="exact")
feature = django_filters.CharFilter(name="tags__name",
lookup_type="icontains")
published = django_filters.BooleanFilter(name="published",
lookup_type="exact")
user_private = django_filters.MethodFilter(action='user_private_filter')
class Meta:
model = Job
fields = ('name', 'description', 'event', 'start', 'end', 'user',
'user_private', 'feature', 'published')
order_by = ('-created_at', )
def user_private_filter(self, queryset, value):
"""
Filter export results by user and/or published status.
Return exports for the specified user where exports are either published or unpublished.
OR
Return exports for all other users and where the export is published.
"""
return queryset.filter(
(Q(user__username=value) |
(~Q(user__username=value) & Q(published=True))))
class CommunityHealthUnitFilter(CommonFieldsFilterset):
def chu_pending_approval(self, value):
if value in TRUTH_NESS:
return self.filter(
Q(is_approved=False, is_rejected=False, has_edits=False)
| Q(is_approved=True, is_rejected=False, has_edits=True)
| Q(is_approved=False, is_rejected=True, has_edits=True))
else:
return self.filter(
Q(is_approved=True, is_rejected=False, has_edits=False)
| Q(is_approved=False, is_rejected=True, has_edits=False))
name = django_filters.CharFilter(lookup_type='icontains')
ward = ListCharFilter(name='facility__ward')
constituency = ListCharFilter(name='facility__ward__constituency')
county = ListCharFilter(name='facility__ward__constituency__county')
is_approved = django_filters.TypedChoiceFilter(choices=BOOLEAN_CHOICES,
coerce=strtobool)
is_rejected = django_filters.TypedChoiceFilter(choices=BOOLEAN_CHOICES,
coerce=strtobool)
has_edits = django_filters.TypedChoiceFilter(choices=BOOLEAN_CHOICES,
coerce=strtobool)
pending_approval = django_filters.MethodFilter(action=chu_pending_approval)
class Meta(object):
model = CommunityHealthUnit
