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