class CourseFilter(django_filters.FilterSet): class Meta: model = Course fields = '__all__' has_grades = django_filters.BooleanFilter(method='filter_has_grades') # overrides Course.has_enrollment. TODO: Remove Course.has_enrollment soon has_enrollment = django_filters.BooleanFilter(method='filter_has_enrollment') in_playlists = django_filters.BaseInFilter(method='filter_in_playlists') id_in = django_filters.BaseInFilter(method='filter_id_in') def filter_has_grades(self, queryset, name, value): return queryset.exclude(grade__isnull=value) def filter_has_enrollment(self, queryset, name, value): return queryset.exclude(section__isnull=value) def filter_in_playlists(self, queryset, name, value): playlist_ids = list(map(lambda global_id: from_global_id(global_id)[1], value)) categories = Playlist.objects.filter(id__in=playlist_ids).distinct('category').values_list('category', flat=True) all_reduce = queryset for category in categories: playlists = Playlist.objects.filter(id__in=playlist_ids, category=category) intersected = [playlist.courses.all() for playlist in playlists] if category in ('university', 'ls', 'engineering', 'haas'): all_reduce &= all_reduce & reduce(lambda x, y: x & y, intersected) else: all_reduce &= all_reduce & reduce(lambda x, y: x | y, intersected) return all_reduce def filter_id_in(self, queryset, name, value): course_ids = list(map(lambda global_id: from_global_id(global_id)[1], value)) return queryset.filter(id__in=course_ids)
class SurveyObsFilter(django_filters.FilterSet): status_in = django_filters.BaseInFilter( field_name="status__name") #, lookup_expr='in') obs_mjd_gte = django_filters.Filter(field_name="obs_mjd", lookup_expr='gte') obs_mjd_lte = django_filters.Filter(field_name="obs_mjd", lookup_expr='lte') mjd_requested_gte = django_filters.Filter(field_name="mjd_requested", lookup_expr='gte') mjd_requested_lte = django_filters.Filter(field_name="mjd_requested", lookup_expr='lte') survey_field = django_filters.BaseInFilter( field_name="survey_field__field_id") obs_group = django_filters.BaseInFilter( field_name="survey_field__obs_group__name") ra_gt = django_filters.Filter(field_name="survey_field__ra_cen", lookup_expr='gt') ra_lt = django_filters.Filter(field_name="survey_field__ra_cen", lookup_expr='lt') dec_gt = django_filters.Filter(field_name="survey_field__dec_cen", lookup_expr='gt') dec_lt = django_filters.Filter(field_name="survey_field__dec_cen", lookup_expr='lt') class Meta: model = SurveyObservation fields = ()
class DonationCustomFilter(django_filters.FilterSet): patient = django_filters.BaseInFilter(method="search_in_patient") medical_staff = django_filters.BaseInFilter(method="search_in_medical_staff") class Meta: model = Donation fields = { "id": ["in"], "date_of_donation": [ "exact", "icontains", "gt", "gte", "lt", "lte", "year", "month", "day", ], "accept_donate": ["exact"], "refuse_information": ["icontains"], } def search_in_medical_staff(self, queryset, name, value): return queryset.filter(medical_staff_id__in=value) def search_in_patient(self, queryset, name, value): return queryset.filter(patient_id__in=value)
class ScoreFilterSet(filters.FilterSet): id = AllInFilter() digital_object = filters.BaseInFilter(field_name='target') url = filters.CharFilter(field_name='target__url', lookup_expr='icontains') metric = filters.BaseInFilter(field_name='rubric__metrics') class Meta: model = models.Assessment exclude = ('timestamp', )
class BlsOesFilter(django_filters.FilterSet): """ Create a filter to use with the BlsOes model. When multiple options are chosen in these filters, there must be no space between comma-separated values """ socs = django_filters.BaseInFilter(field_name='soc_code', lookup_expr='in') areas = django_filters.BaseInFilter(field_name='area_title', lookup_expr='in') class Meta: model = BlsOes fields = ['socs', 'areas']
class BandComboFilter(django_filters.FilterSet): colours = django_filters.BaseInFilter(lookup_expr='contains') symbols = django_filters.BaseInFilter(lookup_expr='contains') is_extended = django_filters.BooleanFilter(name='bird__bird_extended__is_extended', lookup_expr='isnull', exclude=True, label='Is extended') is_featured = django_filters.BooleanFilter(name='bird__bird_extended__is_featured', label='Is featured') class Meta: model = BandCombo fields = ('style', 'study_area', 'bird__status',)
class PresentationFilter(django_filters.FilterSet): search = django_filters.CharFilter(method='search_filter') summit_id = django_filters.NumberFilter(field_name='summit__id') is_rsvp = django_filters.BooleanFilter(method='rsvp_filter') has_feedback = django_filters.BooleanFilter(method='feedback_filter') track = django_filters.BaseInFilter(field_name='category__id') room = django_filters.BaseInFilter(field_name='location__id') tag_id = django_filters.NumberFilter(field_name='tags__id') has_video = django_filters.BooleanFilter(method='video_filter') status = django_filters.CharFilter(method='status_filter') class Meta: model = Presentation fields = ['title', 'abstract', 'summit__id', 'published', 'status'] def search_filter(self, queryset, name, value): queryset = queryset.filter( models.Q(title__icontains=value) | models.Q(abstract__icontains=value) | models.Q(speakers__last_name=value) | models.Q(speakers__member__email=value)) return queryset.distinct() def room_filter(self, queryset, name, value): queryset = queryset.filter( models.Q(category__title=value) | models.Q(category__code=value)) return queryset def rsvp_filter(self, queryset, name, value): queryset = queryset.exclude(rsvp_template__isnull=True).exclude( rsvp_template__id=0) return queryset def feedback_filter(self, queryset, name, value): return queryset.annotate( feedback_count=models.Count('feedback'), rate=models.Avg('feedback__rate')).filter(feedback_count__gt=0) def video_filter(self, queryset, name, value): return queryset.annotate( video_count=models.Count('materials__presentationvideo')).filter( video_count__gt=0) def status_filter(self, queryset, name, value): if (value == 'null'): return queryset.filter(status__isnull=True) else: return queryset.filter(status=value)
class TransientFilter(django_filters.FilterSet): created_date_gte = django_filters.DateTimeFilter(name="created_date", lookup_expr='gte') modified_date_gte = django_filters.DateTimeFilter(name="modified_date", lookup_expr='gte') status_in = django_filters.BaseInFilter( name="status__name") #, lookup_expr='in') ra_gte = django_filters.Filter(name="ra", lookup_expr='gte') ra_lte = django_filters.Filter(name="ra", lookup_expr='lte') dec_gte = django_filters.Filter(name="dec", lookup_expr='gte') dec_lte = django_filters.Filter(name="dec", lookup_expr='lte') tag_in = django_filters.BaseInFilter(name="tags__name") class Meta: model = Transient fields = ('created_date', 'modified_date')
class ScienceApplicationFilter(django_filters.FilterSet): status = django_filters.ChoiceFilter( choices=ScienceApplication.STATUS_CHOICES) exclude_status = django_filters.ChoiceFilter( choices=ScienceApplication.STATUS_CHOICES, exclude=True, field_name='status') proposal_type = django_filters.ChoiceFilter( choices=Call.PROPOSAL_TYPE_CHOICES, field_name='call__proposal_type') exclude_proposal_type = django_filters.ChoiceFilter( choices=Call.PROPOSAL_TYPE_CHOICES, exclude=True, field_name='call__proposal_type') only_authored = django_filters.BooleanFilter(method='filter_only_authored') tags = django_filters.BaseInFilter(method='filter_has_tag', label='Comma separated list of tags') class Meta: model = ScienceApplication fields = ('call', 'status', 'exclude_status', 'proposal_type', 'exclude_proposal_type', 'only_authored') def filter_only_authored(self, queryset, name, value): if value: return queryset.filter(submitter=self.request.user) else: return queryset def filter_has_tag(self, queryset, name, value): return queryset.filter(tags__overlap=value)
class ProductParentFilter(django_filters.FilterSet): #having problem so decided to custom filter for __in parent2product__cat__cat_id__in = django_filters.BaseInFilter( field_name="parent2product__cat__cat_id", lookup_expr='in') class Meta: model = ProductParent fields = ("parent2product__cat__cat_id", )
class JobFilterSet(filters.FilterSet): id = filters.BaseInFilter(widget=forms.HiddenInput) is_active = filters.BooleanFilter() tags = filters.MultipleChoiceFilter(choices=get_tags) class Meta: model = models.Job fields = []
class ProductFilter(FilterSet): # brand_in = django_filters.CharFilter(field_name="brand", lookup_expr="iexact") brand__in = django_filters.BaseInFilter(field_name="brand", lookup_expr="in") list_price__gt = django_filters.BaseRangeFilter(field_name="list_price", lookup_expr="range") # sizes__in = django_filters.BaseCSVFilter(field_name="sizes",lookup_expr="in") sizes__in = SizeFilter(field_name="sizes", lookup_expr="contains") colors__in = ColorsFilter(field_name="colors", lookup_expr="contains") # def sizes__in(self,queryset,value,**args,**kwargs): # return queryset # sizes__in = ListFilter(field_name="sizes") # sizes__in = django_filters.( # field_name="sizes", # lookup_expr='in', # # lookup_expr='icontains', # # conjoined=False, # # choices=["S,M,L"], # ) # colors__in = django_filters.BaseInFilter(field_name="color",lookup_expr="in") # sizes = graphene.List(graphene.String) # size__in = django_filters.MultipleChoiceFilter(field_name="sizes",lookup_expr="in") # sizes__in = django_filters.BaseInFilter(field_name="brand",lookup_expr="in") class Meta: model = Product fields = '__all__' filter_fields = { "isActive": ["exact"], "parent": ["lte", "gte", "exact", "isnull"], "sizes": ["in", "icontains", "exact", "iexact"], "list_price": ["lte", "gte"], "brand": ["in"] } # brands = django_filters.MultipleChoiceFilter( # # field_class = CharField, # # lookup_choices=("in",) # lookup_expr="in" # ) order_by = OrderingFilter( fields=(('id', 'brand', 'name', 'list_price', 'mrp')), # lookup_expr="iexect" # filter_fields = { # "isActive":["exact"], # "parent":["lte","gte","exact","isnull"], # "sizes":["in","icontains","exact","iexact"], # "list_price":["lte","gte"], # "brand":["in"] # } )
class TripBaseFilter(filters.FilterSet): name = filters.CharFilter(field_name='name', lookup_expr=('icontains')) destination = filters.BaseInFilter(field_name="destination__slug") duration_from = filters.NumberFilter(field_name='duration', lookup_expr=('gte')) duration_to = filters.NumberFilter(field_name='duration', lookup_expr=('lte')) class Meta: model = Trip fields = ('destination',)
class SummitEventFilter(django_filters.FilterSet): search = django_filters.CharFilter(method='search_filter') summit_id = django_filters.NumberFilter(field_name='summit__id') track = django_filters.BaseInFilter(field_name='category__id') room = django_filters.BaseInFilter(field_name='location__id') type = django_filters.BaseInFilter(field_name='type__id') type_class = django_filters.CharFilter(field_name='type__class_name') class_name = django_filters.CharFilter(field_name='class_name') def search_filter(self, queryset, name, value): queryset = queryset.filter( models.Q(title__icontains=value) | models.Q(category__title__icontains=value) | models.Q(presentation__speakers__last_name=value)) return queryset.distinct() class Meta: model = SummitEvent fields = ['id', 'title', 'published', 'start_date', 'end_date']
class WorkflowLevel2Filter(django_filters.FilterSet): create_date = django_filters.DateFromToRangeFilter( widget=DateRangeWidget()) project_id__isnull = django_filters.BooleanFilter(field_name='project_id', lookup_expr='isnull') status__short_name = django_filters.BaseInFilter() status__uuid = django_filters.BaseInFilter() class Meta: model = WorkflowLevel2 fields = [ 'workflowlevel1__name', 'workflowlevel1__id', 'create_date', 'status__short_name', 'status__uuid', 'project_id', ]
class BrandListFilters(SimpleIdListFilter): category_id = django_filters.BaseInFilter(method="category_filter") def category_filter(self, queryset, name, value): filter_list = get_numeric_filter_list(value) return queryset.filter(**{ "product__category__pk__in": filter_list }).distinct() class Meta: model = Brand fields = ('id', )
class SurveyObsFilter(django_filters.FilterSet): status_in = django_filters.BaseInFilter( name="status__name") #, lookup_expr='in') obs_mjd_gte = django_filters.Filter(name="obs_mjd", lookup_expr='gte') obs_mjd_lte = django_filters.Filter(name="obs_mjd", lookup_expr='lte') mjd_requested_gte = django_filters.Filter(name="mjd_requested", lookup_expr='gte') mjd_requested_lte = django_filters.Filter(name="mjd_requested", lookup_expr='lte') class Meta: model = SurveyObservation fields = ()
class ProductNode(DjangoObjectType): #having problem so decided to custom filter for __in cat__cat_id__in = django_filters.BaseInFilter(field_name="cat__cat_id", lookup_expr='in') class Meta: model = Product interfaces = (relay.Node, ) filter_fields = { "title": ["exact", "icontains", "istartswith"], "sku": ["exact"], "cat__cat_name": ["exact", "icontains"], "cat__cat_id": ["exact"] }
class PropertyFilter(df.FilterSet): id = df.BaseInFilter(field_name="pk") country = df.CharFilter(field_name='location__city__country__name') city = df.CharFilter(field_name='location__city__name') city_id = df.NumberFilter(field_name='location__city__pk') amenities = df.BaseInFilter(field_name='amenities__name') facilities = df.BaseInFilter(field_name='facilities__name') tags = df.BaseInFilter(field_name='tags__name') max_price = df.NumberFilter(field_name='price', lookup_expr='lte') min_price = df.NumberFilter(field_name='price', lookup_expr='gte') bedroom_number = df.NumberFilter(field_name='bedroom_number') bedroom_number_gte = df.NumberFilter(field_name='bedroom_number', lookup_expr='gte') bathroom_number = df.NumberFilter(field_name='bathroom_number', lookup_expr='gte') seller_id = df.NumberFilter(field_name='seller__id') class Meta: model = Property fields = [ 'id', 'bedroom_number', 'country', 'city', 'city_id', 'bathroom_number', 'amenities', 'facilities', 'tags', 'max_price', 'min_price', 'seller_id', 'bedroom_number_gte' ]
class ProposalFilter(django_filters.FilterSet): semester = django_filters.ModelChoiceFilter( label="Semester", distinct=True, queryset=Semester.objects.all().order_by('-start')) active = django_filters.ChoiceFilter(choices=((False, 'Inactive'), (True, 'Active')), empty_label='All') tags = django_filters.BaseInFilter(method='filter_has_tag', label='Comma separated list of tags') class Meta: model = Proposal fields = ('active', 'semester', 'id', 'tac_rank', 'tac_priority', 'public', 'title') def filter_has_tag(self, queryset, name, value): return queryset.filter(tags__overlap=value)
class CategoryListFilters(SimpleIdListFilter): top_level_only = django_filters.BooleanFilter( method="top_level_only_filter") brand_id = django_filters.BaseInFilter(method="brand_filter") def brand_filter(self, queryset, name, value): filter_list = get_numeric_filter_list(value) return queryset.filter(**{ "product__brand__pk__in": filter_list }).distinct() def top_level_only_filter(self, queryset, name, value): return queryset.filter(**{ "parent__isnull": value, }) class Meta: model = Category fields = ('id', )
class ProductFilter(django_filters.rest_framework.FilterSet): sale_price = django_filters.RangeFilter(name="sale_price") # min_sale_price = django_filters.NumberFilter(name="sale_price", lookup_expr='gte') # max_sale_price = django_filters.NumberFilter(name="sale_price", lookup_expr='lte') categories = django_filters.BaseInFilter(name="categories", method='filter_categories') def filter_categories(self, queryset, name, value): """ Filter categories. """ # value is already split as csv, by the BaseInFilter(BaseCSVFilter) class. tree = Category.get_tree_active(value) ids = [c.id for c in tree] return queryset.filter(categories__id__in=ids) class Meta: model = Product fields = ['categories', 'sale_price']
class PatientCustomFilter(django_filters.FilterSet): can_donate = django_filters.BooleanFilter(field_name="can_donate") search = django_filters.CharFilter(method="full_search") registered_by = django_filters.BaseInFilter(method="search_in_registered_by") class Meta: model = Patient fields = { "id": ["in"], "first_name": ["exact", "icontains"], "last_name": ["exact", "icontains"], "pesel": ["exact", "icontains"], "blood_group": ["exact", "icontains"], "gender": ["exact"], "email": ["exact", "icontains"], "phone_number": ["exact", "icontains"], "date_of_register": [ "exact", "icontains", "gt", "gte", "lt", "lte", "year", "month", "day", ] } def full_search(self, queryset, name, value): # full search in given fields return queryset.filter( Q(first_name__icontains=value) | Q(last_name__icontains=value) | Q(pesel__icontains=value) | Q(email__icontains=value) | Q(phone_number__icontains=value) ) def search_in_registered_by(self, queryset, name, value): return queryset.filter(registered_by_id__in=value)
class SimpleIdListFilter(django_filters.rest_framework.FilterSet): id = django_filters.BaseInFilter(method='id_filter') def id_filter(self, queryset, name, value): filter_list = get_numeric_filter_list(value) return queryset.filter(**{"id__in": filter_list})
class BarrierFilterSet(django_filters.FilterSet): """ Custom FilterSet to handle all necessary filters on Barriers reported_on_before: filter start date dd-mm-yyyy reported_on_after: filter end date dd-mm-yyyy cateogory: int, one or more comma seperated category ids ex: category=1 or category=1,2 sector: uuid, one or more comma seperated sector UUIDs ex: sector=af959812-6095-e211-a939-e4115bead28a sector=af959812-6095-e211-a939-e4115bead28a,9538cecc-5f95-e211-a939-e4115bead28a status: int, one or more status id's. ex: status=1 or status=1,2 location: UUID, one or more comma seperated overseas region/country/state UUIDs ex: location=a25f66a0-5d95-e211-a939-e4115bead28a location=a25f66a0-5d95-e211-a939-e4115bead28a,955f66a0-5d95-e211-a939-e4115bead28a priority: priority code, one or more comma seperated priority codes ex: priority=UNKNOWN or priority=UNKNOWN,LOW text: combination custom search across multiple fields. Searches for reference code, barrier title and barrier summary """ reported_on = django_filters.DateFromToRangeFilter("reported_on") sector = django_filters.BaseInFilter(method="sector_filter") status = django_filters.BaseInFilter("status") category = django_filters.BaseInFilter("categories", distinct=True) priority = django_filters.BaseInFilter(method="priority_filter") location = django_filters.BaseInFilter(method="location_filter") search = django_filters.Filter(method="text_search") text = django_filters.Filter(method="text_search") user = django_filters.Filter(method="my_barriers") team = django_filters.Filter(method="team_barriers") member = django_filters.Filter(method="member_filter") archived = django_filters.BooleanFilter("archived", widget=BooleanWidget) economic_assessment = django_filters.BaseInFilter(method="economic_assessment_filter") economic_impact_assessment = django_filters.BaseInFilter(method="economic_impact_assessment_filter") public_view = django_filters.BaseInFilter(method="public_view_filter") tags = django_filters.BaseInFilter(method="tags_filter") trade_direction = django_filters.BaseInFilter("trade_direction") wto = django_filters.BaseInFilter(method="wto_filter") organisation = django_filters.BaseInFilter("organisations", distinct=True) commodity_code = django_filters.BaseInFilter(method="commodity_code_filter") commercial_value_estimate = django_filters.BaseInFilter(method="commercial_value_estimate_filter") class Meta: model = Barrier fields = [ "country", "category", "sector", "reported_on", "status", "priority", "archived", ] def __init__(self, *args, **kwargs): if kwargs.get("user"): self.user = kwargs.pop("user") return super().__init__(*args, **kwargs) def get_user(self): if hasattr(self, "user"): return self.user if self.request is not None: return self.request.user def sector_filter(self, queryset, name, value): """ custom filter for multi-select filtering of Sectors field, which is ArrayField """ return queryset.filter( Q(all_sectors=True) | Q(sectors__overlap=value) ) def priority_filter(self, queryset, name, value): """ customer filter for multi-select of priorities field by code rather than priority id. UNKNOWN would either mean, UNKNOWN is set in the field or priority is not yet set for that barrier """ UNKNOWN = "UNKNOWN" priorities = BarrierPriority.objects.filter(code__in=value) if UNKNOWN in value: return queryset.filter( Q(priority__isnull=True) | Q(priority__in=priorities) ) else: return queryset.filter(priority__in=priorities) def clean_location_value(self, value): """ Splits a list of locations into countries, regions and trading blocs """ location_values = [] overseas_region_values = [] trading_bloc_values = [] overseas_region_countries = [] for location in value: if location in TRADING_BLOCS: trading_bloc_values.append(location) else: location_values.append(location) # Add all countries within the overseas regions for country in cache.get_or_set("dh_countries", get_countries, 72000): if country["overseas_region"] and country["overseas_region"]["id"] in location_values: overseas_region_countries.append(country["id"]) if country["overseas_region"]["id"] not in overseas_region_values: overseas_region_values.append(country["overseas_region"]["id"]) # Add all trading blocs associated with the overseas regions for overseas_region in overseas_region_values: for trading_bloc in TRADING_BLOCS.values(): if overseas_region in trading_bloc["overseas_regions"]: trading_bloc_values.append(trading_bloc["code"]) return { "countries": [ location for location in location_values if location not in overseas_region_values ], "overseas_regions": overseas_region_values, "overseas_region_countries": overseas_region_countries, "trading_blocs": trading_bloc_values, } def location_filter(self, queryset, name, value): """ custom filter for retrieving barriers of all countries of an overseas region """ location = self.clean_location_value(value) tb_queryset = queryset.none() if location["trading_blocs"]: tb_queryset = queryset.filter(trading_bloc__in=location["trading_blocs"]) if "country_trading_bloc" in self.data: trading_bloc_countries = [] for trading_bloc in self.data["country_trading_bloc"].split(","): trading_bloc_countries += get_trading_bloc_country_ids(trading_bloc) tb_queryset = tb_queryset | queryset.filter( country__in=trading_bloc_countries, caused_by_trading_bloc=True, ) return tb_queryset | queryset.filter( Q(country__in=location["countries"]) | Q(country__in=location["overseas_region_countries"]) | Q(admin_areas__overlap=location["countries"]) ) def text_search(self, queryset, name, value): """ custom text search against multiple fields full value of code full text search on summary partial search on title """ return queryset.annotate( search=SearchVector('summary'), ).filter( Q(code=value) | Q(search=value) | Q(title__icontains=value) | Q(public_barrier__id=value.lstrip("PID-").upper()) ) def my_barriers(self, queryset, name, value): if value: current_user = self.get_user() qs = queryset.filter(created_by=current_user) return qs return queryset def team_barriers(self, queryset, name, value): if value: current_user = self.get_user() return queryset.filter( Q(barrier_team__user=current_user) & Q(barrier_team__archived=False) ).distinct() return queryset def member_filter(self, queryset, name, value): if value: member = get_object_or_404(TeamMember, pk=value) return queryset.filter(barrier_team__user=member.user).distinct() return queryset def public_view_filter(self, queryset, name, value): public_queryset = queryset.none() if "changed" in value: value.remove("changed") changed_ids = queryset.annotate( change=Concat( "cached_history_items__model", V("."), "cached_history_items__field", output_field=CharField(), ), change_date=F("cached_history_items__date"), ).filter( public_barrier___public_view_status=PublicBarrierStatus.PUBLISHED, change_date__gt=F("public_barrier__last_published_on"), change__in=( "barrier.categories", "barrier.location", "barrier.sectors", "barrier.status", "barrier.summary", "barrier.title", ), ).values_list("id", flat=True) public_queryset = queryset.filter(id__in=changed_ids) if "not_yet_sifted" in value: value.remove("not_yet_sifted") public_queryset = queryset.filter(public_eligibility=None) status_lookup = { "unknown": PublicBarrierStatus.UNKNOWN, "ineligible": PublicBarrierStatus.INELIGIBLE, "eligible": PublicBarrierStatus.ELIGIBLE, "ready": PublicBarrierStatus.READY, "published": PublicBarrierStatus.PUBLISHED, "unpublished": PublicBarrierStatus.UNPUBLISHED, } statuses = [status_lookup.get(status) for status in value if status in status_lookup.keys()] public_queryset = public_queryset | queryset.filter(public_barrier___public_view_status__in=statuses) return queryset & public_queryset def tags_filter(self, queryset, name, value): return queryset.filter(tags__in=value).distinct() def wto_filter(self, queryset, name, value): wto_queryset = queryset.none() if "wto_has_been_notified" in value: wto_queryset = wto_queryset | queryset.filter( wto_profile__wto_has_been_notified=True ) if "wto_should_be_notified" in value: wto_queryset = wto_queryset | queryset.filter( wto_profile__wto_should_be_notified=True ) if "has_raised_date" in value: wto_queryset = wto_queryset | queryset.filter( wto_profile__raised_date__isnull=False ) if "has_committee_raised_in" in value: wto_queryset = wto_queryset | queryset.filter( wto_profile__committee_raised_in__isnull=False ) if "has_case_number" in value: wto_queryset = wto_queryset | queryset.filter( wto_profile__isnull=False ).exclude(wto_profile__case_number="") if "has_no_information" in value: wto_queryset = wto_queryset | queryset.filter(wto_profile__isnull=True) return queryset & wto_queryset def economic_assessment_filter(self, queryset, name, value): assessment_queryset = queryset.none() if "with" in value: assessment_queryset = assessment_queryset | queryset.filter( economic_assessments__archived=False, ).distinct() if "without" in value: assessment_queryset = assessment_queryset | queryset.filter( economic_assessments__isnull=True, ).distinct() if "ready_for_approval" in value: assessment_queryset = assessment_queryset | queryset.filter( economic_assessments__archived=False, economic_assessments__ready_for_approval=True, economic_assessments__approved__isnull=True, ).distinct() return queryset.distinct() & assessment_queryset def economic_impact_assessment_filter(self, queryset, name, value): assessment_queryset = queryset.none() if "with" in value: assessment_queryset = assessment_queryset | queryset.filter( economic_assessments__economic_impact_assessments__archived=False, ).distinct() if "without" in value: assessment_queryset = assessment_queryset | queryset.filter( economic_assessments__economic_impact_assessments__isnull=True, ).distinct() return queryset.distinct() & assessment_queryset def commodity_code_filter(self, queryset, name, value): filters = Q() if "with" in value: filters &= ~Q(commodities=None) if "without" in value: filters &= Q(commodities=None) return queryset.filter(filters).distinct() def commercial_value_estimate_filter(self, queryset, name, value): filters = Q() if "with" in value: filters &= ~Q(commercial_value=None) if "without" in value: filters &= Q(commercial_value=None) return queryset.filter(filters).distinct()
class ProductListFilter(django_filters.rest_framework.FilterSet): brand_id = django_filters.BaseInFilter(method="brand_filter") category_id = django_filters.BaseInFilter(method="category_filter") has_map_price = django_filters.BooleanFilter(method="has_map_price_filter", label="Has Map Price") min_map = django_filters.NumberFilter(name="map_price", lookup_expr='gte') max_map = django_filters.NumberFilter(name="map_price", lookup_expr='lte') is_universal_fitment = django_filters.BooleanFilter( method="is_universal_fitment_filter", label="Universal Fitment") fitment = django_filters.CharFilter( method="fitment_filter", label= "Fitment, example: 2005 Chevrolet Corvette. Multi year, 2008-2013 Chevrolet Corvette" ) has_images = django_filters.BooleanFilter(method="has_images_filter", label="Has images") is_superseded = django_filters.BooleanFilter(method="is_superseded_filter", label="Superseded") is_discontinued = django_filters.BooleanFilter( method="is_discontinued_filter", label="Discontinued") is_obsolete = django_filters.BooleanFilter(method="is_obsolete_filter", label="Obsolete") def fitment_filter(self, queryset, name, val): """ Below filters use rawsql because built in django exists filter is quite slow as it adds unnecessary group bys The performance on the filter goes from 100+ seconds to under 1 second Culprit was entire SQL turns into a subquery with odd group bys """ fitment_query = val.split() year, make, model = fitment_query[0:3] engine, engine_condition_sql, engine_condition_join = None, '', '' if len(fitment_query) == 4: engine = fitment_query[3] year_range = year.split("-") if len(year_range) > 1: years = range(int(year_range[0]), int(year_range[1]) + 1) else: years = [int(year)] years_conditions = list() for year in years: years_conditions.append( f"({year} BETWEEN aces_pies_data_productfitment.start_year and aces_pies_data_productfitment.end_year)" ) years_condition_sql = " OR ".join(years_conditions) if engine: engine_condition_join = "INNER JOIN aces_pies_data_vehicleengine ON aces_pies_data_vehicle.engine_id = aces_pies_data_vehicleengine.id" engine_condition_sql = f"AND aces_pies_data_vehicleengine.configuration = '{engine}'" queryset = queryset.extra(where=[ f""" EXISTS ( SELECT 1 FROM aces_pies_data_productfitment INNER JOIN aces_pies_data_vehicle ON aces_pies_data_vehicle.id = aces_pies_data_productfitment.vehicle_id INNER JOIN aces_pies_data_vehiclemake ON aces_pies_data_vehiclemake.id = aces_pies_data_vehicle.make_id INNER JOIN aces_pies_data_vehiclemodel ON aces_pies_data_vehiclemodel.id = aces_pies_data_vehicle.model_id {engine_condition_join} WHERE aces_pies_data_productfitment.product_id = aces_pies_data_product.id AND aces_pies_data_vehiclemake.name = '{make}' AND aces_pies_data_vehiclemodel.name = '{model}' AND ({years_condition_sql}) {engine_condition_sql} ) """ ]) return queryset def has_images_filter(self, queryset, name, val): not_exists = "" if val else "NOT" queryset = queryset.extra(where=[ f""" {not_exists} EXISTS ( SELECT 1 FROM aces_pies_data_productdigitalasset pda INNER JOIN aces_pies_data_digitalasset da on da.id = pda.digital_asset_id INNER JOIN aces_pies_data_digitalassettype dat on da.type_id = dat.id WHERE pda.product_id = aces_pies_data_product.id AND dat.name = 'Product Image' ) """ ]) return queryset def brand_filter(self, queryset, name, value): return queryset.filter(**{"brand__name__in": value}) def category_filter(self, queryset, name, value): return queryset.filter(**{"category__name__in": value}) def has_map_price_filter(self, queryset, name, value): return queryset.filter(**{ "map_price__isnull": not value, }) def is_universal_fitment_filter(self, queryset, name, value): if value: return queryset.filter(**{ "fitment_count": 0, }) else: return queryset.filter(**{ "fitment_count__gte": 1, }) def is_superseded_filter(self, queryset, name, value): return queryset.filter(**{ "is_superseded": value, }) def is_discontinued_filter(self, queryset, name, value): return queryset.filter(**{ "is_discontinued": value, }) def is_obsolete_filter(self, queryset, name, value): return queryset.filter(**{ "is_obsolete": value, }) class Meta: model = Product fields = ( 'part_number', 'is_hazardous', 'is_carb_legal', 'is_discontinued', 'is_obsolete', )
class SpeakerFilter(django_filters.FilterSet): summit_id = django_filters.NumberFilter( method='has_events_from_summit_filter') published_in = django_filters.NumberFilter( method='has_published_events_from_summit_filter') search = django_filters.CharFilter(method='search_filter') has_feedback_for_summit = django_filters.NumberFilter( method='feedback_filter') track = django_filters.BaseInFilter( field_name='presentations__category__id') confirmed_for_summit = django_filters.CharFilter(method='confirmed_filter') checkedin_for_summit = django_filters.CharFilter(method='checked_filter') registered_for_summit = django_filters.CharFilter( method='registered_filter') attending_media_for_summit = django_filters.CharFilter( method='attending_media_filter') class Meta: model = Speaker fields = ['id', 'first_name', 'last_name'] def has_events_from_summit_filter(self, queryset, name, value): return queryset.filter(presentations__summit__id=value).distinct() def has_published_events_from_summit_filter(self, queryset, name, value): return queryset.filter(presentations__summit__id=value, presentations__published=True).distinct() def has_events_on_category_filter(self, queryset, name, value): return queryset.filter(presentations__category__id=value).distinct() def confirmed_filter(self, queryset, name, value): values = value.split(',') summit_id = values[0] confirmed = values[1] == 'true' return queryset.filter(attendances__summit__id=summit_id, attendances__confirmed=confirmed).distinct() def registered_filter(self, queryset, name, value): values = value.split(',') summit_id = values[0] registered = values[1] == 'true' return queryset.filter(attendances__summit__id=summit_id, attendances__registered=registered).distinct() def checked_filter(self, queryset, name, value): values = value.split(',') summit_id = values[0] checked = values[1] == 'true' return queryset.filter(attendances__summit__id=summit_id, attendances__checked_in=checked).distinct() def attending_media_filter(self, queryset, name, value): values = value.split(',') summit_id = values[0] attending = values[1] == 'true' return queryset.filter( presentations__summit__id=summit_id, presentations__attending_media=attending).distinct() def search_filter(self, queryset, name, value): queryset = queryset.filter( models.Q(last_name=value) | models.Q(member__email=value) | models.Q(presentations__title__icontains=value)) return queryset.distinct() def feedback_filter(self, queryset, name, value): feedbacks = EventFeedback.objects.filter( event__presentation__speakers=models.OuterRef('id'), event__summit__id=value) queryTmp = queryset.annotate( has_feedback=models.Exists(feedbacks)).filter(has_feedback=True) queryTmp = queryTmp.annotate(rate=SubQueryAvg(feedbacks, field="rate")) return queryTmp