def list(self, request):
content_id = get_query_params(self.request).get("content_id")
if content_id:
content = get_object_or_404(Content, pk=content_id)
# Find special coverage via percolator
special_coverage_filter = {
"filter": {
"prefix": {
"_id": "specialcoverage"
}
}
}
search_objects = type(content).search_objects
results = search_objects.client.percolate(
index=search_objects.mapping.index,
doc_type=search_objects.mapping.doc_type,
id=content.id,
body=special_coverage_filter,
)
# Translate perocolator results into SpecialCoverage objects
if results["total"]:
special_coverage_ids = [
int(m["_id"].split(".")[-1]) for m in results["matches"]
]
qs = SpecialCoverage.objects.filter(
id__in=special_coverage_ids)
# Active Filter
active = get_query_params(self.request).get('active',
'').lower()
now = timezone.now()
if active == 'true':
qs = qs.filter(
start_date__lte=now, end_date__gte=now) | qs.filter(
start_date__lte=now, end_date__isnull=True)
elif active == 'false':
qs = qs.exclude(
start_date__lte=now, end_date__gte=now) | qs.exclude(
start_date__lte=now, end_date__isnull=False)
# Sponsored Filter
sponsored = get_query_params(self.request).get(
'sponsored', '').lower()
if sponsored == 'true':
qs = qs.filter(tunic_campaign_id__isnull=False)
elif sponsored == 'false':
qs = qs.exclude(tunic_campaign_id__isnull=False)
serializer = SpecialCoverageSerializer(qs, many=True)
return Response(serializer.data)
else:
return Response(status=status.HTTP_204_NO_CONTENT)
else:
raise Http404('Must specify "content_id" param')
def list(self, request):
content_id = get_query_params(self.request).get("content_id")
if content_id:
content = get_object_or_404(Content, pk=content_id)
# Find special coverage via percolator
special_coverage_filter = {
"filter": {
"prefix": {"_id": "specialcoverage"}
}
}
search_objects = type(content).search_objects
results = search_objects.client.percolate(
index=search_objects.mapping.index,
doc_type=search_objects.mapping.doc_type,
id=content.id,
body=special_coverage_filter,
)
# Translate perocolator results into SpecialCoverage objects
if results["total"]:
special_coverage_ids = [int(m["_id"].split(".")[-1]) for m in results["matches"]]
qs = SpecialCoverage.objects.filter(id__in=special_coverage_ids)
# Active Filter
active = get_query_params(self.request).get('active', '').lower()
now = timezone.now()
if active == 'true':
qs = qs.filter(
start_date__lte=now, end_date__gte=now
) | qs.filter(
start_date__lte=now, end_date__isnull=True
)
elif active == 'false':
qs = qs.exclude(
start_date__lte=now, end_date__gte=now
) | qs.exclude(
start_date__lte=now, end_date__isnull=False
)
# Sponsored Filter
sponsored = get_query_params(self.request).get('sponsored', '').lower()
if sponsored == 'true':
qs = qs.filter(tunic_campaign_id__isnull=False)
elif sponsored == 'false':
qs = qs.exclude(tunic_campaign_id__isnull=False)
serializer = SpecialCoverageSerializer(qs, many=True)
return Response(serializer.data)
else:
return Response(status=status.HTTP_204_NO_CONTENT)
else:
raise Http404('Must specify "content_id" param')
def list(self, request, *args, **kwargs):
"""Modified list view to driving listing from ES"""
search_kwargs = {"published": False}
for field_name in ("before", "after", "status", "published"):
if field_name in get_query_params(self.request):
search_kwargs[field_name] = get_query_params(self.request).get(field_name)
for field_name in ("tags", "types", "feature_types"):
if field_name in get_query_params(self.request):
search_kwargs[field_name] = get_query_params(self.request).getlist(field_name)
if "search" in get_query_params(self.request):
search_kwargs["query"] = get_query_params(self.request).get("search")
queryset = Content.search_objects.search(**search_kwargs)
if "authors" in get_query_params(self.request):
authors = get_query_params(self.request).getlist("authors")
queryset = queryset.filter(Authors(authors))
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)
def retrieve(self, request, *args, **kwargs):
"""Retrieve pzone as a preview or applied if no preview is provided."""
when_param = get_query_params(self.request).get("preview", None)
pk = self.kwargs["pk"]
when = None
if when_param:
try:
when = parse_date(when_param)
except ValueError:
# invalid format, set back to None
when = None
pzone = None
if when:
# we have a date, use it
pzone = PZone.objects.preview(pk=pk, when=when)
else:
# we have no date, just get the pzone
pzone = PZone.objects.applied(pk=pk)
# turn content list into json
return Response(PZoneSerializer(pzone).data,
content_type="application/json")
def list(self, request, *args, **kwargs):
"""Modified list view to driving listing from ES"""
search_kwargs = {"published": False}
query_params = get_query_params(self.request)
for field_name in ("status"):
if field_name in query_params:
search_kwargs[field_name] = query_params.get(field_name)
if "search" in query_params:
search_kwargs["query"] = query_params.get("search")
# active/closed are semantics of the Poll model
# active is analagous to 'published' in Content
# closed is in relation to the end_date of a Poll
if "active" in query_params:
del search_kwargs["published"]
search_kwargs["active"] = True
if "closed" in query_params:
del search_kwargs["published"]
search_kwargs["closed"] = True
queryset = self.model.search_objects.search(**search_kwargs)
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)
def get_queryset(self):
queryset = Tag.search_objects.search()
if "search" in self.request.REQUEST:
query_string = self.request.REQUEST["search"].lower()
queryset = queryset.query(Q("match", name=query_string) | Q("match", **{"name.raw": query_string}))
types = get_query_params(self.request).getlist("types", None)
if types:
queryset._doc_type = self.request.REQUEST["types"]
return queryset
def get_queryset(self):
"""creates the base queryset object for the serializer
:return: an instance of `django.db.models.QuerySet`
"""
qs = LogEntry.objects.all()
content_id = get_query_params(self.request).get("content", None)
if content_id:
qs = qs.filter(object_id=content_id)
return qs
def get_queryset(self):
"""creates the base queryset object for the serializer
:return: an instance of `django.db.models.QuerySet`
"""
qs = LogEntry.objects.all()
content_id = get_query_params(self.request).get("content", None)
if content_id:
qs = qs.filter(object_id=content_id)
return qs
def list(self, request, *args, **kwargs):
"""Modified list view to driving listing from ES"""
search_kwargs = {"published": False}
for field_name in ("before", "after", "status", "published"):
if field_name in get_query_params(self.request):
search_kwargs[field_name] = get_query_params(
self.request).get(field_name)
for field_name in ("tags", "types", "feature_types"):
if field_name in get_query_params(self.request):
search_kwargs[field_name] = get_query_params(
self.request).getlist(field_name)
if "search" in get_query_params(self.request):
search_kwargs["query"] = get_query_params(
self.request).get("search")
queryset = self.model.search_objects.search(**search_kwargs)
if "authors" in get_query_params(self.request):
authors = get_query_params(self.request).getlist("authors")
queryset = queryset.filter(Authors(authors))
if "exclude" in get_query_params(self.request):
exclude = get_query_params(self.request).get("exclude")
queryset = queryset.filter(
es_filter.Not(es_filter.Type(**{'value': exclude})))
# always filter out Super Features from listing page
queryset = queryset.filter(
es_filter.Not(filter=es_filter.Type(value=get_superfeature_model(
).search_objects.mapping.doc_type)))
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)
def list(self, request, *args, **kwargs):
"""Modified list view to driving listing from ES"""
search_kwargs = {"published": False}
for field_name in ("before", "after", "status", "published"):
if field_name in get_query_params(self.request):
search_kwargs[field_name] = get_query_params(self.request).get(field_name)
for field_name in ("tags", "types", "feature_types"):
if field_name in get_query_params(self.request):
search_kwargs[field_name] = get_query_params(self.request).getlist(field_name)
if "search" in get_query_params(self.request):
search_kwargs["query"] = get_query_params(self.request).get("search")
queryset = self.model.search_objects.search(**search_kwargs)
if "authors" in get_query_params(self.request):
authors = get_query_params(self.request).getlist("authors")
queryset = queryset.filter(Authors(authors))
if "exclude" in get_query_params(self.request):
exclude = get_query_params(self.request).get("exclude")
queryset = queryset.filter(
es_filter.Not(es_filter.Type(**{'value': exclude}))
)
# always filter out Super Features from listing page
queryset = queryset.filter(
es_filter.Not(filter=es_filter.Type(
value=get_superfeature_model().search_objects.mapping.doc_type))
)
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)
def filter_queryset(self, request, queryset, view):
new_queryset = queryset
key_active = 'active'
now = datetime.now()
if key_active in get_query_params(request):
val = get_query_params(request)[key_active].lower()
if val == 'true':
# start_date <= now < end_date
new_queryset = queryset.filter(start_date__lte=now,
end_date__gt=now)
elif val == 'false':
# now < start_date || now >= end_date
new_queryset = \
queryset.filter(start_date__gt=now) | \
new_queryset.filter(end_date__lte=now)
return new_queryset
def filter_queryset(self, request, queryset, view):
boolean_fields = getattr(view, 'boolean_fields', None)
if not boolean_fields:
return queryset
boolean_filters = {}
for field in boolean_fields:
if field in get_query_params(request):
val = get_query_params(request)[field].lower()
if val == 'true':
boolean_filters[field] = True
elif val == 'false':
boolean_filters[field] = False
if len(boolean_filters) > 0:
return queryset.filter(**boolean_filters)
return queryset
def filter_queryset(self, request, queryset, view):
boolean_fields = getattr(view, 'boolean_fields', None)
if not boolean_fields:
return queryset
boolean_filters = {}
for field in boolean_fields:
if field in get_query_params(request):
val = get_query_params(request)[field].lower()
if val == 'true':
boolean_filters[field] = True
elif val == 'false':
boolean_filters[field] = False
if len(boolean_filters) > 0:
return queryset.filter(**boolean_filters)
return queryset
def list(self, request):
url = get_query_params(self.request).get("url")
if url:
try:
match = resolve(urlparse(url).path)
except Resolver404:
raise Http404("No content found matching UUID")
content = get_object_or_404(Content, pk=match.kwargs.get('pk'))
return Response(ContentSerializer(content).data)
else:
raise Http404('Must specify content "url" param')
def list(self, request):
"""Search the doctypes for this model."""
query = get_query_params(request).get("search", "")
results = []
base = self.model.get_base_class()
doctypes = indexable_registry.families[base]
for doctype, klass in doctypes.items():
name = klass._meta.verbose_name.title()
if query.lower() in name.lower():
results.append(dict(name=name, doctype=doctype))
results.sort(key=lambda x: x["name"])
return Response(dict(results=results))
def get_queryset(self):
queryset = Tag.search_objects.search()
if "search" in self.request.REQUEST:
query_string = self.request.REQUEST["search"].lower()
queryset = queryset.query(
Q("match", name=query_string)
| Q("match", **{"name.raw": query_string}))
types = get_query_params(self.request).getlist("types", None)
if types:
queryset._doc_type = self.request.REQUEST["types"]
return queryset
def list(self, request):
url = get_query_params(self.request).get("url")
if url:
try:
match = resolve(urlparse(url).path)
except Resolver404:
raise Http404("No content found matching UUID")
content = get_object_or_404(Content, pk=match.kwargs.get('pk'))
return Response(ContentSerializer(content).data)
else:
raise Http404('Must specify content "url" param')
def filter_queryset(self, request, queryset, view):
new_queryset = queryset
key_active = 'active'
now = datetime.now()
if key_active in get_query_params(request):
val = get_query_params(request)[key_active].lower()
if val == 'true':
# start_date <= now < end_date
new_queryset = queryset.filter(
start_date__lte=now,
end_date__gt=now
)
elif val == 'false':
# now < start_date || now >= end_date
new_queryset = \
queryset.filter(start_date__gt=now) | \
new_queryset.filter(end_date__lte=now)
return new_queryset
def list(self, request):
"""Search the doctypes for this model."""
query = get_query_params(request).get("search", "")
results = []
base = self.model.get_base_class()
doctypes = indexable_registry.families[base]
for doctype, klass in doctypes.items():
name = klass._meta.verbose_name.title()
if query.lower() in name.lower():
results.append(dict(
name=name,
doctype=doctype
))
results.sort(key=lambda x: x["name"])
return Response(dict(results=results))
def filter_queryset(self, request, queryset, view):
queryset = super(SpecialCoverageFilter, self).filter_queryset(request, queryset, view)
query_params = get_query_params(request)
if "active" in query_params:
today_filter = timezone.now()
value = query_params.get("active").lower()
if value == "true":
queryset = queryset.filter(
start_date__lte=today_filter, end_date__gte=today_filter
)
elif value == "false":
queryset == queryset.exclude(
start_date__lte=today_filter, end_date__gte=today_filter
)
return queryset
def filter_queryset(self, request, queryset, view):
queryset = super(SpecialCoverageFilter,
self).filter_queryset(request, queryset, view)
query_params = get_query_params(request)
if "active" in query_params:
today_filter = timezone.now()
value = query_params.get("active").lower()
if value == "true":
queryset = queryset.filter(
start_date__lte=today_filter,
end_date__gte=today_filter) | queryset.filter(
start_date__lte=today_filter, end_date__isnull=True)
elif value == "false":
queryset == queryset.exclude(
start_date__lte=today_filter,
end_date__gte=today_filter) | queryset.exclude(
start_date__lte=today_filter, end_date__isnull=False)
return queryset
def retrieve(self, request, *args, **kwargs):
"""Retrieve pzone as a preview or applied if no preview is provided."""
when_param = get_query_params(self.request).get("preview", None)
pk = self.kwargs["pk"]
when = None
if when_param:
try:
when = parse_date(when_param)
except ValueError:
# invalid format, set back to None
when = None
pzone = None
if when:
# we have a date, use it
pzone = PZone.objects.preview(pk=pk, when=when)
else:
# we have no date, just get the pzone
pzone = PZone.objects.applied(pk=pk)
# turn content list into json
return Response(PZoneSerializer(pzone).data, content_type="application/json")
