def site_search(request):
search_query = request.GET.get('query', None)
page = request.GET.get('page', request.GET.get('p', 1))
results_per_page = settings.SPCA_LIST_PAGE_LENGTH
if search_query:
search_results = Page.objects.live().search(search_query)
Query.get(search_query).add_hit()
else:
search_query = ''
search_results = Page.objects.none()
paginator = Paginator(search_results, results_per_page)
try:
search_results = paginator.page(page)
except PageNotAnInteger:
search_results = paginator.page(1)
except EmptyPage:
search_results = paginator.page(paginator.num_pages)
return render(
request, 'core/search_results.html', {
'search_query':
search_query,
'search_results':
search_results,
'title':
'{} Search Results for: {}'.format(settings.SPCA_SITE_SHORT_NAME,
search_query),
})
def test_post_reorder(self):
# Check order before reordering
self.assertEqual(Query.get("Hello").editors_picks.all()[0], self.search_pick)
self.assertEqual(Query.get("Hello").editors_picks.all()[1], self.search_pick_2)
# Submit
post_data = {
'query_string': "Hello",
'editors_picks-TOTAL_FORMS': 2,
'editors_picks-INITIAL_FORMS': 2,
'editors_picks-MAX_NUM_FORMS': 1000,
'editors_picks-0-id': self.search_pick.id,
'editors_picks-0-DELETE': '',
'editors_picks-0-ORDER': 1, # Change
'editors_picks-0-page': 1,
'editors_picks-0-description': "Root page",
'editors_picks-1-id': self.search_pick_2.id,
'editors_picks-1-DELETE': '',
'editors_picks-1-ORDER': 0, # Change
'editors_picks-1-page': 2,
'editors_picks-1-description': "Homepage",
}
response = self.client.post(reverse('wagtailsearchpromotions:edit', args=(self.query.id, )), post_data)
# User should be redirected back to the index
self.assertRedirects(response, reverse('wagtailsearchpromotions:index'))
# Check that the ordering has been saved correctly
self.assertEqual(SearchPromotion.objects.get(id=self.search_pick.id).sort_order, 1)
self.assertEqual(SearchPromotion.objects.get(id=self.search_pick_2.id).sort_order, 0)
# Check that the recommendations were reordered
self.assertEqual(Query.get("Hello").editors_picks.all()[0], self.search_pick_2)
self.assertEqual(Query.get("Hello").editors_picks.all()[1], self.search_pick)
def site_search(request):
search_query = request.GET.get("query", None)
page = request.GET.get("page", request.GET.get("p", 1))
# page = request.GET.get('page', 1)
results_per_page = 5
if search_query:
search_results = Page.objects.live().search(search_query)
Query.get(search_query).add_hit()
else:
search_query = ""
search_results = Page.objects.none()
paginator = Paginator(search_results, results_per_page)
try:
search_results = paginator.page(page)
except PageNotAnInteger:
search_results = paginator.page(1)
except EmptyPage:
search_results = paginator.page(paginator.num_pages)
return render(
request,
"base/search_results.html",
{
"search_query":
search_query,
"search_results":
search_results,
"title":
"{} Search Results for: {}".format(settings.WAGTAIL_SITE_NAME,
search_query),
},
)
def search(request):
site = Site.find_for_request(request)
search_query = ''
if request.method == 'POST':
form = SearchBirdForm(request.POST)
if form.is_valid():
search_query = form.cleaned_data['search_query']
search_results = Page.objects.in_site(
site).live().public().filter().exclude(
show_in_menus=True).order_by('-first_published_at').search(
search_query, order_by_relevance=False)
Query.get(search_query).add_hit()
form = SearchBirdForm()
else:
search_results = Page.objects.none()
else:
form = SearchBirdForm()
search_results = Page.objects.none()
search_query = request.GET.get('search_query', None)
if search_query:
search_results = Page.objects.in_site(
site).live().public().exclude(
show_in_menus=True).order_by('-first_published_at').search(
search_query, order_by_relevance=False)
Query.get(search_query).add_hit()
else:
search_results = Page.objects.none()
return render(
request, 'birdapp657/search_results.html', {
'form': form,
'search_query': search_query,
'search_results': search_results,
})
def search(request):
search_query = request.GET.get("q", None)
page = request.GET.get("page")
if search_query:
search_results = Page.objects.live().specific().search(search_query)
# Log the query so Wagtail can suggest promoted results
Query.get(search_query).add_hit()
else:
search_results = Page.objects.none()
# pagination
paginator = Paginator(search_results, 10)
try:
results = paginator.page(page)
except PageNotAnInteger:
results = paginator.page(1)
except EmptyPage:
results = paginator.page(paginator.num_pages)
return render(
request,
"search/search_results.html",
{"search_query": search_query, "search_results": results},
)
def search(self, request):
subpage = {'title': 'Search', 'url': ''}
context = {'page': self, 'subpage': subpage, 'headline': ''}
# Search
search_query = request.GET.get('query', None)
if search_query:
page_results = Page.objects.live().not_type(
(BlogIndexPage)).search(search_query).annotate_score("score")
# Log the query so Wagtail can suggest promoted results
Query.get(search_query).add_hit()
# Also query non-wagtail models
s = get_search_backend()
model_results = s.search(
search_query,
BaseImpactModel.objects.filter(impact_model__public=True))
else:
page_results = []
model_results = []
context.update({
'search_query': search_query,
'page_results': page_results,
'model_results': model_results,
})
# raise Exception(dir(model_results[0]))
# raise Exception(search_results)
# Render template
return render(request, 'pages/search_page.html', context)
def get_search_queryset(query,
queryset,
operator="or",
fields=None,
tags=None,
criteria=None):
if not query:
query = ''
if not tags:
tags = ''
order_by_relevance = not queryset.ordered
if query:
if tags:
criteria.update(tags__name__in=[t.lower() for t in tags])
operator = 'and'
if criteria:
queryset = queryset.filter(**criteria)
query = f'{query} {tags}'.strip().lower()
if query:
Query.get(query).add_hit()
else:
query = MATCH_ALL
results = search_backend.search(query,
queryset,
operator=operator,
fields=fields,
order_by_relevance=order_by_relevance)
results.model = queryset.model
return results
def serve(self, request):
search_query = ''
if request.method == 'POST':
form = SearchBirdForm(request.POST)
if form.is_valid():
search_query = form.cleaned_data['search_query']
search_results = self.get_parent().get_descendants().live(
).public().exclude(
show_in_menus=True).order_by('-first_published_at').search(
search_query, order_by_relevance=False)
Query.get(search_query).add_hit()
form = SearchBirdForm()
else:
search_results = Page.objects.none()
else:
form = SearchBirdForm()
search_results = Page.objects.none()
return render(
request, 'birdapp657/search_bird_page.html', {
'page': self,
'form': form,
'search_query': search_query,
'search_results': search_results,
})
def entries_search(self, request, *args, **kwargs):
search_query = request.GET.get('q', None)
self.entries = self.get_entries()
if search_query:
self.entries = self.entries.search(search_query)
self.search_term = search_query
self.search_type = _('search')
Query.get(search_query).add_hit()
return Page.serve(self, request, *args, **kwargs)
def post_search(self, request, *args, **kwargs):
search_query = request.GET.get('q', None)
if search_query:
self.posts = self.get_all_live_posts().search(search_query)
self.search_header = _('Search results for:')
self.search_term = search_query
# Log the query so Wagtail can suggest promoted results
Query.get(search_query).add_hit()
return self.serve(request, *args, **kwargs)
def entries_search(self, request, *args, **kwargs):
""" Generates a page containing all the entries associated with a specific search. """
self.search_query = request.GET.get('q', None)
response = None
if self.search_query:
self.filter_type = 'search'
self.filter_value = self.search_query
self.entries = self.get_entries().search(self.search_query,
operator='or')
Query.get(self.search_query).add_hit()
response = Page.serve(self, request, *args, **kwargs)
return response or redirect(self.url)
def test_search_pick_create(self):
# Create a search pick to the root page
SearchPromotion.objects.create(
query=Query.get("root page"),
page_id=1,
sort_order=0,
description="First search promotion",
)
# Check
self.assertEqual(Query.get("root page").editors_picks.count(), 1)
self.assertEqual(Query.get("root page").editors_picks.first().page_id, 1)
def test_search_pick_create(self):
# Create a search pick to the root page
SearchPromotion.objects.create(
query=Query.get("root page"),
page_id=1,
sort_order=0,
description="First search promotion",
)
# Check
self.assertEqual(Query.get("root page").editors_picks.count(), 1)
self.assertEqual(
Query.get("root page").editors_picks.first().page_id, 1)
def search(request, results_per_page=10, load_more=False):
search_query = request.GET.get('q', None)
search_query = search_query.strip() if search_query else search_query
page = request.GET.get('p', 1)
locale = get_locale_code(get_language_from_request(request))
if search_query:
main = request.site.root_page
results = ArticlePage.objects.descendant_of(main).filter(
language__locale=locale
).exact_type(ArticlePage).values_list('pk', flat=True)
# Elasticsearch backend doesn't support filtering
# on related fields, at the moment.
# So we need to filter ArticlePage entries using DB,
# then, we will be able to search
results = ArticlePage.objects.filter(pk__in=results)
results = results.live().search(search_query)
# At the moment only ES backends have highlight API.
if hasattr(results, 'highlight'):
results = results.highlight(
fields={
'title': {},
'subtitle': {},
'body': {},
},
require_field_match=False
)
Query.get(search_query).add_hit()
else:
results = ArticlePage.objects.none()
if load_more:
return results
paginator = Paginator(results, results_per_page)
try:
search_results = paginator.page(page)
except PageNotAnInteger:
search_results = paginator.page(1)
except EmptyPage:
search_results = paginator.page(paginator.num_pages)
return render(request, 'search/search_results.html', {
'search_query': search_query,
'search_results': search_results,
'results': results,
})
def search(request):
search_query = request.GET.get('query', None)
if search_query:
search_results = BlogPage.objects.live().search(search_query)
# Log the query so Wagtail can suggest promoted results
Query.get(search_query).add_hit()
else:
search_results = BlogPage.objects.none()
# Render template
return render(request, 'blog/search_results.html', {
'search_query': search_query,
'search_results': search_results,
})
def search(request, results_per_page=10, load_more=False):
search_query = request.GET.get('q', None)
search_query = search_query.strip() if search_query else search_query
page = request.GET.get('p', 1)
locale = get_locale_code(get_language_from_request(request))
if search_query:
main = request.site.root_page
results = ArticlePage.objects.descendant_of(main).filter(
language__locale=locale).exact_type(ArticlePage).values_list(
'pk', flat=True)
# Elasticsearch backend doesn't support filtering
# on related fields, at the moment.
# So we need to filter ArticlePage entries using DB,
# then, we will be able to search
results = ArticlePage.objects.filter(pk__in=results)
results = results.live().search(search_query)
# At the moment only ES backends have highlight API.
if hasattr(results, 'highlight'):
results = results.highlight(fields={
'title': {},
'subtitle': {},
'body': {},
},
require_field_match=False)
Query.get(search_query).add_hit()
else:
results = ArticlePage.objects.none()
if load_more:
return results
paginator = Paginator(results, results_per_page)
try:
search_results = paginator.page(page)
except PageNotAnInteger:
search_results = paginator.page(1)
except EmptyPage:
search_results = paginator.page(paginator.num_pages)
return render(
request, 'search/search_results.html', {
'search_query': search_query,
'search_results': search_results,
'results': results,
})
def search(request):
search_query = request.GET.get('query', None)
page = request.GET.get('page', 1)
# Search
if search_query:
search_results = BlogPostPage.objects.live().public().search(
search_query)
query = Query.get(search_query)
# Record hit
query.add_hit()
else:
search_results = BlogPostPage.objects.none()
# Pagination
paginator = Paginator(search_results, 10)
try:
search_results = paginator.page(page)
except PageNotAnInteger:
search_results = paginator.page(1)
except EmptyPage:
search_results = paginator.page(paginator.num_pages)
blog_list_page = BlogListPage.objects.first()
context = blog_list_page.get_context(request)
return render(request, 'search/search.html', {
'search_query': search_query,
'search_results': search_results,
**context
})
def search(request):
search_query = request.GET.get('query', None)
page = request.GET.get('page', 1)
# Search
if search_query:
home = Page.objects.get(slug=request.LANGUAGE_CODE, )
search_results = Page.objects.descendant_of(
home, inclusive=True).live().search(search_query)
# search_results = Page.objects.live().search(search_query)
query = Query.get(search_query)
# Record hit
query.add_hit()
else:
search_results = Page.objects.none()
# Pagination
paginator = Paginator(search_results, 10)
try:
search_results = paginator.page(page)
except PageNotAnInteger:
search_results = paginator.page(1)
except EmptyPage:
search_results = paginator.page(paginator.num_pages)
return render(request, 'search/search.html', {
'search_query': search_query,
'search_results': search_results,
})
def search(request):
search_query = request.GET.get('query', None)
page = request.GET.get('page', 1)
backend = get_search_backend()
# Search
if search_query:
search_results = Page.objects.live().search(search_query).results()
query = Query.get(search_query)
# Adding non - page models to the search results
# search_results += backend.search(search_query, AboutPageQuestion.objects.all()).results()
# search_results += backend.search(search_query, AboutPageTopic.objects.all()).results()
# Record hit
query.add_hit()
else:
search_results = Page.objects.none()
# Pagination
paginator = Paginator(search_results, 20)
try:
search_results = paginator.page(page)
except PageNotAnInteger:
search_results = paginator.page(1)
except EmptyPage:
search_results = paginator.page(paginator.num_pages)
return render(request, 'search/search.html', {
'search_query': search_query,
'search_results': search_results,
})
def search(request):
search_query = request.GET.get('query', None)
page = request.GET.get('page', 1)
# Search
if search_query:
search_results = Page.objects.live().search(search_query)
query = Query.get(search_query)
# Record hit
query.add_hit()
else:
search_results = Page.objects.none()
# Pagination
paginator = Paginator(search_results, 10)
try:
search_results = paginator.page(page)
except PageNotAnInteger:
search_results = paginator.page(1)
except EmptyPage:
search_results = paginator.page(paginator.num_pages)
return render(request, 'search/search.html', {
'search_query': search_query,
'search_results': search_results,
})
def search(request):
search_query = request.GET.get('query', None)
page = request.GET.get('page', 1)
# Search
if search_query:
public_site = request.site.root_page
search_results = Page.objects.live().descendant_of(
public_site,
inclusive=True,
).specific().search(search_query, operator='and')
query = Query.get(search_query)
# Record hit
query.add_hit()
else:
search_results = Page.objects.none()
# Pagination
paginator = Paginator(search_results, settings.DEFAULT_PER_PAGE)
try:
search_results = paginator.page(page)
except PageNotAnInteger:
search_results = paginator.page(1)
except EmptyPage:
search_results = paginator.page(paginator.num_pages)
return render(request, 'search/search.html', {
'search_query': search_query,
'search_results': search_results,
})
def search(request):
search_query = request.GET.get("query", None)
page = request.GET.get("page", 1)
# Search
if search_query:
search_results = Page.objects.live().search(search_query)
query = Query.get(search_query)
# Record hit
query.add_hit()
else:
search_results = Page.objects.none()
# Pagination
paginator = Paginator(search_results, 10)
try:
search_results = paginator.page(page)
except PageNotAnInteger:
search_results = paginator.page(1)
except EmptyPage:
search_results = paginator.page(paginator.num_pages)
return TemplateResponse(
request, "search/search.html", {"search_query": search_query, "search_results": search_results,}
)
def search(request):
search_query = request.GET.get('query', None)
page = request.GET.get('page', 1)
# Search
if search_query:
search_results = Page.objects.live().search(search_query)
query = Query.get(search_query)
# Record hit
query.add_hit()
else:
search_results = Page.objects.none()
# Pagination
paginator = Paginator(search_results, 10)
try:
search_results = paginator.page(page)
except PageNotAnInteger:
search_results = paginator.page(1)
except EmptyPage:
search_results = paginator.page(paginator.num_pages)
wallpaper = Image.objects.filter(
tags__name="搜索壁纸").order_by('-created_at')[0]
return render(
request, 'search/search.html', {
'search_query': search_query,
'search_results': search_results,
'wallpaper': wallpaper,
})
def search(request):
search_query = request.GET.get('query', None)
page = request.GET.get('page', 1)
# Search
if search_query:
index.AutocompleteField('title')
search_results = ArticlePage.objects.search(search_query,
fields=['title'])
query = Query.get(search_query)
# Record hit
query.add_hit()
else:
search_results = Page.objects.none()
# Pagination
paginator = Paginator(search_results, 10)
try:
search_results = paginator.page(page)
except PageNotAnInteger:
search_results = paginator.page(1)
except EmptyPage:
search_results = paginator.page(paginator.num_pages)
return render(request, 'search/search.html', {
'search_query': search_query,
'search_results': search_results,
})
def search(request):
if request.method == 'GET':
search_query = request.GET.get('query', None)
page = request.GET.get('page', 1)
# Search
if search_query:
search_results = BlogPage.objects.live().order_by('-date').search(
search_query, fields=['title', 'subtitle'])
query = Query.get(search_query)
posts_count = search_results.count
# Record hit
query.add_hit()
else:
search_results = BlogPage.objects.none()
posts_count = 0
# Pagination
paginator = Paginator(search_results, 5)
try:
search_results = paginator.page(page)
except PageNotAnInteger:
search_results = paginator.page(1)
except EmptyPage:
search_results = paginator.page(paginator.num_pages)
context = {
'search_query': search_query,
'posts_count': posts_count,
'posts': search_results,
}
return render(request, 'pages/search.html', context)
def search(request):
search_query = request.GET.get('query', None)
page = request.GET.get('page', 1)
print(search_query)
# Search
if search_query:
search_results = Page.objects.live().search(search_query)
query = Query.get(search_query)
# Record hit
query.add_hit()
print(query)
else:
search_results = Page.objects.none()
# Pagination
paginator = Paginator(search_results, 10)
try:
search_results = paginator.page(page)
except PageNotAnInteger:
search_results = paginator.page(1)
except EmptyPage:
search_results = paginator.page(paginator.num_pages)
return render(request, 'search/search.html', {
'search_query': search_query,
'search_results': search_results,
})
def setUp(self):
self.login()
# Create an search pick to delete
self.query = Query.get("Hello")
self.search_pick = self.query.editors_picks.create(page_id=1, description="Root page")
self.search_pick_2 = self.query.editors_picks.create(page_id=2, description="Homepage")
def get_context(self, request, *args, **kwargs):
"""Overwrite the default wagtail get_context function to allow for filtering based on params.
Use the functions built into the abstract index page class to dynamically filter the child pages.
"""
filter_dict = {}
search_query = request.GET.get('search', None)
if search_query:
query = Query.get(search_query)
query.add_hit()
guidance_type_organisation = request.GET.get('organisation', None)
guidance_type_activity = request.GET.get('activity', None)
guidance_type_list = list()
if guidance_type_organisation:
guidance_type_list.append("organisation")
if guidance_type_activity:
guidance_type_list.append("activity")
if len(guidance_type_list):
filter_dict["guidance_types__guidance_type__in"] = guidance_type_list
context = super(StandardGuidanceIndexPage, self).get_context(request)
context['guidance'] = self.get_guidance(request, filter_dict, search_query)
return context
def search(request):
search_query = request.GET.get('query', None)
# Search
if search_query:
search_results = ArticlePage.objects.live().search(search_query)
query = Query.get(search_query)
# Record hit
query.add_hit()
else:
search_results = ArticlePage.objects.none()
# Pagination
page = request.GET.get('page')
page_size = 10
from home.models import GeneralSettings
if GeneralSettings.for_site(request.site).pagination_count:
page_size = GeneralSettings.for_site(request.site).pagination_count
if page_size is not None:
paginator = Paginator(search_results, page_size)
try:
search_results = paginator.page(page)
except PageNotAnInteger:
search_results = paginator.page(1)
except EmptyPage:
search_results = paginator.page(paginator.num_pages)
return render(request, 'search/search.html', {
'search_query': search_query,
'search_results': search_results,
})
def search(request):
search_query = request.GET.get("query", None)
logger.debug(f'search for "{search_query}"')
page = request.GET.get("page", 1)
# Search
if search_query:
search_results = Page.objects.type(ArticlePage).live().search(search_query)
query = Query.get(search_query)
# Record hit
query.add_hit()
else:
search_results = Page.objects.none()
# Pagination
paginator = Paginator(search_results, 10)
try:
search_results = paginator.page(page)
except PageNotAnInteger:
search_results = paginator.page(1)
except EmptyPage:
search_results = paginator.page(paginator.num_pages)
return render(
request,
"search/search.html",
{"search_query": search_query, "search_results": search_results,},
)
def edit(request, query_id):
query = get_object_or_404(Query, id=query_id)
if request.method == 'POST':
# Get query
query_form = search_forms.QueryForm(request.POST)
# and the recommendations
searchpicks_formset = forms.SearchPromotionsFormSet(request.POST, instance=query)
if query_form.is_valid():
new_query = Query.get(query_form['query_string'].value())
# Save search picks
if save_searchpicks(query, new_query, searchpicks_formset):
messages.success(request, _("Editor's picks for '{0}' updated.").format(new_query), buttons=[
messages.button(reverse('wagtailsearchpromotions:edit', args=(query.id,)), _('Edit'))
])
return redirect('wagtailsearchpromotions:index')
else:
if len(searchpicks_formset.non_form_errors()):
messages.error(request, " ".join(error for error in searchpicks_formset.non_form_errors()))
# formset level error (e.g. no forms submitted)
else:
messages.error(request, _("Recommendations have not been saved due to errors"))
# specific errors will be displayed within form fields
else:
query_form = search_forms.QueryForm(initial=dict(query_string=query.query_string))
searchpicks_formset = forms.SearchPromotionsFormSet(instance=query)
return render(request, 'wagtailsearchpromotions/edit.html', {
'query_form': query_form,
'searchpicks_formset': searchpicks_formset,
'query': query,
})
def search(request):
search_query = request.GET.get('query', None)
page = request.GET.get('page', 1)
catage = BlogCategory.objects.all()
# Search
if search_query:
search_results = Page.objects.all().search(search_query)
catage = catage.filter(name__contains=search_query)
query = Query.get(search_query)
# Record hit
query.add_hit()
else:
search_results = Page.objects.none()
# Pagination
paginator = Paginator(search_results, 10)
try:
search_results = paginator.page(page)
except PageNotAnInteger:
search_results = paginator.page(1)
except EmptyPage:
search_results = paginator.page(paginator.num_pages)
return render(
request, 'search/search.html', {
'search_query': search_query,
'category_results': catage,
'search_results': search_results,
})
def add(request):
if request.method == 'POST':
# Get query
query_form = search_forms.QueryForm(request.POST)
if query_form.is_valid():
query = Query.get(query_form['query_string'].value())
# Save search picks
searchpicks_formset = forms.SearchPromotionsFormSet(request.POST, instance=query)
if save_searchpicks(query, query, searchpicks_formset):
messages.success(request, _("Editor's picks for '{0}' created.").format(query), buttons=[
messages.button(reverse('wagtailsearchpromotions:edit', args=(query.id,)), _('Edit'))
])
return redirect('wagtailsearchpromotions:index')
else:
if len(searchpicks_formset.non_form_errors()):
# formset level error (e.g. no forms submitted)
messages.error(request, " ".join(error for error in searchpicks_formset.non_form_errors()))
else:
# specific errors will be displayed within form fields
messages.error(request, _("Recommendations have not been created due to errors"))
else:
searchpicks_formset = forms.SearchPromotionsFormSet()
else:
query_form = search_forms.QueryForm()
searchpicks_formset = forms.SearchPromotionsFormSet()
return render(request, 'wagtailsearchpromotions/add.html', {
'query_form': query_form,
'searchpicks_formset': searchpicks_formset,
'form_media': query_form.media + searchpicks_formset.media,
})
def search(request):
search_query = request.GET.get('query', None)
page = request.GET.get('page', 1)
# Search
if search_query:
search_results = Page.objects.live().search(search_query, operator='and')
query = Query.get(search_query)
# Record hit
query.add_hit()
else:
search_results = Page.objects.none()
# Pagination
paginator = Paginator(search_results, settings.DEFAULT_PER_PAGE)
try:
search_results = paginator.page(page)
except PageNotAnInteger:
search_results = paginator.page(1)
except EmptyPage:
search_results = paginator.page(paginator.num_pages)
response = TemplateResponse(request, 'patterns/pages/search/search.html', {
'search_query': search_query,
'search_results': search_results,
})
# Instruct FE cache to not cache when the search query is present.
# It's so hits get added to the database and results include newly
# added pages.
if search_query:
add_never_cache_headers(response)
else:
patch_cache_control(response, **get_default_cache_control_kwargs())
return response
def search(request):
search_query = request.GET.get('query', None)
page = request.GET.get('page', 1)
# Search
if search_query:
search_results = Page.objects.live().public().search(search_query)
query = Query.get(search_query)
# Record hit
query.add_hit()
else:
search_results = Page.objects.none()
# Pagination
paginator = Paginator(search_results, 10)
try:
search_results = paginator.page(page)
except PageNotAnInteger:
search_results = paginator.page(1)
except EmptyPage:
search_results = paginator.page(paginator.num_pages)
return render(
request, 'search/search.html', {
'is_search_page': True,
'page_message': 'seek and ye shall find. (or perhaps not.)',
'search_query': search_query,
'search_results': search_results,
})
def make_search_picks(self):
for i in range(50):
SearchPromotion.objects.create(
query=Query.get("query " + str(i)),
page_id=1,
sort_order=0,
description="First search pick",
)
def test_get_search_promotions_template_tag(self):
# Create a search pick to the root page
pick = SearchPromotion.objects.create(
query=Query.get("root page"),
page_id=1,
sort_order=0,
description="First search pick",
)
# Create another search pick against a different query
SearchPromotion.objects.create(
query=Query.get("root page again"),
page_id=1,
sort_order=0,
description="Second search pick",
)
# Check
search_picks = list(get_search_promotions("root page"))
self.assertEqual(search_picks, [pick])
def test_search_pick_ordering(self):
# Add 3 search picks in a different order to their sort_order values
# They should be ordered by their sort order values and not their insertion order
SearchPromotion.objects.create(
query=Query.get("root page"),
page_id=1,
sort_order=0,
description="First search pick",
)
SearchPromotion.objects.create(
query=Query.get("root page"),
page_id=1,
sort_order=2,
description="Last search pick",
)
SearchPromotion.objects.create(
query=Query.get("root page"),
page_id=1,
sort_order=1,
description="Middle search pick",
)
# Check
self.assertEqual(Query.get("root page").editors_picks.count(), 3)
self.assertEqual(Query.get("root page").editors_picks.first().description, "First search pick")
self.assertEqual(Query.get("root page").editors_picks.last().description, "Last search pick")
def test_results_are_ordered_alphabetically(self):
self.make_search_picks()
SearchPromotion.objects.create(
query=Query.get("aaargh snake"),
page_id=1,
sort_order=0,
description="ooh, it's a snake",
)
response = self.client.get(reverse('wagtailsearchpromotions:index'))
# Check response
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'wagtailsearchpromotions/index.html')
# "aargh snake" should be the first result alphabetically
self.assertEqual(response.context['queries'][0].query_string, "aaargh snake")
def test_post(self):
# Submit
post_data = {
'query_string': "test",
'editors_picks-TOTAL_FORMS': 1,
'editors_picks-INITIAL_FORMS': 0,
'editors_picks-MAX_NUM_FORMS': 1000,
'editors_picks-0-DELETE': '',
'editors_picks-0-ORDER': 0,
'editors_picks-0-page': 1,
'editors_picks-0-description': "Hello",
}
response = self.client.post(reverse('wagtailsearchpromotions:add'), post_data)
# User should be redirected back to the index
self.assertRedirects(response, reverse('wagtailsearchpromotions:index'))
# Check that the search pick was created
self.assertTrue(Query.get('test').editors_picks.filter(page_id=1).exists())
def edit(request, query_id):
query = get_object_or_404(Query, id=query_id)
if request.method == 'POST':
# Get query
query_form = search_forms.QueryForm(request.POST)
# and the recommendations
searchpicks_formset = forms.SearchPromotionsFormSet(request.POST, instance=query)
if query_form.is_valid():
new_query = Query.get(query_form['query_string'].value())
# Save search picks
if save_searchpicks(query, new_query, searchpicks_formset):
messages.success(request, _("Editor's picks for '{0}' updated.").format(new_query), buttons=[
messages.button(reverse('wagtailsearchpromotions:edit', args=(query.id,)), _('Edit'))
])
return redirect('wagtailsearchpromotions:index')
else:
if len(searchpicks_formset.non_form_errors()):
messages.error(request, " ".join(error for error in searchpicks_formset.non_form_errors()))
# formset level error (e.g. no forms submitted)
else:
messages.error(request, _("Recommendations have not been saved due to errors"))
# specific errors will be displayed within form fields
else:
query_form = search_forms.QueryForm(initial=dict(query_string=query.query_string))
searchpicks_formset = forms.SearchPromotionsFormSet(instance=query)
return render(request, 'wagtailsearchpromotions/edit.html', {
'query_form': query_form,
'searchpicks_formset': searchpicks_formset,
'query': query,
'form_media': query_form.media + searchpicks_formset.media,
})
def get_search_promotions(search_query):
if search_query:
return Query.get(search_query).editors_picks.all()
else:
return SearchPromotion.objects.none()
def search(
request,
template=None,
template_ajax=None,
results_per_page=10,
use_json=False,
json_attrs=['title', 'url'],
show_unpublished=False,
search_title_only=False,
extra_filters={},
path=None):
warnings.warn(
"Wagtail's builtin search view "
"(wagtail.wagtailsearch.views.frontend.search) is deprecated and will "
"be removed in a future release",
category=RemovedInWagtail22Warning
)
# Get default templates
if template is None:
if hasattr(settings, 'WAGTAILSEARCH_RESULTS_TEMPLATE'):
template = settings.WAGTAILSEARCH_RESULTS_TEMPLATE
else:
template = 'wagtailsearch/search_results.html'
if template_ajax is None:
if hasattr(settings, 'WAGTAILSEARCH_RESULTS_TEMPLATE_AJAX'):
template_ajax = settings.WAGTAILSEARCH_RESULTS_TEMPLATE_AJAX
else:
template_ajax = template
# Get query string and page from GET paramters
query_string = request.GET.get('q', '')
page = request.GET.get('page', request.GET.get('p', 1))
# Search
if query_string != '':
pages = models.Page.objects.filter(path__startswith=(path or request.site.root_page.path))
if not show_unpublished:
pages = pages.live()
if extra_filters:
pages = pages.filter(**extra_filters)
if search_title_only:
search_results = pages.search(query_string, fields=['title'])
else:
search_results = pages.search(query_string)
# Get query object
query = Query.get(query_string)
# Add hit
query.add_hit()
# Pagination
paginator = Paginator(search_results, results_per_page)
try:
search_results = paginator.page(page)
except PageNotAnInteger:
search_results = paginator.page(1)
except EmptyPage:
search_results = paginator.page(paginator.num_pages)
else:
query = None
search_results = None
if use_json:
# Return a json response
if search_results:
search_results_json = []
for result in search_results:
result_specific = result.specific
search_results_json.append(dict(
(attr, getattr(result_specific, attr))
for attr in json_attrs
if hasattr(result_specific, attr)
))
return JsonResponse(search_results_json, safe=False)
else:
return JsonResponse([], safe=False)
else:
# Render a template
if request.is_ajax() and template_ajax:
template = template_ajax
return render(request, template, dict(
query_string=query_string,
search_results=search_results,
is_ajax=request.is_ajax(),
query=query
))
