I'm trying to limit query results for a specific DocumentChooserBlock inside of a wagtail stream field block.
I already know that you can limit file types for DocumentChooser for a page type by using hooks, but I would like to avoid limiting possible file types page wide in case I need them for other StreamField blocks.
Are there any possible ways to implement what I am trying to achieve here?
Wagtail's Chooser Modal system works a bit differently to a normal Django widget (Class used to render html content of a field), the widget itself mostly renders a button 'Choose Document' and the button then triggers a modal which is a separate view and template.
As you noted, the construct_document_chooser_queryset hook can limit the results shown in these modals but only with access to the request object of the page being viewed, not of the Widget used to trigger that modal.
There is a way to get some limited desired functionality but it will not work for search results and will not restrict any additional uploads to that file type.
DocumentChooserBlockDocumentChooserBlock and has a custom __init__ method that pulls out a kwarg accept and assigns it to the widget attrs.attrs and these are output on the rendered HTML element, our custom Block assigns the value we want to the widget so that other methods have access to it.doc_block = SpecificDocumentChooserBlock(accept="svg,md") # uses accept kwarg<input type="hidden" name="body-2-value" accept="svg,md" id="body-2-value" value="">from wagtail.documents.blocks import DocumentChooserBlock
class SpecificDocumentChooserBlock(DocumentChooserBlock):
"""
Existing DocumentChooserBlock with the ability to add widget attrs based on the
accept kwarg, anything on self.widget.attrs will be added to the hidden
input field (so be careful what key is used).
"""
def __init__(self, accept=None, **kwargs):
super().__init__(**kwargs)
self.widget.attrs["accept"] = accept
data-chooser-url on the document-chooser block div.wagtail_hooks.py, as we will need that file anyway and we know it only gets run once at runtime.widget.render_html( is the key part, we are using the ** syntax to unpack any widget.attrs values (one will be the accept item set by our custom block).from wagtail.core.telepath import register as telepath_register
from wagtail.documents.widgets import AdminDocumentChooser, DocumentChooserAdapter
class CustomDocumentChooserAdapter(DocumentChooserAdapter):
def js_args(self, widget):
return [
widget.render_html(
# this line is changed, allocate any widget.attrs to the attrs passed to render_html
"__NAME__",
None,
attrs={**widget.attrs, "id": "__ID__"},
),
widget.id_for_label("__ID__"),
]
telepath_register(CustomDocumentChooserAdapter(), AdminDocumentChooser)
INSTALLED_APPS for this step.myapp/templates/wagtaildocs/widgets/document_chooser.html, the part after templates is critical here as we want to override and extend this exact template.chooser_attributes as this is what adds the data-chooser-url used by the Chooser Modal trigger.data-chooser-url with a query string added to the URL <div id="body-2-value-chooser" class="chooser document-chooser blank" data-chooser-url="/admin/documents/chooser/?accept=svg,md">{% extends "wagtaildocs/widgets/document_chooser.html" %}
{% comment %}
This template overrides the Wagtail default chooser field, this is not the modal but
the button / selected value shown in the page editor.
chooser_attributes are the attributes that are used by the modal trigger, we will
override the 'data-chooser-url' value with a url param
{% endcomment %}
{% block chooser_attributes %}data-chooser-url="{% url "wagtaildocs:chooser" %}{% if attrs.accept %}?accept={{ attrs.accept }}{% endif %}"{% endblock %}
accept query string paramconstruct_document_chooser_queryset now, it will be possible to pull in the GET param accept and parse it to generate a different set of document results.@hooks.register("construct_document_chooser_queryset")
def show_accepted_documents_only(documents, request):
accept = request.GET.get("accept")
if accept:
accepted_files = accept.split(",")
queries = [Q(file__iendswith=f".{value}") for value in accepted_files]
query = queries.pop()
for item in queries:
query |= item
documents = documents.filter(query)
return documents
CustomDocumentChooserAdapter so be sure to keep an eye on the Wagtail code changes.
Using wagtail-generic-chooser offers much more ability to customise the way the Chooser modal works.
wagtail-generic-chooserpip install wagtail-generic-choosergeneric_chooser to your project's INSTALLED_APPS.accept parameter by creating a custom class that extends the ModelChooserMixin, this will mean the param still gets passed when searching.accept URL param to conditionally filter the returned values.ModelChooserViewSet which will handle the showing of the Document listing within the modal.from django.db.models import Q
from generic_chooser.views import ModelChooserMixin, ModelChooserViewSet
from wagtail.documents.models import Document
class RestrictedDocumentChooserMixin(ModelChooserMixin):
# preserve this URL parameter on pagination / search
preserve_url_parameters = [
"accept",
]
def get_unfiltered_object_list(self):
objects = super().get_unfiltered_object_list()
accept = self.request.GET.get("accept")
print("get_unfiltered_object_list", accept)
if accept:
accepted_files = accept.split(",")
queries = [Q(file__iendswith=f".{value}") for value in accepted_files]
query = queries.pop()
for item in queries:
query |= item
objects = objects.filter(query)
return objects
class RestrictedDocumentChooserViewSet(ModelChooserViewSet):
chooser_mixin_class = RestrictedDocumentChooserMixin
icon = "doc"
model = Document
page_title = "Choose a document"
per_page = 10
order_by = "title"
fields = ["title", "file"]
Block but will be used as the base for the Block and can also be used for a FieldPanel.AdminChooser.__init__ method we pull out the accept kwarg so we can use it to generate the custom URL param.get_edit_item_url method which will allow the clicking of a selected Document to edit it.to append the URL query param (note: I could not getreverse` working here without heaps more wrangling).from django.contrib.admin.utils import quote
from django.urls import reverse
from generic_chooser.widgets import AdminChooser
from wagtail.documents.models import Document
class RestrictedDocumentChooser(AdminChooser):
def __init__(self, **kwargs):
self.accept = kwargs.pop("accept")
super().__init__(**kwargs)
choose_one_text = "Choose a Document"
choose_another_text = "Choose another document"
link_to_chosen_text = "Edit this document"
model = Document
choose_modal_url_name = "restricted_document_chooser:choose"
def get_choose_modal_url(self):
url = super().get_choose_modal_url()
return url + "?accept=%s" % self.accept
def get_edit_item_url(self, item):
return reverse("wagtaildocs:edit", args=[item.id])
construct_document_chooser_queryset here, instead use the hook register_admin_viewset and register the RestrictedDocumentChooserViewSet.from wagtail.core import hooks
from .views import RestrictedDocumentChooserViewSet
# ... other hooks etc
@hooks.register("register_admin_viewset")
def register_restricted_document_chooser_viewset():
return RestrictedDocumentChooserViewSet(
"restricted_document_chooser", url_prefix="restricted-document-chooser"
)
BlockChooserBlock and wraps the RestrictedDocumentChooser widget that has been created.__init__ the same kwarg accept is pulled out and passed to the RestrictedDocumentChooser when created.accept though. doc_block = RestrictedDocumentChooserBlock(accept="svg,md")from django.utils.functional import cached_property
from wagtail.images.blocks import ChooserBlock
# ...
class RestrictedDocumentChooserBlock(ChooserBlock):
def __init__(self, **kwargs):
self.accept = kwargs.pop("accept")
super().__init__(**kwargs)
@cached_property
def target_model(self):
from wagtail.documents.models import Document
return Document
@cached_property
def widget(self):
from .widgets import RestrictedDocumentChooser
return RestrictedDocumentChooser(accept=self.accept)
def get_form_state(self, value):
return self.widget.get_value_data(value)