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, 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 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):
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, 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 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 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 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):
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'),
})
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 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 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 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 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"))
next_url = reverse("wagtaildocs:index")
request_query_string = self.request.META.get("QUERY_STRING")
if request_query_string:
next_url += "?" + request_query_string
context.update({
"ordering": ordering,
"documents": documents,
"query_string": query_string,
"is_searching": bool(query_string),
"next": next_url,
})
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 get(self, request, app_label, model_name):
self.model = get_snippet_model_from_url_params(app_label, model_name)
items = self.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')
# Filter by locale
self.locale = None
self.locale_filter = None
self.selected_locale = None
if issubclass(self.model, TranslatableMixin):
# 'locale' is the Locale of the object that this snippet is being chosen for
if request.GET.get('locale'):
self.locale = get_object_or_404(
Locale, language_code=request.GET['locale'])
# 'locale_filter' is the current value of the "Locale" selector in the UI
if request.GET.get('locale_filter'):
self.locale_filter = get_object_or_404(
Locale, language_code=request.GET['locale_filter'])
self.selected_locale = self.locale_filter or self.locale
if self.selected_locale:
items = items.filter(locale=self.selected_locale)
# Search
self.is_searchable = class_is_indexed(self.model)
self.is_searching = False
self.search_query = None
if self.is_searchable and 'q' in request.GET:
self.search_form = SearchForm(
request.GET,
placeholder=_("Search %(snippet_type_name)s") %
{'snippet_type_name': self.model._meta.verbose_name})
if self.search_form.is_valid():
self.search_query = self.search_form.cleaned_data['q']
search_backend = get_search_backend()
items = search_backend.search(self.search_query, items)
self.is_searching = True
else:
self.search_form = SearchForm(
placeholder=_("Search %(snippet_type_name)s") %
{'snippet_type_name': self.model._meta.verbose_name})
# Pagination
paginator = Paginator(items, per_page=25)
self.paginated_items = paginator.get_page(request.GET.get('p'))
return self.render_to_response()
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 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"))
next_url = reverse("wagtailimages:index")
request_query_string = self.request.META.get("QUERY_STRING")
if request_query_string:
next_url += "?" + request_query_string
context.update({
"images": images,
"query_string": query_string,
"is_searching": bool(query_string),
"next": next_url,
})
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_search_form(self):
if self.is_searchable and "q" in self.request.GET:
return SearchForm(
self.request.GET,
placeholder=_("Search %(snippet_type_name)s") %
{"snippet_type_name": self.model._meta.verbose_name_plural},
)
return SearchForm(
placeholder=_("Search %(snippet_type_name)s") %
{"snippet_type_name": self.model._meta.verbose_name_plural})
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,
},
),
)
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 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 get_search_form(self):
if self.model is None:
return None
if self.is_searchable and self.search_kwarg in self.request.GET:
return SearchForm(
self.request.GET,
placeholder=_("Search %(model_name)s")
% {"model_name": self.model._meta.verbose_name_plural},
)
return SearchForm(
placeholder=_("Search %(model_name)s")
% {"model_name": self.model._meta.verbose_name_plural}
)
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 chooser_upload(request):
VideoForm = get_video_form(Video)
searchform = SearchForm()
if request.POST:
video = Video(uploaded_by_user=request.user)
form = VideoForm(request.POST, request.FILES, instance=video)
if form.is_valid():
video.uploaded_by_user = request.user
video.save()
# Reindex the video to make sure all tags are indexed
search_index.insert_or_update_object(video)
return render_modal_workflow(
request, None, 'wagtailvideos/chooser/video_chosen.js',
{'video_json': get_video_json(video)}
)
else:
form = VideoForm()
videos = Video.objects.order_by('title')
paginator, videos = paginate(request, videos, per_page=12)
return render_modal_workflow(
request, 'wagtailvideos/chooser/chooser.html', 'wagtailvideos/chooser/chooser.js',
{'videos': videos, 'uploadform': form, 'searchform': searchform}
)
def index(request):
form = SearchForm(placeholder=_("Search something"))
example_form = ExampleForm()
messages.success(request,
_("Success message"),
buttons=[
messages.button('', _('View live')),
messages.button('', _('Edit'))
])
messages.warning(request,
_("Warning message"),
buttons=[
messages.button('', _('View live')),
messages.button('', _('Edit'))
])
messages.error(request,
_("Error message"),
buttons=[
messages.button('', _('View live')),
messages.button('', _('Edit'))
])
paginator = Paginator(list(range(100)), 10)
page = paginator.page(2)
return TemplateResponse(request, 'wagtailstyleguide/base.html', {
'search_form': form,
'example_form': example_form,
'example_page': page,
})
def index(request):
is_searching = False
query_string = request.GET.get('q', "")
queries = Query.objects.filter(editors_picks__isnull=False).distinct().order_by('query_string')
# Search
if query_string:
queries = queries.filter(query_string__icontains=query_string)
is_searching = True
paginator, queries = paginate(request, queries)
if request.is_ajax():
return render(request, "wagtailsearchpromotions/results.html", {
'is_searching': is_searching,
'queries': queries,
'query_string': query_string,
})
else:
return render(request, 'wagtailsearchpromotions/index.html', {
'is_searching': is_searching,
'queries': queries,
'query_string': query_string,
'search_form': SearchForm(
data=dict(q=query_string) if query_string else None, placeholder=_("Search promoted results")
),
})
def chooser_upload(request):
VideoForm = get_video_form(Video)
searchform = SearchForm()
if request.POST:
video = Video(uploaded_by_user=request.user)
form = VideoForm(request.POST, request.FILES, instance=video)
if form.is_valid():
video.uploaded_by_user = request.user
video.save()
# Reindex the video to make sure all tags are indexed
search_index.insert_or_update_object(video)
return render_modal_workflow(
request, None, json_data={
'step': 'video_chosen',
'result': get_video_json(video)
}
)
else:
form = VideoForm()
videos = Video.objects.order_by('title')
paginator = Paginator(videos, per_page=12)
page = paginator.get_page(request.GET.get('p'))
return render_modal_workflow(
request, 'wagtailvideos/chooser/chooser.html', None,
template_vars={'videos': page, 'uploadform': form, 'searchform': searchform},
json_data=get_chooser_js_data()
)
def index(request):
# Ordering
valid_ordering = ["query_string", "-query_string", "views", "-views"]
ordering = valid_ordering[0]
if "ordering" in request.GET and request.GET["ordering"] in valid_ordering:
ordering = request.GET["ordering"]
# Query
queries = Query.objects.filter(editors_picks__isnull=False).distinct()
if "views" in ordering:
queries = queries.annotate(
views=functions.Coalesce(Sum("daily_hits__hits"), 0))
queries = queries.order_by(ordering)
# Search
is_searching = False
query_string = request.GET.get("q", "")
if query_string:
queries = queries.filter(query_string__icontains=query_string)
is_searching = True
# Paginate
paginator = Paginator(queries, per_page=20)
queries = paginator.get_page(request.GET.get("p"))
if request.headers.get("x-requested-with") == "XMLHttpRequest":
return TemplateResponse(
request,
"wagtailsearchpromotions/results.html",
{
"is_searching": is_searching,
"ordering": ordering,
"queries": queries,
"query_string": query_string,
},
)
else:
return TemplateResponse(
request,
"wagtailsearchpromotions/index.html",
{
"is_searching":
is_searching,
"ordering":
ordering,
"queries":
queries,
"query_string":
query_string,
"search_form":
SearchForm(
data={"q": query_string} if query_string else None,
placeholder=_("Search promoted results"),
),
},
)
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(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 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,
})
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(),
})
