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 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',
'wagtaildocs/chooser/chooser.js', {
'documents': documents,
'uploadform': uploadform,
'searchform': searchform,
'collections': collections,
'is_searching': False,
})
def offer_choose(request):
queryset = (Offer.objects.get_queryset())
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(name__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/offer_choose.html',
'oscar_wagtail/chooser/offer_choose.js', {
'items': paginated_items,
'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, 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 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):
Media = get_media_model()
media_files = []
q = None
is_searching = False
if 'q' in request.GET or 'p' in request.GET or 'collection_id' in request.GET:
media_files = Media.objects.all()
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:
media_files = media_files.order_by('-created_at')
is_searching = False
# 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,
'pagination_template': pagination_template,
})
else:
searchform = SearchForm()
collections = Collection.objects.all()
if len(collections) < 2:
collections = None
media_files = Media.objects.order_by('-created_at')
paginator, media_files = paginate(request, media_files, per_page=10)
return render_modal_workflow(
request,
'wagtailmedia/chooser/chooser.html',
None, {
'media_files': media_files,
'searchform': searchform,
'collections': collections,
'is_searching': False,
},
json_data={
'step': 'chooser',
'error_label': "Server Error",
'error_message':
"Report this error to your webmaster with the following information:",
'tag_autocomplete_url': reverse('wagtailadmin_tag_autocomplete'),
})
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', 'wagtaildocs/chooser/chooser.js', {
'documents': documents,
'uploadform': uploadform,
'searchform': searchform,
'collections': collections,
'is_searching': False,
'uploadid': uuid.uuid4(),
})
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 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, videos = paginate(request, videos, per_page=12)
return render(request, "wagtailvideos/chooser/results.html", {
'videos': videos,
'is_searching': is_searching,
'query_string': q,
})
else:
searchform = SearchForm()
collections = Collection.objects.all()
if len(collections) < 2:
collections = None
paginator, videos = paginate(request, videos, per_page=12)
return render_modal_workflow(request, 'wagtailvideos/chooser/chooser.html', 'wagtailvideos/chooser/chooser.js', {
'videos': videos,
'uploadform': uploadform,
'searchform': searchform,
'is_searching': False,
'query_string': q,
'popular_tags': popular_tags_for_model(Video),
'collections': collections,
})
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, images = paginate(request, images)
collections = permission_policy.collections_user_has_any_permission_for(
request.user, ['add', 'change']
)
if len(collections) < 2:
collections = None
# 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):
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, videos = paginate(request, videos, per_page=12)
return render(request, "wagtailvideos/chooser/results.html", {
'videos': videos,
'is_searching': is_searching,
'query_string': q,
})
else:
searchform = SearchForm()
collections = Collection.objects.all()
if len(collections) < 2:
collections = None
paginator, videos = paginate(request, videos, per_page=12)
return render_modal_workflow(
request, 'wagtailvideos/chooser/chooser.html',
'wagtailvideos/chooser/chooser.js', {
'videos': videos,
'uploadform': uploadform,
'searchform': searchform,
'is_searching': False,
'query_string': q,
'popular_tags': popular_tags_for_model(Video),
'collections': collections,
})
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, paginated_items = paginate(request, items, per_page=25)
# 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 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, paginated_items = paginate(request, items)
# 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, paginated_items = paginate(request, items, per_page=25)
# 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', 'wagtailsnippets/chooser/choose.js',
{
'model_opts': model._meta,
'items': paginated_items,
'is_searchable': is_searchable,
'search_form': search_form,
'query_string': search_query,
'is_searching': is_searching,
}
)
def choose(request):
# TODO: Ideally this would return the endnotes for the current article.
items = EndNote.objects.all()
# Search
is_searchable = class_is_indexed(EndNote)
is_searching = False
search_query = None
if is_searchable and 'q' in request.GET:
search_form = SearchForm(request.GET, placeholder=_("Search End Notes"))
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 End Notes"))
# Pagination
p = request.GET.get("p", 1)
paginator = Paginator(items, 25)
try:
paginated_items = paginator.page(p)
except PageNotAnInteger:
paginated_items = paginator.page(1)
except EmptyPage:
paginated_items = paginator.page(paginator.num_pages)
# If paginating or searching, render "results.html"
if request.GET.get('results', None) == 'true':
return render(request, "content_notes/chooser/results.html", {
'items': paginated_items,
'query_string': search_query,
'is_searching': is_searching,
})
return render_modal_workflow(
request,
'content_notes/chooser/choose.html', 'content_notes/chooser/choose.js',
{
'items': paginated_items,
'is_searchable': is_searchable,
'search_form': search_form,
'query_string': search_query,
'is_searching': is_searching,
}
)
def chooser(request):
Media = get_media_model()
media_files = []
q = None
is_searching = False
if 'q' in request.GET or 'p' in request.GET or 'collection_id' in request.GET:
media_files = Media.objects.all()
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:
media_files = media_files.order_by('-created_at')
is_searching = False
# 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:
searchform = SearchForm()
collections = Collection.objects.all()
if len(collections) < 2:
collections = None
media_files = Media.objects.order_by('-created_at')
paginator, media_files = paginate(request, media_files, per_page=10)
return render_modal_workflow(
request, 'wagtailmedia/chooser/chooser.html',
'wagtailmedia/chooser/chooser.js', {
'media_files': media_files,
'searchform': searchform,
'collections': collections,
'is_searching': False,
})
def choose(request):
# TODO: Ideally this would return the endnotes for the current article.
items = EndNote.objects.all()
# Search
is_searchable = class_is_indexed(EndNote)
is_searching = False
search_query = None
if is_searchable and 'q' in request.GET:
search_form = SearchForm(request.GET,
placeholder=_("Search End Notes"))
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 End Notes"))
# Pagination
p = request.GET.get("p", 1)
paginator = Paginator(items, 25)
try:
paginated_items = paginator.page(p)
except PageNotAnInteger:
paginated_items = paginator.page(1)
except EmptyPage:
paginated_items = paginator.page(paginator.num_pages)
# If paginating or searching, render "results.html"
if request.GET.get('results', None) == 'true':
return render(
request, "content_notes/chooser/results.html", {
'items': paginated_items,
'query_string': search_query,
'is_searching': is_searching,
})
return render_modal_workflow(
request, 'content_notes/chooser/choose.html',
'content_notes/chooser/choose.js', {
'items': paginated_items,
'is_searchable': is_searchable,
'search_form': search_form,
'query_string': search_query,
'is_searching': is_searching,
})
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)
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)
searchform = SearchForm()
return render_modal_workflow(
request,
'wagtail_embed_videos/chooser/chooser.html',
'wagtail_embed_videos/chooser/chooser.js',
{
'embed_videos': embed_videos,
'searchform': searchform,
'is_searching': False,
'can_add': can_add,
'query_string': q,
'popular_tags': popular_tags_for_model(EmbedVideo),
}
)
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)
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)
searchform = SearchForm()
return render_modal_workflow(
request,
'wagtail_embed_videos/chooser/chooser.html',
None,
{
'embed_videos': embed_videos,
'searchform': searchform,
'is_searching': False,
'can_add': can_add,
'query_string': q,
'popular_tags': popular_tags_for_model(EmbedVideo),
}
)
def chooser(request):
Media = get_media_model()
media_files = []
q = None
is_searching = False
if 'q' in request.GET or 'p' in request.GET or 'collection_id' in request.GET:
media_files = Media.objects.all()
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:
media_files = media_files.order_by('-created_at')
is_searching = False
# 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:
searchform = SearchForm()
collections = Collection.objects.all()
if len(collections) < 2:
collections = None
media_files = Media.objects.order_by('-created_at')
paginator, media_files = paginate(request, media_files, per_page=10)
return render_modal_workflow(request, 'wagtailmedia/chooser/chooser.html', 'wagtailmedia/chooser/chooser.js', {
'media_files': media_files,
'searchform': searchform,
'collections': collections,
'is_searching': False,
})
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):
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 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 render(request, 'wagtailstyleguide/base.html', {
'search_form': form,
'example_form': example_form,
'example_page': page,
})
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 list(request):
items = EndNote.objects.all()
# Search
is_searchable = class_is_indexed(EndNote)
is_searching = False
search_query = None
if is_searchable and 'q' in request.GET:
search_form = SearchForm(request.GET,
placeholder=_("Search End Notes"))
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 End Notes"))
# Pagination
p = request.GET.get('p', 1)
paginator = Paginator(items, 20)
try:
paginated_items = paginator.page(p)
except PageNotAnInteger:
paginated_items = paginator.page(1)
except EmptyPage:
paginated_items = paginator.page(paginator.num_pages)
# Template
if request.is_ajax():
template = 'content_notes/endnotes/results.html'
else:
template = 'content_notes/endnotes/type_index.html'
return render(
request, template, {
'items': paginated_items,
'is_searchable': is_searchable,
'search_form': search_form,
'is_searching': is_searching,
'query_string': search_query,
})
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 list(request):
items = EndNote.objects.all()
# Search
is_searchable = class_is_indexed(EndNote)
is_searching = False
search_query = None
if is_searchable and 'q' in request.GET:
search_form = SearchForm(request.GET, placeholder=_("Search End Notes"))
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 End Notes"))
# Pagination
p = request.GET.get('p', 1)
paginator = Paginator(items, 20)
try:
paginated_items = paginator.page(p)
except PageNotAnInteger:
paginated_items = paginator.page(1)
except EmptyPage:
paginated_items = paginator.page(paginator.num_pages)
# Template
if request.is_ajax():
template = 'content_notes/endnotes/results.html'
else:
template = 'content_notes/endnotes/type_index.html'
return render(request, template, {
'items': paginated_items,
'is_searchable': is_searchable,
'search_form': search_form,
'is_searching': is_searching,
'query_string': search_query,
})
def chooser(request):
video_files = []
q = None
is_searching = False
if 'q' in request.GET or 'p' in request.GET:
video_files = Video.objects.all()
searchform = SearchForm(request.GET)
if searchform.is_valid():
q = searchform.cleaned_data['q']
video_files = video_files.search(q)
is_searching = True
else:
video_files = video_files.order_by('-title')
is_searching = False
# Pagination
paginator = Paginator(video_files, per_page=10)
page = paginator.get_page(request.GET.get('p'))
return render(request, "video/chooser/results.html", {
'video_files': video_files,
'query_string': q,
'is_searching': is_searching,
})
else:
searchform = SearchForm()
video_files = Video.objects.order_by('-title')
paginator = Paginator(video_files, per_page=10)
video_modeladmin = VideoAdmin()
return render_modal_workflow(request, 'video/chooser/chooser.html', None, {
'video_files': video_files,
'searchform': searchform,
'is_searching': False,
'video_index_url': video_modeladmin.url_helper.index_url,
}, json_data={
'step': 'chooser',
'error_label': "Server Error",
'error_message': "Report this error to your webmaster with the following information:",
})
def chooser_upload(request, media_type):
Media = get_media_model()
MediaForm = get_media_form(Media)
if request.method == 'POST':
media = Media(uploaded_by_user=request.user, type=media_type)
form = MediaForm(request.POST,
request.FILES,
instance=media,
user=request.user,
prefix='media-chooser-upload')
if form.is_valid():
form.save()
# Reindex the media entry to make sure all tags are indexed
for backend in get_search_backends():
backend.add(media)
return render_modal_workflow(request,
None,
None,
None,
json_data={
'step': 'media_chosen',
'result': get_media_json(media)
})
media_files = permission_policy.instances_user_has_any_permission_for(
request.user, ['change', 'delete'])
# allow hooks to modify the queryset
for hook in hooks.get_hooks('construct_media_chooser_queryset'):
media_files = hook(media_files, request)
searchform = SearchForm()
collections = Collection.objects.all()
if len(collections) < 2:
collections = None
media_files = media_files.order_by('-created_at')
paginator, media_files = paginate(request, media_files, per_page=10)
context = {
'media_files': media_files,
'searchform': searchform,
'collections': collections,
'uploadform': form,
'is_searching': False,
'pagination_template': pagination_template,
'media_type': media_type,
}
return render_modal_workflow(request,
'wagtailmedia/chooser/chooser.html',
None,
context,
json_data={'step': 'chooser'})
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 chooser(request, snippet_type=None):
try:
handler = find_choosers()[snippet_type]
except KeyError:
raise Http404
model = handler.model
if 'q' in request.GET or 'p' in request.GET:
searchform = SearchForm(request.GET)
if searchform.is_valid():
s = get_search_backend()
q = searchform.cleaned_data['q']
items = s.search(q, model.objects.all())
is_searching = True
else:
q = request.GET.get('q', '')
items = model.objects.all()
is_searching = False
# Pagination
_, items = paginate(request, items, per_page=10)
return render(
request, 'snippets/includes/_results.html', {
'items': items,
'snippet_type': handler,
'query_string': q,
'is_searching': is_searching,
})
searchform = SearchForm()
items = model.objects.all()
_, items = paginate(request, items, per_page=10)
return render_modal_workflow(
request, 'snippets/browse.html', 'snippets/chooser.js', {
'SNIPPET_TYPES': find_choosers(),
'items': items,
'searchform': searchform,
'snippet_type': handler,
})
def choose(request):
items = Poll.objects.all()
# Search
is_searching = False
search_query = None
if 'q' in request.GET:
search_form = AdminSearchForm(
request.GET,
placeholder=_("Search %(snippet_type_name)s") %
{'snippet_type_name': 'Polls'})
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, paginated_items = paginate(request, items, per_page=25)
# If paginating or searching, render "results.html"
if request.GET.get('results', None) == 'true':
return render(
request, "wagtailpolls/search_results.html", {
'items': paginated_items,
'query_string': search_query,
'is_searching': is_searching,
})
return render_modal_workflow(
request, 'wagtailpolls/choose.html', 'wagtailpolls/choose.js', {
'snippet_type_name': 'Poll',
'items': paginated_items,
'is_searchable': True,
'search_form': search_form,
'query_string': search_query,
'is_searching': is_searching,
})
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 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, pages = paginate(request, pages, per_page=25)
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 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, pages = paginate(request, pages, per_page=25)
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_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
search_form = SearchForm(request.GET)
if search_form.is_valid() and search_form.cleaned_data['q']:
pages = Page.objects.exclude(
depth=1 # never include root
).order_by(
'-first_published_at') # change 1) give pages a default order
pages = filter_page_type(pages, desired_classes)
pages = pages.search(
search_form.cleaned_data['q'],
fields=['title'],
order_by_relevance=False,
operator='and') # change 2) order by the new default order
else:
pages = Page.objects.none()
paginator, pages = paginate(request, pages, per_page=25)
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 get_chooser_context(request):
"""Helper function to return common template context variables for the main chooser view"""
collections = Collection.objects.all()
if len(collections) < 2:
collections = None
return {
'searchform': SearchForm(),
'is_searching': False,
'query_string': None,
'will_select_format': request.GET.get('select_format'),
'popular_tags': popular_tags_for_model(get_image_model()),
'collections': collections,
}
def chooser_upload(request):
Image = get_image_model()
ImageForm = get_image_form(Image)
searchform = SearchForm()
if request.method == 'POST':
image = Image(uploaded_by_user=request.user)
form = ImageForm(request.POST, request.FILES, instance=image, user=request.user)
if form.is_valid():
# Set image file size
image.file_size = image.file.size
# Set image file hash
image.file.seek(0)
image._set_file_hash(image.file.read())
form.save()
# Reindex the image to make sure all tags are indexed
search_index.insert_or_update_object(image)
if request.GET.get('select_format'):
form = ImageInsertionForm(initial={'alt_text': image.default_alt_text})
return render_modal_workflow(
request, 'wagtailimages/chooser/select_format.html', None,
{'image': image, 'form': form}, json_data={'step': 'select_format'}
)
else:
# not specifying a format; return the image details now
return render_modal_workflow(
request, None, None,
None, json_data={'step': 'image_chosen', 'result': get_image_result_data(image)}
)
else:
form = ImageForm(user=request.user)
images = Image.objects.order_by('-created_at')
paginator, images = paginate(request, images, per_page=12)
return render_modal_workflow(
request, 'wagtailimages/chooser/chooser.html', None,
{'images': images, 'uploadform': form, 'searchform': searchform},
json_data=get_chooser_context()
)
def index(request):
query_string = request.GET.get('q', "")
ordering = request.GET.get('ordering', 'old_path')
redirects = models.Redirect.objects.prefetch_related(
'redirect_page', 'site')
# Search
if query_string:
redirects = redirects.filter(
Q(old_path__icontains=query_string)
| Q(redirect_page__url_path__icontains=query_string)
| Q(redirect_link__icontains=query_string))
# Ordering (A bit useless at the moment as only 'old_path' is allowed)
if ordering not in ['old_path']:
ordering = 'old_path'
redirects = redirects.order_by(ordering)
# Pagination
paginator, redirects = paginate(request, redirects)
# Render template
if request.is_ajax():
return render(
request, "wagtailredirects/results.html", {
'ordering': ordering,
'redirects': redirects,
'query_string': query_string,
})
else:
return render(
request, "wagtailredirects/index.html", {
'ordering':
ordering,
'redirects':
redirects,
'query_string':
query_string,
'search_form':
SearchForm(data=dict(q=query_string) if query_string else None,
placeholder=_("Search redirects")),
'user_can_add':
permission_policy.user_has_permission(request.user, 'add'),
})
def search(request):
if not user_can_edit_news(request.user):
raise PermissionDenied
allowed_news_types = get_allowed_news_types(request.user)
query = request.GET.get('q', '')
# FIXME: this is crap, need to construct a single query for all types
# to search by relevance however that's not currently possible in
# a backend agnostic way :(
newsitem_models = [
NewsIndex.get_newsitem_model() for NewsIndex in allowed_news_types
]
newsitem_results = list(_search_newsitems(request, newsitem_models, query))
return render(
request, 'wagtailnews/search.html', {
'single_result_type': len(newsitem_results) == 1,
'single_newsitem_model': len(newsitem_models) == 1,
'newsitem_results': newsitem_results,
'search_form': SearchForm(request.GET if request.GET else None),
'query_string': query,
})
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, documents = paginate(request, documents)
collections = permission_policy.collections_user_has_any_permission_for(
request.user, ['add', 'change']
)
if len(collections) < 2:
collections = None
# 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 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
will_select_format = request.GET.get('select_format')
will_select_rendition = request.GET.get('select_rendition')
images = Image.objects.order_by('-created_at') \
.filter(show_in_catalogue=True)
# allow hooks to modify the queryset
for hook in hooks.get_hooks('construct_image_chooser_queryset'):
images = hook(images, request)
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:
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
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': will_select_format,
'will_select_rendition': will_select_rendition,
'post_processing_spec': request.GET.get('pps'),
'additional_params': get_cropper_params(request),
})
else:
searchform = SearchForm()
collections = Collection.objects.all()
if len(collections) < 2:
collections = None
paginator, images = paginate(request, images, per_page=12)
return render_modal_workflow(request, 'wagtailimages/chooser/chooser.html', 'wagtailimages/chooser/chooser.js', {
'images': images,
'uploadform': uploadform,
'searchform': searchform,
'is_searching': False,
'query_string': q,
'will_select_format': will_select_format,
'will_select_rendition': will_select_rendition,
'popular_tags': popular_tags_for_model(Image),
'collections': collections,
'uploadid': uuid.uuid4(),
'post_processing_spec': request.GET.get('pps'),
'additional_params': get_cropper_params(request),
'allowed_extensions': ALLOWED_EXTENSIONS,
'error_max_file_size':
uploadform.fields['file']
.error_messages['file_too_large_unknown_size']
if uploadform else None,
'error_accepted_file_types':
uploadform.fields['file'].error_messages['invalid_image']
if uploadform else None,
})
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,
})
