def chooser(request):
VideoForm = get_video_form(Video)
uploadform = VideoForm()
videos = Video.objects.order_by('-created_at')
q = None
if ('q' in request.GET or 'p' in request.GET or 'tag' in request.GET
or 'collection_id' in request.GET):
# this request is triggered from search, pagination or 'popular tags';
# we will just render the results.html fragment
collection_id = request.GET.get('collection_id')
if collection_id:
videos = videos.filter(collection=collection_id)
searchform = SearchForm(request.GET)
if searchform.is_valid():
q = searchform.cleaned_data['q']
videos = videos.search(q)
is_searching = True
else:
is_searching = False
tag_name = request.GET.get('tag')
if tag_name:
videos = videos.filter(tags__name=tag_name)
# Pagination
paginator = Paginator(videos, per_page=12)
page = paginator.get_page(request.GET.get('p'))
return render(request, "wagtailvideos/chooser/results.html", {
'videos': page,
'is_searching': is_searching,
'query_string': q,
})
else:
searchform = SearchForm()
collections = Collection.objects.all()
if len(collections) < 2:
collections = None
paginator = Paginator(videos, per_page=12)
page = paginator.get_page(request.GET.get('p'))
return render_modal_workflow(
request,
'wagtailvideos/chooser/chooser.html',
None, {
'videos': page,
'uploadform': uploadform,
'searchform': searchform,
'is_searching': False,
'query_string': q,
'popular_tags': popular_tags_for_model(Video),
'collections': collections,
},
json_data=get_chooser_js_data())
def chooser(request):
Image = get_image_model()
if permission_policy.user_has_permission(request.user, 'add'):
ImageForm = get_image_form(Image)
uploadform = ImageForm(user=request.user)
else:
uploadform = None
images = Image.objects.order_by('-created_at')
# allow hooks to modify the queryset
for hook in hooks.get_hooks('construct_image_chooser_queryset'):
images = hook(images, request)
if (
'q' in request.GET or 'p' in request.GET or 'tag' in request.GET or
'collection_id' in request.GET
):
# this request is triggered from search, pagination or 'popular tags';
# we will just render the results.html fragment
collection_id = request.GET.get('collection_id')
if collection_id:
images = images.filter(collection=collection_id)
searchform = SearchForm(request.GET)
if searchform.is_valid():
q = searchform.cleaned_data['q']
images = images.search(q)
is_searching = True
else:
is_searching = False
q = None
tag_name = request.GET.get('tag')
if tag_name:
images = images.filter(tags__name=tag_name)
# Pagination
paginator, images = paginate(request, images, per_page=12)
return render(request, "wagtailimages/chooser/results.html", {
'images': images,
'is_searching': is_searching,
'query_string': q,
'will_select_format': request.GET.get('select_format')
})
else:
paginator, images = paginate(request, images, per_page=12)
context = get_chooser_context(request)
context.update({
'images': images,
'uploadform': uploadform,
})
return render_modal_workflow(
request, 'wagtailimages/chooser/chooser.html', None, context,
json_data=get_chooser_js_data()
)
def chooser(request, get_results=False):
# Get most popular queries
queries = models.Query.get_most_popular()
# If searching, filter results by query string
query_string = None
if 'q' in request.GET:
searchform = SearchForm(request.GET)
if searchform.is_valid():
query_string = searchform.cleaned_data['q']
queries = queries.filter(query_string__icontains=normalise_query_string(query_string))
else:
searchform = SearchForm()
paginator, queries = paginate(request, queries, per_page=10)
# Render
if get_results:
return render(request, "wagtailsearch/queries/chooser/results.html", {
'queries': queries,
})
else:
return render_modal_workflow(
request, 'wagtailsearch/queries/chooser/chooser.html', 'wagtailsearch/queries/chooser/chooser.js', {
'queries': queries,
'searchform': searchform,
}
)
def search(request):
pages = []
q = None
if 'q' in request.GET:
form = SearchForm(request.GET)
if form.is_valid():
q = form.cleaned_data['q']
pages = Page.objects.all().prefetch_related(
'content_type').specific().search(q)
paginator, pages = paginate(request, pages)
else:
form = SearchForm()
if request.is_ajax():
return render(
request, "wagtailadmin/pages/search_results.html", {
'pages': pages,
'query_string': q,
'pagination_query_params': ('q=%s' % q) if q else ''
})
else:
return render(
request, "wagtailadmin/pages/search.html", {
'search_form': form,
'pages': pages,
'query_string': q,
'pagination_query_params': ('q=%s' % q) if q else ''
})
def chooser(request, get_results=False):
# Get most popular queries
queries = models.Query.get_most_popular()
# If searching, filter results by query string
query_string = None
if 'q' in request.GET:
searchform = SearchForm(request.GET)
if searchform.is_valid():
query_string = searchform.cleaned_data['q']
queries = queries.filter(query_string__icontains=normalise_query_string(query_string))
else:
searchform = SearchForm()
paginator, queries = paginate(request, queries, per_page=10)
# Render
if get_results:
return render(request, "wagtailsearch/queries/chooser/results.html", {
'queries': queries,
})
else:
return render_modal_workflow(
request, 'wagtailsearch/queries/chooser/chooser.html', None, {
'queries': queries,
'searchform': searchform,
}, json_data={'step': 'chooser'}
)
def get_queryset(self):
# Get documents (filtered by user permission)
documents = self.get_documents()
invoices = self.get_invoices()
# Ordering
ordering = None
if "ordering" in self.request.GET and self.request.GET["ordering"] in [
"title",
"-created_at",
"file_size",
]:
ordering = self.request.GET["ordering"]
else:
ordering = "title"
documents = documents.order_by(ordering)
# Search
query_string = None
if "q" in self.request.GET:
form = SearchForm(self.request.GET, placeholder="Search documents")
if form.is_valid():
query_string = form.cleaned_data["q"]
documents = documents.search(query_string)
return documents
def chooser(request):
Image = get_image_model()
if permission_policy.user_has_permission(request.user, 'add'):
ImageForm = get_image_form(Image)
uploadform = ImageForm(user=request.user)
else:
uploadform = None
images = Image.objects.order_by('-created_at')
# allow hooks to modify the queryset
for hook in hooks.get_hooks('construct_image_chooser_queryset'):
images = hook(images, request)
if ('q' in request.GET or 'p' in request.GET or 'tag' in request.GET
or 'collection_id' in request.GET):
# this request is triggered from search, pagination or 'popular tags';
# we will just render the results.html fragment
collection_id = request.GET.get('collection_id')
if collection_id:
images = images.filter(collection=collection_id)
searchform = SearchForm(request.GET)
if searchform.is_valid():
q = searchform.cleaned_data['q']
images = images.search(q)
is_searching = True
else:
is_searching = False
q = None
tag_name = request.GET.get('tag')
if tag_name:
images = images.filter(tags__name=tag_name)
# Pagination
paginator, images = paginate(request, images, per_page=12)
return render(
request, "wagtailimages/chooser/results.html", {
'images': images,
'is_searching': is_searching,
'query_string': q,
'will_select_format': request.GET.get('select_format')
})
else:
paginator, images = paginate(request, images, per_page=12)
context = get_chooser_context(request)
context.update({
'images': images,
'uploadform': uploadform,
})
return render_modal_workflow(request,
'wagtailimages/chooser/chooser.html',
None,
context,
json_data=get_chooser_js_data())
class BaseListingView(TemplateView):
@method_decorator(permission_checker.require_any("add", "change", "delete"))
def get(self, request):
return super().get(request)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
# Get images (filtered by user permission)
images = (
permission_policy.instances_user_has_any_permission_for(
self.request.user, ["change", "delete"]
)
.order_by("-created_at")
.select_related("collection")
)
# Search
query_string = None
if "q" in self.request.GET:
self.form = SearchForm(self.request.GET, placeholder=_("Search images"))
if self.form.is_valid():
query_string = self.form.cleaned_data["q"]
images = images.search(query_string)
else:
self.form = SearchForm(placeholder=_("Search images"))
# Filter by collection
self.current_collection = None
collection_id = self.request.GET.get("collection_id")
if collection_id:
try:
self.current_collection = Collection.objects.get(id=collection_id)
images = images.filter(collection=self.current_collection)
except (ValueError, Collection.DoesNotExist):
pass
# Filter by tag
self.current_tag = self.request.GET.get("tag")
if self.current_tag:
try:
images = images.filter(tags__name=self.current_tag)
except (AttributeError):
self.current_tag = None
paginator = Paginator(images, per_page=INDEX_PAGE_SIZE)
images = paginator.get_page(self.request.GET.get("p"))
context.update(
{
"images": images,
"query_string": query_string,
"is_searching": bool(query_string),
"next": self.request.get_full_path(),
}
)
return context
def chooser(request):
EmbedVideo = get_embed_video_model()
if request.user.has_perm('wagtail_embed_videos.add_embedvideo'):
can_add = True
else:
can_add = False
q = None
embed_videos = EmbedVideo.objects.order_by('-created_at')
if 'q' in request.GET or 'p' in request.GET:
searchform = SearchForm(request.GET)
if searchform.is_valid():
q = searchform.cleaned_data['q']
embed_videos = embed_videos.search(q)
is_searching = True
else:
is_searching = False
q = None
# Pagination
# paginator, embed_videos = paginate(request, embed_videos, per_page=12) #DEPRECATED
paginator = Paginator(embed_videos, per_page=25)
embed_videos = paginator.get_page(request.GET.get('p'))
return render(
request, "wagtail_embed_videos/chooser/results.html", {
'embed_videos': embed_videos,
'is_searching': is_searching,
'can_add': can_add,
'query_string': q,
})
else:
# paginator, embed_videos = paginate(request, embed_videos, per_page=12) #DEPRECATED
paginator = Paginator(embed_videos, per_page=25)
embed_videos = paginator.get_page(request.GET.get('p'))
searchform = SearchForm()
return render_modal_workflow(
request,
'wagtail_embed_videos/chooser/chooser.html',
None, #'wagtail_embed_videos/chooser/chooser.js',
template_vars={
'embed_videos': embed_videos,
'searchform': searchform,
'is_searching': False,
'can_add': can_add,
'query_string': q,
'popular_tags': popular_tags_for_model(EmbedVideo),
},
json_data={
'step': 'chooser',
})
def index(request):
Image = get_image_model()
# Get images (filtered by user permission)
images = permission_policy.instances_user_has_any_permission_for(
request.user, ['change', 'delete']
).order_by('-created_at')
# Search
query_string = None
if 'q' in request.GET:
form = SearchForm(request.GET, placeholder=_("Search images"))
if form.is_valid():
query_string = form.cleaned_data['q']
images = images.search(query_string)
else:
form = SearchForm(placeholder=_("Search images"))
# Filter by collection
current_collection = None
collection_id = request.GET.get('collection_id')
if collection_id:
try:
current_collection = Collection.objects.get(id=collection_id)
images = images.filter(collection=current_collection)
except (ValueError, Collection.DoesNotExist):
pass
paginator = Paginator(images, per_page=20)
images = paginator.get_page(request.GET.get('p'))
collections = permission_policy.collections_user_has_any_permission_for(
request.user, ['add', 'change']
)
if len(collections) < 2:
collections = None
else:
collections = Collection.order_for_display(collections)
# Create response
if request.is_ajax():
return render(request, 'wagtailimages/images/results.html', {
'images': images,
'query_string': query_string,
'is_searching': bool(query_string),
})
else:
return render(request, 'wagtailimages/images/index.html', {
'images': images,
'query_string': query_string,
'is_searching': bool(query_string),
'search_form': form,
'popular_tags': popular_tags_for_model(Image),
'collections': collections,
'current_collection': current_collection,
'user_can_add': permission_policy.user_has_permission(request.user, 'add'),
})
class BaseListingView(TemplateView):
@method_decorator(permission_checker.require_any("add", "change",
"delete"))
def get(self, request):
return super().get(request)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
# Get documents (filtered by user permission)
documents = permission_policy.instances_user_has_any_permission_for(
self.request.user, ["change", "delete"])
# Ordering
if "ordering" in self.request.GET and self.request.GET["ordering"] in [
"title",
"-created_at",
]:
ordering = self.request.GET["ordering"]
else:
ordering = "-created_at"
documents = documents.order_by(ordering)
# Filter by collection
self.current_collection = None
collection_id = self.request.GET.get("collection_id")
if collection_id:
try:
self.current_collection = Collection.objects.get(
id=collection_id)
documents = documents.filter(
collection=self.current_collection)
except (ValueError, Collection.DoesNotExist):
pass
# Search
query_string = None
if "q" in self.request.GET:
self.form = SearchForm(self.request.GET,
placeholder=_("Search documents"))
if self.form.is_valid():
query_string = self.form.cleaned_data["q"]
documents = documents.search(query_string)
else:
self.form = SearchForm(placeholder=_("Search documents"))
# Pagination
paginator = Paginator(documents, per_page=20)
documents = paginator.get_page(self.request.GET.get("p"))
context.update({
"ordering": ordering,
"documents": documents,
"query_string": query_string,
"is_searching": bool(query_string),
"next": self.request.get_full_path(),
})
return context
class BaseListingView(TemplateView):
@method_decorator(permission_checker.require_any('add', 'change',
'delete'))
def get(self, request):
return super().get(request)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
# Get documents (filtered by user permission)
documents = permission_policy.instances_user_has_any_permission_for(
self.request.user, ['change', 'delete'])
# Ordering
if 'ordering' in self.request.GET and self.request.GET['ordering'] in [
'title', '-created_at'
]:
ordering = self.request.GET['ordering']
else:
ordering = '-created_at'
documents = documents.order_by(ordering)
# Filter by collection
self.current_collection = None
collection_id = self.request.GET.get('collection_id')
if collection_id:
try:
self.current_collection = Collection.objects.get(
id=collection_id)
documents = documents.filter(
collection=self.current_collection)
except (ValueError, Collection.DoesNotExist):
pass
# Search
query_string = None
if 'q' in self.request.GET:
self.form = SearchForm(self.request.GET,
placeholder=_("Search documents"))
if self.form.is_valid():
query_string = self.form.cleaned_data['q']
documents = documents.search(query_string)
else:
self.form = SearchForm(placeholder=_("Search documents"))
# Pagination
paginator = Paginator(documents, per_page=20)
documents = paginator.get_page(self.request.GET.get('p'))
context.update({
'ordering': ordering,
'documents': documents,
'query_string': query_string,
'is_searching': bool(query_string),
'next': self.request.get_full_path(),
})
return context
def index(request):
# Get Videos (filtered by user permission)
videos = Video.objects.all()
# Search
query_string = None
if 'q' in request.GET:
form = SearchForm(request.GET, placeholder=_("Search videos"))
if form.is_valid():
query_string = form.cleaned_data['q']
videos = videos.search(query_string)
else:
form = SearchForm(placeholder=_("Search videos"))
# Filter by collection
current_collection = None
collection_id = request.GET.get('collection_id')
if collection_id:
try:
current_collection = Collection.objects.get(id=collection_id)
videos = videos.filter(collection=current_collection)
except (ValueError, Collection.DoesNotExist):
pass
paginator = Paginator(videos, per_page=25)
collections = permission_policy.collections_user_has_any_permission_for(
request.user, ['add', 'change']
)
if len(collections) < 2:
collections = None
else:
collections = Collection.order_for_display(collections)
page = paginator.get_page(request.GET.get('p'))
# Create response
if request.is_ajax():
response = render(request, 'wagtailvideos/videos/results.html', {
'videos': page,
'query_string': query_string,
'is_searching': bool(query_string),
})
return response
else:
response = render(request, 'wagtailvideos/videos/index.html', {
'videos': page,
'query_string': query_string,
'is_searching': bool(query_string),
'search_form': form,
'popular_tags': popular_tags_for_model(Video),
'current_collection': current_collection,
'collections': collections,
})
return response
def chooser(request):
Document = get_document_model()
if permission_policy.user_has_permission(request.user, 'add'):
DocumentForm = get_document_form(Document)
uploadform = DocumentForm(user=request.user)
else:
uploadform = None
documents = Document.objects.all()
# allow hooks to modify the queryset
for hook in hooks.get_hooks('construct_document_chooser_queryset'):
documents = hook(documents, request)
q = None
if 'q' in request.GET or 'p' in request.GET or 'collection_id' in request.GET:
collection_id = request.GET.get('collection_id')
if collection_id:
documents = documents.filter(collection=collection_id)
searchform = SearchForm(request.GET)
if searchform.is_valid():
q = searchform.cleaned_data['q']
documents = documents.search(q)
is_searching = True
else:
documents = documents.order_by('-created_at')
is_searching = False
# Pagination
paginator, documents = paginate(request, documents, per_page=10)
return render(request, "wagtaildocs/chooser/results.html", {
'documents': documents,
'query_string': q,
'is_searching': is_searching,
})
else:
searchform = SearchForm()
collections = Collection.objects.all()
if len(collections) < 2:
collections = None
documents = documents.order_by('-created_at')
paginator, documents = paginate(request, documents, per_page=10)
return render_modal_workflow(request, 'wagtaildocs/chooser/chooser.html', None, {
'documents': documents,
'uploadform': uploadform,
'searchform': searchform,
'collections': collections,
'is_searching': False,
}, json_data=get_chooser_context())
def list(request, app_label, model_name):
model = get_snippet_model_from_url_params(app_label, model_name)
permissions = [
get_permission_name(action, model)
for action in ['add', 'change', 'delete']
]
if not any([request.user.has_perm(perm) for perm in permissions]):
return permission_denied(request)
items = model.objects.all()
# Preserve the snippet's model-level ordering if specified, but fall back on PK if not
# (to ensure pagination is consistent)
if not items.ordered:
items = items.order_by('pk')
# Search
is_searchable = class_is_indexed(model)
is_searching = False
search_query = None
if is_searchable and 'q' in request.GET:
search_form = SearchForm(request.GET, placeholder=_("Search %(snippet_type_name)s") % {
'snippet_type_name': model._meta.verbose_name_plural
})
if search_form.is_valid():
search_query = search_form.cleaned_data['q']
search_backend = get_search_backend()
items = search_backend.search(search_query, items)
is_searching = True
else:
search_form = SearchForm(placeholder=_("Search %(snippet_type_name)s") % {
'snippet_type_name': model._meta.verbose_name_plural
})
paginator = Paginator(items, per_page=20)
paginated_items = paginator.get_page(request.GET.get('p'))
# Template
if request.is_ajax():
template = 'wagtailsnippets/snippets/results.html'
else:
template = 'wagtailsnippets/snippets/type_index.html'
return render(request, template, {
'model_opts': model._meta,
'items': paginated_items,
'can_add_snippet': request.user.has_perm(get_permission_name('add', model)),
'can_delete_snippets': request.user.has_perm(get_permission_name('delete', model)),
'is_searchable': is_searchable,
'search_form': search_form,
'is_searching': is_searching,
'query_string': search_query,
})
def list(request, app_label, model_name):
model = get_snippet_model_from_url_params(app_label, model_name)
permissions = [
get_permission_name(action, model)
for action in ['add', 'change', 'delete']
]
if not any([request.user.has_perm(perm) for perm in permissions]):
return permission_denied(request)
items = model.objects.all()
# Preserve the snippet's model-level ordering if specified, but fall back on PK if not
# (to ensure pagination is consistent)
if not items.ordered:
items = items.order_by('pk')
# Search
is_searchable = class_is_indexed(model)
is_searching = False
search_query = None
if is_searchable and 'q' in request.GET:
search_form = SearchForm(request.GET, placeholder=_("Search %(snippet_type_name)s") % {
'snippet_type_name': model._meta.verbose_name_plural
})
if search_form.is_valid():
search_query = search_form.cleaned_data['q']
search_backend = get_search_backend()
items = search_backend.search(search_query, items)
is_searching = True
else:
search_form = SearchForm(placeholder=_("Search %(snippet_type_name)s") % {
'snippet_type_name': model._meta.verbose_name_plural
})
paginator = Paginator(items, per_page=20)
paginated_items = paginator.get_page(request.GET.get('p'))
# Template
if request.is_ajax():
template = 'wagtailsnippets/snippets/results.html'
else:
template = 'wagtailsnippets/snippets/type_index.html'
return render(request, template, {
'model_opts': model._meta,
'items': paginated_items,
'can_add_snippet': request.user.has_perm(get_permission_name('add', model)),
'can_delete_snippets': request.user.has_perm(get_permission_name('delete', model)),
'is_searchable': is_searchable,
'search_form': search_form,
'is_searching': is_searching,
'query_string': search_query,
})
def index(request):
EmbedVideo = get_embed_video_model()
# Get embed videos
embed_videos = EmbedVideo.objects.order_by('-created_at')
# Permissions
if not request.user.has_perm('wagtail_embed_videos.change_embedvideo'):
# restrict to the user's own embed videos
embed_videos = embed_videos.filter(uploaded_by_user=request.user)
# Search
query_string = None
if 'q' in request.GET:
form = SearchForm(request.GET, placeholder=_("Search videos"))
if form.is_valid():
query_string = form.cleaned_data['q']
if not request.user.has_perm(
'wagtail_embed_videos.change_embedvideo'):
# restrict to the user's own embed videos
embed_videos = EmbedVideo.objects.search(
query_string,
filters={'uploaded_by_user_id': request.user.id})
else:
embed_videos = EmbedVideo.objects.search(query_string)
else:
form = SearchForm(placeholder=_("Search videos"))
# Pagination
p = request.GET.get('p', 1)
paginator = Paginator(embed_videos, 20)
try:
embed_videos = paginator.page(p)
except PageNotAnInteger:
embed_videos = paginator.page(1)
except EmptyPage:
embed_videos = paginator.page(paginator.num_pages)
# Create response
if request.is_ajax():
return render(
request, 'wagtail_embed_videos/embed_videos/results.html', {
'embed_videos': embed_videos,
'query_string': query_string,
'is_searching': bool(query_string),
})
else:
return render(
request, 'wagtail_embed_videos/embed_videos/index.html', {
'embed_videos': embed_videos,
'query_string': query_string,
'is_searching': bool(query_string),
'search_form': form,
'popular_tags': popular_tags_for_model(EmbedVideo),
})
def choose(request, app_label, model_name):
model = get_snippet_model_from_url_params(app_label, model_name)
items = model.objects.all()
# Preserve the snippet's model-level ordering if specified, but fall back on PK if not
# (to ensure pagination is consistent)
if not items.ordered:
items = items.order_by('pk')
# Search
is_searchable = class_is_indexed(model)
is_searching = False
search_query = None
if is_searchable and 'q' in request.GET:
search_form = SearchForm(
request.GET,
placeholder=_("Search %(snippet_type_name)s") %
{'snippet_type_name': model._meta.verbose_name})
if search_form.is_valid():
search_query = search_form.cleaned_data['q']
search_backend = get_search_backend()
items = search_backend.search(search_query, items)
is_searching = True
else:
search_form = SearchForm(
placeholder=_("Search %(snippet_type_name)s") %
{'snippet_type_name': model._meta.verbose_name})
# Pagination
paginator = Paginator(items, per_page=25)
paginated_items = paginator.get_page(request.GET.get('p'))
# If paginating or searching, render "results.html"
if request.GET.get('results', None) == 'true':
return render(
request, "wagtailsnippets/chooser/results.html", {
'model_opts': model._meta,
'items': paginated_items,
'query_string': search_query,
'is_searching': is_searching,
})
return render_modal_workflow(request,
'wagtailsnippets/chooser/choose.html',
None, {
'model_opts': model._meta,
'items': paginated_items,
'is_searchable': is_searchable,
'search_form': search_form,
'query_string': search_query,
'is_searching': is_searching,
},
json_data={'step': 'choose'})
def choose(request, app_label, model_name):
model = get_snippet_model_from_url_params(app_label, model_name)
items = model.objects.all()
# Preserve the snippet's model-level ordering if specified, but fall back on PK if not
# (to ensure pagination is consistent)
if not items.ordered:
items = items.order_by('pk')
# Search
is_searchable = class_is_indexed(model)
is_searching = False
search_query = None
if is_searchable and 'q' in request.GET:
search_form = SearchForm(request.GET, placeholder=_("Search %(snippet_type_name)s") % {
'snippet_type_name': model._meta.verbose_name
})
if search_form.is_valid():
search_query = search_form.cleaned_data['q']
search_backend = get_search_backend()
items = search_backend.search(search_query, items)
is_searching = True
else:
search_form = SearchForm(placeholder=_("Search %(snippet_type_name)s") % {
'snippet_type_name': model._meta.verbose_name
})
# Pagination
paginator = Paginator(items, per_page=25)
paginated_items = paginator.get_page(request.GET.get('p'))
# If paginating or searching, render "results.html"
if request.GET.get('results', None) == 'true':
return render(request, "wagtailsnippets/chooser/results.html", {
'model_opts': model._meta,
'items': paginated_items,
'query_string': search_query,
'is_searching': is_searching,
})
return render_modal_workflow(
request,
'wagtailsnippets/chooser/choose.html', None,
{
'model_opts': model._meta,
'items': paginated_items,
'is_searchable': is_searchable,
'search_form': search_form,
'query_string': search_query,
'is_searching': is_searching,
}, json_data={'step': 'choose'}
)
class BaseListingView(TemplateView):
@method_decorator(permission_checker.require_any('add', 'change',
'delete'))
def get(self, request):
return super().get(request)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
# Get images (filtered by user permission)
images = permission_policy.instances_user_has_any_permission_for(
self.request.user,
['change', 'delete'
]).order_by('-created_at').select_related('collection')
# Search
query_string = None
if 'q' in self.request.GET:
self.form = SearchForm(self.request.GET,
placeholder=_("Search images"))
if self.form.is_valid():
query_string = self.form.cleaned_data['q']
images = images.search(query_string)
else:
self.form = SearchForm(placeholder=_("Search images"))
# Filter by collection
self.current_collection = None
collection_id = self.request.GET.get('collection_id')
if collection_id:
try:
self.current_collection = Collection.objects.get(
id=collection_id)
images = images.filter(collection=self.current_collection)
except (ValueError, Collection.DoesNotExist):
pass
# Filter by tag
self.current_tag = self.request.GET.get('tag')
if self.current_tag:
try:
images = images.filter(tags__name=self.current_tag)
except (AttributeError):
self.current_tag = None
paginator = Paginator(images, per_page=INDEX_PAGE_SIZE)
images = paginator.get_page(self.request.GET.get('p'))
context.update({
'images': images,
'query_string': query_string,
'is_searching': bool(query_string),
})
return context
def chooser(request):
Media = get_media_model()
if permission_policy.user_has_permission(request.user, 'add'):
MediaForm = get_media_form(Media)
uploadform = MediaForm(user=request.user)
else:
uploadform = None
media_files = Media.objects.order_by('-created_at')
#May not be necessary.
for hook in hooks.get_hooks('construct_media_chooser_queryset'):
media_files = hook(media_files, request)
if ('q' in request.GET or 'p' in request.GET
or 'collection_id' in request.GET):
media_files = Media.objects.order_by('-created_at')
collection_id = request.GET.get('collection_id')
if collection_id:
media_files = media_files.filter(collection=collection_id)
searchform = SearchForm(request.GET)
if searchform.is_valid():
q = searchform.cleaned_data['q']
media_files = media_files.search(q)
is_searching = True
else:
is_searching = False
q = None
# Pagination
paginator, media_files = paginate(request, media_files, per_page=10)
return render(
request, "wagtailmedia/chooser/results.html", {
'media_files': media_files,
'query_string': q,
'is_searching': is_searching,
})
else:
paginator, media_files = paginate(request, media_files, per_page=10)
context = get_chooser_context(request)
context.update({
'media_files': media_files,
'uploadform': uploadform,
})
return render_modal_workflow(request,
'wagtailmedia/chooser/chooser.html',
None,
context,
json_data=get_chooser_js_data())
def choose(request):
model = Poll
items = Poll.objects.all()
if not items.ordered:
items = items.order_by('pk')
# Search
is_searchable = class_is_indexed(model)
is_searching = False
search_query = None
if is_searchable and 'q' in request.GET:
search_form = AdminSearchForm(
request.GET,
placeholder=_("Search %(snippet_type_name)s") %
{'snippet_type_name': model._meta.verbose_name})
if search_form.is_valid():
search_query = search_form.cleaned_data['q']
search_backend = get_search_backend()
items = search_backend.search(search_query, items)
is_searching = True
else:
search_form = AdminSearchForm()
# Pagination
paginator = Paginator(items, per_page=25)
paginated_items = paginator.get_page(request.GET.get('p'))
# If paginating or searching, render "results.html"
if request.GET.get('results', None) == 'true':
return render(
request, "wagtailpolls/results.html", {
'model_opts': model._meta,
'items': paginated_items,
'query_string': search_query,
'is_searching': is_searching,
})
return render_modal_workflow(request,
'wagtailpolls/choose.html',
None, {
'model_opts': model._meta,
'snippet_type_name': 'Poll',
'items': paginated_items,
'is_searchable': True,
'search_form': search_form,
'query_string': search_query,
'is_searching': is_searching,
},
json_data={'step': 'choose'})
def get(self, request):
self.i18n_enabled = getattr(settings, "WAGTAIL_I18N_ENABLED", False)
# A missing or empty page_type parameter indicates 'all page types' (i.e. descendants of wagtailcore.page)
page_type_string = request.GET.get("page_type") or "wagtailcore.page"
try:
desired_classes = page_models_from_string(page_type_string)
except (ValueError, LookupError):
raise Http404
pages = Page.objects.all()
if self.i18n_enabled:
pages = pages.select_related("locale")
# allow hooks to modify the queryset
for hook in hooks.get_hooks("construct_page_chooser_queryset"):
pages = hook(pages, request)
search_form = SearchForm(request.GET)
if search_form.is_valid() and search_form.cleaned_data["q"]:
pages = pages.exclude(depth=1) # never include root
pages = pages.type(*desired_classes)
pages = pages.specific()
pages = pages.search(search_form.cleaned_data["q"])
else:
pages = pages.none()
paginator = Paginator(pages, per_page=25)
pages = paginator.get_page(request.GET.get("p"))
for page in pages:
page.can_choose = True
page.is_parent_page = False
table = PageChooserTable(
self.columns,
pages,
)
return TemplateResponse(
request,
"wagtailadmin/chooser/_search_results.html",
shared_context(
request,
{
"searchform": search_form,
"table": table,
"pages": pages,
"page_type_string": page_type_string,
"show_locale_labels": self.i18n_enabled,
},
),
)
class BaseChooseView(View):
def get(self, request):
self.image_model = get_image_model()
images = (permission_policy.instances_user_has_any_permission_for(
request.user, ["choose"]).order_by("-created_at").select_related(
"collection").prefetch_renditions("max-165x165"))
# allow hooks to modify the queryset
for hook in hooks.get_hooks("construct_image_chooser_queryset"):
images = hook(images, request)
collection_id = request.GET.get("collection_id")
if collection_id:
images = images.filter(collection=collection_id)
self.is_searching = False
self.q = None
if "q" in request.GET:
self.search_form = SearchForm(request.GET)
if self.search_form.is_valid():
self.q = self.search_form.cleaned_data["q"]
self.is_searching = True
images = images.search(self.q)
else:
self.search_form = SearchForm()
if not self.is_searching:
tag_name = request.GET.get("tag")
if tag_name:
images = images.filter(tags__name=tag_name)
# Pagination
paginator = Paginator(images, per_page=CHOOSER_PAGE_SIZE)
self.images = paginator.get_page(request.GET.get("p"))
return self.render_to_response()
def get_context_data(self):
return {
"images": self.images,
"is_searching": self.is_searching,
"query_string": self.q,
"will_select_format": self.request.GET.get("select_format"),
}
def render_to_response(self):
raise NotImplementedError()
class BaseChooseView(View):
def get(self, request):
self.image_model = get_image_model()
images = permission_policy.instances_user_has_any_permission_for(
request.user, ['choose']
).order_by('-created_at')
# allow hooks to modify the queryset
for hook in hooks.get_hooks('construct_image_chooser_queryset'):
images = hook(images, request)
collection_id = request.GET.get('collection_id')
if collection_id:
images = images.filter(collection=collection_id)
self.is_searching = False
self.q = None
if 'q' in request.GET:
self.search_form = SearchForm(request.GET)
if self.search_form.is_valid():
self.q = self.search_form.cleaned_data['q']
self.is_searching = True
images = images.search(self.q)
else:
self.search_form = SearchForm()
if not self.is_searching:
tag_name = request.GET.get('tag')
if tag_name:
images = images.filter(tags__name=tag_name)
# Pagination
paginator = Paginator(images, per_page=CHOOSER_PAGE_SIZE)
self.images = paginator.get_page(request.GET.get('p'))
return self.render_to_response()
def get_context_data(self):
return {
'images': self.images,
'is_searching': self.is_searching,
'query_string': self.q,
'will_select_format': self.request.GET.get('select_format')
}
def render_to_response(self):
raise NotImplementedError()
def choose_modal(request):
try:
newsitem_model_string = request.GET['type']
NewsItem = get_newsitem_model(newsitem_model_string)
except (ValueError, KeyError):
raise Http404
newsitem_list = NewsItem.objects.all()
# Search
is_searching = False
search_query = None
if 'q' in request.GET:
search_form = SearchForm(request.GET, placeholder="Search news")
if search_form.is_valid():
search_query = search_form.cleaned_data['q']
search_backend = get_search_backend()
newsitem_list = search_backend.search(search_query, newsitem_list)
is_searching = True
else:
search_form = SearchForm()
# Pagination
paginator, paginated_items = paginate(request, newsitem_list, per_page=10)
# If paginating or searching, render "results.html" - these views are
# accessed via AJAX so do not need the modal wrapper
if request.GET.get('results', None) == 'true':
return render(
request, "wagtailnews/chooser/search_results.html", {
'query_string': search_query,
'items': paginated_items,
'is_searching': is_searching,
})
return render_modal_workflow(
request, 'wagtailnews/chooser/chooser.html',
'wagtailnews/chooser/choose.js', {
'query_string': search_query,
'newsitem_type': newsitem_model_string,
'items': paginated_items,
'is_searchable': True,
'is_searching': is_searching,
'search_form': search_form,
})
def index(request):
# Get Videos (filtered by user permission)
videos = Video.objects.all()
# Search
query_string = None
if 'q' in request.GET:
form = SearchForm(request.GET, placeholder=_("Search videos"))
if form.is_valid():
query_string = form.cleaned_data['q']
videos = videos.search(query_string)
else:
form = SearchForm(placeholder=_("Search videos"))
# Filter by collection
current_collection = None
collection_id = request.GET.get('collection_id')
if collection_id:
try:
current_collection = Collection.objects.get(id=collection_id)
videos = videos.filter(collection=current_collection)
except (ValueError, Collection.DoesNotExist):
pass
paginator, videos = paginate(request, videos)
# Create response
if request.is_ajax():
response = render(
request, 'wagtailvideos/videos/results.html', {
'vidoes': videos,
'query_string': query_string,
'is_searching': bool(query_string),
})
return response
else:
response = render(
request, 'wagtailvideos/videos/index.html', {
'videos': videos,
'query_string': query_string,
'is_searching': bool(query_string),
'search_form': form,
'popular_tags': popular_tags_for_model(Video),
'current_collection': current_collection,
})
return response
def search_unsplash_images(request):
if request.POST and "image_id" in request.POST:
image = add_unsplash_image_to_wagtail(request.POST["image_id"])
return redirect(reverse("wagtailimages:edit", args=(image.id, )))
query_string = None
if 'q' in request.GET:
form = SearchForm(request.GET, placeholder=_("Search Unsplash"))
if form.is_valid():
query_string = form.cleaned_data['q']
else:
form = SearchForm(placeholder=_("Search Unsplash"))
page = int(request.GET.get("p", 1))
per_page = 25
response = None
if query_string:
response = api.search.photos(query=query_string,
page=page,
per_page=per_page)
context = {
'search_form': form,
'results': None,
}
if response:
total_pages = response['total_pages']
next_page = None
if page != total_pages:
next_page = page + 1
previous_page = None
if page != 0:
previous_page = page - 1
contexxt.update(
current_page=total_pages,
current_page=page,
total_results=response['total'],
results=response['results'],
next_page=next_page,
previous_page=previous_page,
)
return TemplateResponse(request, 'wagtail_unsplash/search.html', context)
def search(request, parent_page_id=None):
# A missing or empty page_type parameter indicates 'all page types' (i.e. descendants of wagtailcore.page)
page_type_string = request.GET.get('page_type') or 'wagtailcore.page'
try:
desired_classes = page_models_from_string(page_type_string)
except (ValueError, LookupError):
raise Http404
pages = Page.objects.all()
show_locale_labels = getattr(settings, 'WAGTAIL_I18N_ENABLED', False)
if show_locale_labels:
pages = pages.select_related('locale')
# allow hooks to modify the queryset
for hook in hooks.get_hooks('construct_page_chooser_queryset'):
pages = hook(pages, request)
search_form = SearchForm(request.GET)
if search_form.is_valid() and search_form.cleaned_data['q']:
pages = pages.exclude(
depth=1 # never include root
)
pages = pages.type(*desired_classes)
pages = pages.specific()
pages = pages.search(search_form.cleaned_data['q'])
else:
pages = pages.none()
paginator = Paginator(pages, per_page=25)
pages = paginator.get_page(request.GET.get('p'))
for page in pages:
page.can_choose = True
return TemplateResponse(
request, 'wagtailadmin/chooser/_search_results.html',
shared_context(request, {
'searchform': search_form,
'pages': pages,
'page_type_string': page_type_string,
'show_locale_labels': show_locale_labels,
})
)
def product_choose(request):
queryset = (
Product.objects.get_queryset()
.browsable()
.order_by('title')
)
p = request.GET.get('p', 1)
if request.GET.get('q'):
searchform = SearchForm(request.GET)
if searchform.is_valid():
cleaned_data = searchform.cleaned_data
if hasattr(queryset, 'search'):
queryset = queryset.search(cleaned_data['q'])
else:
queryset = queryset.filter(
Q(title__icontains=cleaned_data['q']) |
Q(upc__icontains=cleaned_data['q']))
else:
searchform = SearchForm()
paginator = Paginator(queryset, 10)
try:
paginated_items = paginator.page(p)
except PageNotAnInteger:
paginated_items = paginator.page(1)
except EmptyPage:
paginated_items = paginator.page(paginator.num_pages)
return render_modal_workflow(
request,
'oscar_wagtail/chooser/product_choose.html',
'oscar_wagtail/chooser/product_choose.js',
{
'items': paginated_items,
'searchform': searchform,
}
)
def render_html(self, request, current=None):
search_areas = self.search_items_for_request(request)
# Get query parameter
form = SearchForm(request.GET)
query = ''
if form.is_valid():
query = form.cleaned_data['q']
# provide a hook for modifying the search area, if construct_hook_name has been set
if self.construct_hook_name:
for fn in hooks.get_hooks(self.construct_hook_name):
fn(request, search_areas)
rendered_search_areas = []
for item in search_areas:
rendered_search_areas.append(
item.render_html(request, query, current))
return mark_safe(''.join(rendered_search_areas))
def search(request, parent_page_id=None):
# A missing or empty page_type parameter indicates 'all page types' (i.e. descendants of wagtailcore.page)
page_type_string = request.GET.get('page_type') or 'wagtailcore.page'
try:
desired_classes = page_models_from_string(page_type_string)
except (ValueError, LookupError):
raise Http404
pages = Page.objects.all()
# allow hooks to modify the queryset
for hook in hooks.get_hooks('construct_page_chooser_queryset'):
pages = hook(pages, request)
search_form = SearchForm(request.GET)
if search_form.is_valid() and search_form.cleaned_data['q']:
pages = pages.exclude(
depth=1 # never include root
)
pages = filter_page_type(pages, desired_classes)
pages = pages.specific()
pages = pages.search(search_form.cleaned_data['q'])
else:
pages = pages.none()
paginator = Paginator(pages, per_page=25)
pages = paginator.get_page(request.GET.get('p'))
for page in pages:
page.can_choose = True
return render(
request, 'wagtailadmin/chooser/_search_results.html',
shared_context(request, {
'searchform': search_form,
'pages': pages,
'page_type_string': page_type_string,
})
)
def chooser(request, get_results=False):
# Get most popular queries
queries = models.Query.get_most_popular()
# If searching, filter results by query string
query_string = None
if "q" in request.GET:
searchform = SearchForm(request.GET)
if searchform.is_valid():
query_string = searchform.cleaned_data["q"]
queries = queries.filter(
query_string__icontains=normalise_query_string(query_string))
else:
searchform = SearchForm()
paginator = Paginator(queries, per_page=10)
queries = paginator.get_page(request.GET.get("p"))
# Render
if get_results:
return TemplateResponse(
request,
"wagtailsearch/queries/chooser/results.html",
{
"queries": queries,
},
)
else:
return render_modal_workflow(
request,
"wagtailsearch/queries/chooser/chooser.html",
None,
{
"queries": queries,
"searchform": searchform,
},
json_data={"step": "chooser"},
)
def get_queryset(self):
# Get documents (filtered by user permission)
documents = self.get_documents()
# Ordering
ordering = None
if 'ordering' in self.request.GET \
and self.request.GET['ordering'] in ['title',
'-created_at',
'file_size']:
ordering = self.request.GET['ordering']
else:
ordering = 'title'
documents = documents.order_by(ordering)
# Search
query_string = None
if 'q' in self.request.GET:
form = SearchForm(self.request.GET, placeholder="Search documents")
if form.is_valid():
query_string = form.cleaned_data['q']
documents = documents.search(query_string)
return documents
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
items = self.model.objects.all()
enable_locale_filter = getattr(settings, 'WAGTAIL_I18N_ENABLED',
False) and issubclass(
self.model, TranslatableMixin)
if enable_locale_filter:
if 'locale' in self.request.GET:
try:
locale = Locale.objects.get(
language_code=self.request.GET['locale'])
except Locale.DoesNotExist:
# Redirect to snippet without locale
return redirect('wagtailsnippets:list', self.app_label,
self.model_name)
else:
# Default to active locale (this will take into account the user's chosen admin language)
locale = Locale.get_active()
items = items.filter(locale=locale)
else:
locale = None
# Preserve the snippet's model-level ordering if specified, but fall back on PK if not
# (to ensure pagination is consistent)
if not items.ordered:
items = items.order_by('pk')
# Search
is_searchable = class_is_indexed(self.model)
is_searching = False
search_query = None
if is_searchable and 'q' in self.request.GET:
search_form = SearchForm(
self.request.GET,
placeholder=_("Search %(snippet_type_name)s") %
{'snippet_type_name': self.model._meta.verbose_name_plural})
if search_form.is_valid():
search_query = search_form.cleaned_data['q']
search_backend = get_search_backend()
items = search_backend.search(search_query, items)
is_searching = True
else:
search_form = SearchForm(
placeholder=_("Search %(snippet_type_name)s") %
{'snippet_type_name': self.model._meta.verbose_name_plural})
paginator = Paginator(items, per_page=20)
paginated_items = paginator.get_page(self.request.GET.get('p'))
context.update({
'model_opts':
self.model._meta,
'items':
paginated_items,
'can_add_snippet':
self.request.user.has_perm(get_permission_name('add', self.model)),
'can_delete_snippets':
self.request.user.has_perm(
get_permission_name('delete', self.model)),
'is_searchable':
is_searchable,
'search_form':
search_form,
'is_searching':
is_searching,
'query_string':
search_query,
'locale':
None,
'translations': [],
})
if enable_locale_filter:
context.update({
'locale':
locale,
'translations': [{
'locale':
locale,
'url':
reverse('wagtailsnippets:list',
args=[self.app_label, self.model_name]) +
'?locale=' + locale.language_code
} for locale in Locale.objects.all().exclude(id=locale.id)],
})
return context
def index(request):
q = None
is_searching = False
model_fields = [f.name for f in User._meta.get_fields()]
if 'q' in request.GET:
form = SearchForm(request.GET, placeholder=_("Search users"))
if form.is_valid():
q = form.cleaned_data['q']
is_searching = True
conditions = Q()
for term in q.split():
if 'username' in model_fields:
conditions |= Q(username__icontains=term)
if 'first_name' in model_fields:
conditions |= Q(first_name__icontains=term)
if 'last_name' in model_fields:
conditions |= Q(last_name__icontains=term)
if 'email' in model_fields:
conditions |= Q(email__icontains=term)
users = User.objects.filter(conditions)
else:
form = SearchForm(placeholder=_("Search users"))
if not is_searching:
users = User.objects.all()
if 'last_name' in model_fields and 'first_name' in model_fields:
users = users.order_by('last_name', 'first_name')
if 'ordering' in request.GET:
ordering = request.GET['ordering']
if ordering == 'username':
users = users.order_by(User.USERNAME_FIELD)
else:
ordering = 'name'
paginator, users = paginate(request, users)
if request.is_ajax():
return render(request, "wagtailusers/users/results.html", {
'users': users,
'is_searching': is_searching,
'query_string': q,
'ordering': ordering,
})
else:
return render(request, "wagtailusers/users/index.html", {
'search_form': form,
'users': users,
'is_searching': is_searching,
'ordering': ordering,
'query_string': q,
})
def search(request):
pages = all_pages = Page.objects.all().prefetch_related('content_type').specific()
q = MATCH_ALL
content_types = []
pagination_query_params = QueryDict({}, mutable=True)
ordering = None
if 'ordering' in request.GET:
if request.GET['ordering'] in ['title', '-title', 'latest_revision_created_at', '-latest_revision_created_at', 'live', '-live']:
ordering = request.GET['ordering']
if ordering == 'title':
pages = pages.order_by('title')
elif ordering == '-title':
pages = pages.order_by('-title')
if ordering == 'latest_revision_created_at':
pages = pages.order_by('latest_revision_created_at')
elif ordering == '-latest_revision_created_at':
pages = pages.order_by('-latest_revision_created_at')
if ordering == 'live':
pages = pages.order_by('live')
elif ordering == '-live':
pages = pages.order_by('-live')
if 'content_type' in request.GET:
pagination_query_params['content_type'] = request.GET['content_type']
app_label, model_name = request.GET['content_type'].split('.')
try:
selected_content_type = ContentType.objects.get_by_natural_key(app_label, model_name)
except ContentType.DoesNotExist:
raise Http404
pages = pages.filter(content_type=selected_content_type)
else:
selected_content_type = None
if 'q' in request.GET:
form = SearchForm(request.GET)
if form.is_valid():
q = form.cleaned_data['q']
pagination_query_params['q'] = q
all_pages = all_pages.search(q, order_by_relevance=not ordering, operator='and')
pages = pages.search(q, order_by_relevance=not ordering, operator='and')
if pages.supports_facet:
content_types = [
(ContentType.objects.get(id=content_type_id), count)
for content_type_id, count in all_pages.facet('content_type_id').items()
]
else:
form = SearchForm()
paginator, pages = paginate(request, pages)
if request.is_ajax():
return render(request, "wagtailadmin/pages/search_results.html", {
'pages': pages,
'all_pages': all_pages,
'query_string': q,
'content_types': content_types,
'selected_content_type': selected_content_type,
'ordering': ordering,
'pagination_query_params': pagination_query_params.urlencode(),
})
else:
return render(request, "wagtailadmin/pages/search.html", {
'search_form': form,
'pages': pages,
'all_pages': all_pages,
'query_string': q,
'content_types': content_types,
'selected_content_type': selected_content_type,
'ordering': ordering,
'pagination_query_params': pagination_query_params.urlencode(),
})
def index(request):
Document = get_document_model()
# Get documents (filtered by user permission)
documents = permission_policy.instances_user_has_any_permission_for(
request.user, ['change', 'delete']
)
# Ordering
if 'ordering' in request.GET and request.GET['ordering'] in ['title', '-created_at']:
ordering = request.GET['ordering']
else:
ordering = '-created_at'
documents = documents.order_by(ordering)
# Filter by collection
current_collection = None
collection_id = request.GET.get('collection_id')
if collection_id:
try:
current_collection = Collection.objects.get(id=collection_id)
documents = documents.filter(collection=current_collection)
except (ValueError, Collection.DoesNotExist):
pass
# Search
query_string = None
if 'q' in request.GET:
form = SearchForm(request.GET, placeholder=_("Search documents"))
if form.is_valid():
query_string = form.cleaned_data['q']
documents = documents.search(query_string)
else:
form = SearchForm(placeholder=_("Search documents"))
# Pagination
paginator = Paginator(documents, per_page=20)
documents = paginator.get_page(request.GET.get('p'))
collections = permission_policy.collections_user_has_any_permission_for(
request.user, ['add', 'change']
)
if len(collections) < 2:
collections = None
else:
collections = Collection.order_for_display(collections)
# Create response
if request.is_ajax():
return render(request, 'wagtaildocs/documents/results.html', {
'ordering': ordering,
'documents': documents,
'query_string': query_string,
'is_searching': bool(query_string),
})
else:
return render(request, 'wagtaildocs/documents/index.html', {
'ordering': ordering,
'documents': documents,
'query_string': query_string,
'is_searching': bool(query_string),
'search_form': form,
'popular_tags': popular_tags_for_model(Document),
'user_can_add': permission_policy.user_has_permission(request.user, 'add'),
'collections': collections,
'current_collection': current_collection,
})
