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
