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