def get_queryset(self):
self._activate_language(self.request)
request = self.request
try:
models = page_models_from_string(
request.GET.get('type', 'wagtailcore.Page'))
except (LookupError, ValueError):
raise BadRequestError("type doesn't exist")
_qs = Page.objects.all().public()
if not (request.user and request.user.is_superuser):
_qs = _qs.live()
if self.request.site:
_qs = _qs.descendant_of(self.request.site.root_page,
inclusive=True)
else:
# No sites configured
_qs = _qs.none()
if not models:
return _qs
elif len(models) == 1:
return models[0].objects.filter(
id__in=_qs.values_list('id', flat=True))
else: # len(models) > 1
return filter_page_type(_qs, models)
def get_queryset(self):
request = self.request
# Allow pages to be filtered to a specific type
try:
models = page_models_from_string(
request.GET.get('type', 'wagtailcore.Page'))
except (LookupError, ValueError):
raise BadRequestError("type doesn't exist")
if not models:
models = [Page]
if len(models) == 1:
queryset = models[0].objects.all()
else:
queryset = Page.objects.all()
# Filter pages by specified models
queryset = filter_page_type(queryset, models)
# Hide root page
# TODO: Add "include_root" flag
queryset = queryset.exclude(depth=1).specific()
return queryset
def get_queryset(self):
request = self.request
# Allow pages to be filtered to a specific type
try:
models = page_models_from_string(
request.GET.get('type', 'wagtailcore.Page'))
except (LookupError, ValueError):
raise BadRequestError("type doesn't exist")
if not models:
models = [Page]
if len(models) == 1:
queryset = models[0].objects.all()
else:
queryset = Page.objects.all()
# Filter pages by specified models
queryset = filter_page_type(queryset, models)
if self.request.user.is_authenticated:
# Get all live pages
queryset = queryset.live()
else:
# Get live pages that are not in a private section
queryset = queryset.public().live()
# Filter by site
queryset = queryset.descendant_of(request.site.root_page,
inclusive=True)
return queryset
def create_content_type_id(object_id: str, content_type:str):
if object_id is None:
raise BadRequestError(_('`object_id` is not valid'))
if content_type not in getattr(settings, 'ALLOWED_COMMENTED_CONTENT_TYPES', []):
raise BadRequestError(_('Given content_type is not allowed to be commented.'))
if content_type is None or not isinstance(content_type,str):
raise BadRequestError(_('both content_type and object_id must be supplied.'))
splitted = content_type.lower().split('.')
if len(splitted) > 2:
raise BadRequestError(_('Invalid content_type.'))
app_label, model = splitted
content_type_obj = ContentType.objects.get(app_label=app_label,model=model)
try:
content_type_obj.get_object_for_this_type(id=int(object_id))
except content_type_obj.model_class().DoesNotExist:
raise BadRequestError(_('Given combination of content_type and object_id does not exist'))
return ContentType.objects.values_list('id').get(app_label=app_label,model=model)[0]
def filter_queryset(self, request, queryset, view):
"""
This overrides the wagtail core api filters.SearchFilter
so we can provide autocomplet/fuzzy text matching with
sb.autocomplete
"""
search_enabled = getattr(settings, "WAGTAILAPI_SEARCH_ENABLED", True)
if "search" in request.GET:
if not search_enabled:
raise BadRequestError("search is disabled")
# Searching and filtering by tag at the same time is not supported
if getattr(queryset, "_filtered_by_tag", False):
raise BadRequestError(
"filtering by tag with a search query is not supported"
)
search_query = request.GET["search"]
search_operator = request.GET.get("search_operator", None)
order_by_relevance = "order" not in request.GET
sb = get_search_backend()
try:
queryset = sb.autocomplete(
search_query,
queryset,
operator=search_operator,
order_by_relevance=order_by_relevance,
)
except FilterFieldError as e:
raise BadRequestError(
"cannot filter by '{}' while searching (field is not indexed)".format(
e.field_name
)
)
except OrderByFieldError as e:
raise BadRequestError(
"cannot order by '{}' while searching (field is not indexed)".format(
e.field_name
)
)
return queryset
def filter_queryset(self, request, queryset, view):
"""
This performs field level filtering on the result set
Eg: ?title=James Joyce
"""
fields = set(
view.get_available_fields(queryset.model, db_fields_only=True))
query_parameters = view.request.GET.keys()
query_parameters = set(
filter(
lambda param: re.sub(r'__.*$', '', param) in fields and param.
find('__') != -1, query_parameters))
fields = fields.union(query_parameters)
for field_name, value in request.GET.items():
if field_name in fields:
lookup = ''
if '__' in field_name:
i = field_name.find('__')
lookup = field_name[i:]
field_name = field_name[:i]
try:
field = queryset.model._meta.get_field(field_name)
except LookupError:
field = None
# Convert value into python
try:
if isinstance(
field,
(models.BooleanField, models.NullBooleanField)):
value = parse_boolean(value)
elif isinstance(field,
(models.IntegerField, models.AutoField)):
value = int(value)
except ValueError as e:
raise BadRequestError(
"field filter error. '%s' is not a valid value for %s (%s)"
% (value, field_name, str(e)))
if isinstance(field, TaggableManager):
for tag in value.split(','):
queryset = queryset.filter(
**{field_name + '__name': tag})
# Stick a message on the queryset to indicate that tag filtering has been performed
# This will let the do_search method know that it must raise an error as searching
# and tag filtering at the same time is not supported
queryset._filtered_by_tag = True
else:
field_name = field_name + lookup
queryset = queryset.filter(**{field_name: value})
return queryset
def execute(self, instance, data):
action = self._action_from_data(instance, data)
try:
new_page = action.execute()
except DjangoValidationError as e:
raise ValidationError(e.message_dict)
except CreatePageAliasIntegrityError as e:
raise BadRequestError(e.args[0])
serializer = self.view.get_serializer(new_page)
return Response(serializer.data, status=status.HTTP_201_CREATED)
def execute(self, instance, data):
action = self._action_from_data(instance, data)
try:
new_revision = action.execute()
except DjangoValidationError as e:
raise ValidationError(e.message_dict)
except RevertToPageRevisionError as e:
raise BadRequestError(e.args[0])
serializer = self.view.get_serializer(new_revision.as_page_object())
return Response(serializer.data, status=status.HTTP_200_OK)
def execute(self, instance, data):
action = self._action_from_data(instance, data)
try:
translated_page = action.execute()
except DjangoValidationError as e:
raise ValidationError(e.message_dict)
except ParentNotTranslatedError as e:
raise BadRequestError(e.args[0])
serializer = self.view.get_serializer(translated_page)
return Response(serializer.data, status=status.HTTP_201_CREATED)
def filter_queryset(self, request, queryset, view):
if "has_children" in request.GET:
try:
has_children_filter = parse_boolean(request.GET["has_children"])
except ValueError:
raise BadRequestError("has_children must be 'true' or 'false'")
if has_children_filter is True:
return queryset.filter(numchild__gt=0)
else:
return queryset.filter(numchild=0)
return queryset
def get_queryset(self):
'''
This is overwritten in order to not exclude drafts
and pages submitted for moderation
'''
request = self.request
# Allow pages to be filtered to a specific type
if 'type' not in request.GET:
model = Page
else:
model_name = request.GET['type']
try:
model = resolve_model_string(model_name)
except LookupError:
raise BadRequestError("type doesn't exist")
if not issubclass(model, Page):
raise BadRequestError("type doesn't exist")
# This is the overwritten line
queryset = model.objects.public() # exclude .live()
# Filter by site
queryset = queryset.descendant_of(request.site.root_page,
inclusive=True)
# Enable filtering by navigation tags
if model == ArticlePage and 'nav_tags__tag' in request.GET:
try:
queryset = queryset.filter(
nav_tags__tag=request.GET['nav_tags__tag'])
except ValueError as e:
raise BadRequestError(
"field filter error. '%s' is not a valid value "
"for nav_tags__tag (%s)" %
(request.GET['nav_tags__tag'], str(e)))
return queryset
def execute(self, instance, data):
try:
action = self._action_from_data(instance, data)
except RuntimeError as e:
raise BadRequestError(e.args[0])
try:
action.execute()
except DjangoValidationError as e:
raise ValidationError(e.message_dict)
new_page = instance.specific_class.objects.get(pk=instance.pk)
serializer = self.view.get_serializer(new_page)
return Response(serializer.data, status=status.HTTP_200_OK)
def filter_queryset(self, request, queryset, view):
if request.GET.get('for_explorer'):
if not hasattr(queryset, '_filtered_by_child_of'):
raise BadRequestError(
"filtering by for_explorer without child_of is not supported"
)
parent_page = queryset._filtered_by_child_of
for hook in hooks.get_hooks('construct_explorer_page_queryset'):
queryset = hook(parent_page, queryset, request)
user_perms = UserPagePermissionsProxy(request.user)
queryset = queryset & user_perms.explorable_pages()
return queryset
def filter_queryset(self, request, queryset, view):
"""
This performs field level filtering on the result set
Eg: ?title=James Joyce
"""
fields = set(
view.get_available_fields(queryset.model, db_fields_only=True))
# Locale is a database field, but we provide a separate filter for it
if 'locale' in fields:
fields.remove('locale')
for field_name, value in request.GET.items():
if field_name in fields:
try:
field = queryset.model._meta.get_field(field_name)
except LookupError:
field = None
# Convert value into python
try:
if isinstance(
field,
(models.BooleanField, models.NullBooleanField)):
value = parse_boolean(value)
elif isinstance(field,
(models.IntegerField, models.AutoField)):
value = int(value)
except ValueError as e:
raise BadRequestError(
"field filter error. '%s' is not a valid value for %s (%s)"
% (value, field_name, str(e)))
if isinstance(field, TaggableManager):
for tag in value.split(','):
queryset = queryset.filter(
**{field_name + '__slug': tag})
# Stick a message on the queryset to indicate that tag filtering has been performed
# This will let the do_search method know that it must raise an error as searching
# and tag filtering at the same time is not supported
queryset._filtered_by_tag = True
else:
queryset = queryset.filter(**{field_name: value})
return queryset
def filter_queryset(self, request, queryset, view):
if request.GET.get('for_explorer'):
if not hasattr(queryset, '_filtered_by_child_of'):
raise BadRequestError(
"filtering by for_explorer without child_of is not supported"
)
parent_page = queryset._filtered_by_child_of
##TODO: This is where the code is broken, see: https://github.com/wagtail/wagtail/blob/17e541715a80a43bc4eb1f1b07183bf22bb1869a/wagtail/contrib/modeladmin/options.py#L49
# for hook in hooks.get_hooks('construct_explorer_page_queryset'):
# queryset = hook(parent_page, queryset, request)
user_perms = UserPagePermissionsProxy(request.user)
# This is returning an empty list! WRONG!
#print(user_perms.explorable_pages())
queryset = queryset & user_perms.explorable_pages()
return queryset
def check_query_parameters(self, queryset):
"""
Ensure that only valid query paramters are included in the URL.
"""
query_parameters = self.request.GET.keys()
query_parameters = set(
map(lambda param: re.sub(r'__.*$', '', param), query_parameters))
# All query paramters must be either a database field or an operation
allowed_query_parameters = set(
self.get_available_fields(queryset.model,
db_fields_only=True)).union(
self.known_query_parameters)
unknown_parameters = query_parameters - allowed_query_parameters
if unknown_parameters:
raise BadRequestError(
"query parameter is not an operation or a recognised field: %s"
% ', '.join(sorted(unknown_parameters)))
def get_serializer_class(self):
if self.action == 'listing_view':
show_details = False
model = getattr(self, 'queryset', self.get_queryset()).model
else:
# Allow "detail_only" (eg parent) fields on detail view
show_details = True
model = type(self.get_object())
# Fields
try:
fields_config = parse_fields_parameter(
self.request.GET.get('fields', []))
except ValueError as e:
raise BadRequestError("fields error: %s" % str(e))
return self._get_serializer_class(self.request.wagtailapi_router,
model,
fields_config,
show_details=show_details)
def get_queryset(self):
"""Allows the user to 1+ Page-derived models to query"""
try:
models = page_models_from_string(
self.request.GET.get('type', 'wagtailcore.Page'))
except (LookupError, ValueError) as exception:
raise BadRequestError("type doesn't exist") from exception
if not models:
models = [Page]
if len(models) == 1:
queryset = models[0].objects.all()
else:
queryset = Page.objects.select_related('site').all()
# Filter pages by specified models
queryset = self._filter_page_type(queryset, models)
queryset = queryset.public().live().specific()
return queryset