def post_search(request):
form = SearchForm()
search_dict =None
if 'q' in request.GET:
form = SearchForm(request.GET)
cd = request.GET['q']
posts = form.search()
total_results = posts.count()
search_dict = {'posts': posts, 'keyword': cd, 'total_results': total_results, 'form': form,}
return render(request, 'blog/post/search.html', search_dict)
class GenericBaseViewMixin(object):
search_form = SearchForm()
def get_search_form(self, **kwargs):
"""Add the search form to view
"""
return self.search_form
def full_search(request):
sform = SearchForm(request.GET)
posts = sform.search()
template = 'defaule/app/search-text.html'
c = Context({'posts': posts})
return render_to_response(template, c)
def bids(request):
context = {}
#### TOP ####
bids = Bid.objects.filter(_status__exact='C')
top_answers = []
for bid in bids:
try:
top_answers.append(Answer.objects.filter(bid=bid.id).order_by('price')[0])
except:
pass
context['top_answers'] = top_answers
#### ALL_BIDS ####
bids = Bid.objects.all()
context["bids"] = bids
#### SEARCH ####!
from haystack.forms import SearchForm
form = SearchForm(request.GET)
query = form.search()
try:
if request.GET["q"]:
context["is_search"] = True
except:
pass
context["form"] = form
context["query"] = query
bid_form = bid_create(request, True)
#if request.method == "POST"
context["bid_form"] = bid_form
return render(request, "core/bids.html", context)
def full_search(request):
"""全局搜索"""
keywords = request.GET['q']
sform = SearchForm(request.GET)
posts = sform.search()
return render(request, 'blog/post_search_list.html',
{'posts': posts, 'list_header': '关键字 \'{}\' 搜索结果'.format(keywords)})
def search(request):
"""Simple search tool"""
context = get_context(request)
context['simple_query'] = get_simple_query(request)
if 'q' not in request.GET:
return redirect('/')
query = request.GET['q'].strip()
if query == '':
return redirect('/')
form = SearchForm(request.GET)
page = request.GET.get('page')
if settings.ELASTICSEARCH is True:
sqs = form.search()
sqs.spelling_suggestion()
results = ""
paginator = ""
if sqs:
paginator = Paginator(sqs, 25)
try:
results = paginator.page(page)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
results = paginator.page(1)
except EmptyPage:
# If page is out of range (e.g. 9999), deliver last page of results.
results = paginator.page(paginator.num_pages)
context['page'] = results
context['paginator'] = paginator
context['results'] = results
context['voucher_code_list'] = get_voucher_code_list(sqs)
context['url_encoded_query'] = get_correct_url_query(
request.GET.urlencode())
context['result_count'] = len(sqs)
return render(request, 'public_interface/search_results.html', context)
else:
sqs = Vouchers.objects.filter(
Q(orden__icontains=query) | Q(genus__icontains=query)
| Q(species__icontains=query) | Q(code__icontains=query), )
results = ""
paginator = ""
if sqs:
paginator = Paginator(sqs, 25)
try:
results = paginator.page(page)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
results = paginator.page(1)
except EmptyPage:
# If page is out of range (e.g. 9999), deliver last page of results.
results = paginator.page(paginator.num_pages)
context["result_count"] = sqs.count()
context['page'] = results
context['paginator'] = paginator
context['results'] = results
return render(request, 'public_interface/search_results.html', context)
def search(request):
form = SearchForm(request.GET or None)
posts = None
if form.data != {} and form.is_valid():
posts = form.search()
return render_to_response('search/search.html', {
'posts': posts
}, context_instance=RequestContext(request))
def index(request):
if (request.GET.get("q", None) != None):
return SearchView(template="books/index.html")(request)
rand_books = Book.objects.all().order_by("?")[:10]
return render(request, 'books/index.html', {
'books': rand_books,
'form': SearchForm()
})
def my_search(request):
form = SearchForm()
activities = Stub.objects.filter(group="activities")
about = Stub.objects.filter(group="about")
return {
'mysearchform': form,
"activitystubs": activities,
"aboutstubs": about
}
def test_unbound(self):
sf = SearchForm({}, searchqueryset=self.sqs)
self.assertEqual(sf.errors, {})
self.assertEqual(sf.is_valid(), True)
# This shouldn't blow up.
sqs = sf.search()
self.assertTrue(isinstance(sqs, EmptySearchQuerySet))
def forms(request):
context = {"search_form": SearchForm()}
if not request.user.is_authenticated():
context["login_form"] = AuthenticationForm()
# TODO: optimize
context["party"], created = Party.objects.get_or_create(
site=get_current_site(request))
context["ANALYTICS_ID"] = getattr(settings, 'ANALYTICS_ID', False)
return context
def search_blog(request):
rs = request.GET['q']
# print(rs)
form = SearchForm(request.GET)
res = form.search()
# res = SearchQuerySet().models(ckeditorBlog).filter(content=rs).load_all()
# print(res)
# for i in posts:
# print(i)
# print(posts)
return render(request, 'search/search.html', {'res': res})
def full_text_search(request):
keyword = request.GET['q']
sform = SearchForm(request.GET)
blogs = sform.search()
print(blogs.all())
for t in blogs.all():
print(t)
return render(request, 'searchResult.html', {
"blogs": blogs.all(),
'list_header': '关键字 \'{}\' '.format(keyword)
})
def process_query(query, email):
"""Function for processing of a request and sending email with results
using celery"""
form = SearchForm({'q': query})
# Launch searching
books = form.search()
# sending email with results
subject = 'Results of books searching'
html_content = render_to_string('books/results_email.html', {
'query': query,
'books': books,
})
text_content = strip_tags(html_content)
send_mail(subject,
text_content,
settings.DEFAULT_FROM_EMAIL, [email],
fail_silently=True,
html_message=html_content)
def full_search(request):
"""全局搜索"""
keywords = request.GET['q']
form = SearchForm(request.GET)
articles = form.search()
try:
page = request.GET.get('page', 1)
except PageNotAnInteger:
page = 1
p = Paginator(articles, 1, request=request)
articles = p.page(page)
return render(request,
'home/article_search_list.html',
context={
'articles': articles,
'keywords': '关键字 \'{}\' 搜索结果'.format(keywords)
})
def search_helper(request, searchqueryset, pagination_function):
"""
Description: Helper function by searching
Based off haystack.views.basic_search()
Arguments: - request: HttpRequest object
- searchqueryset: SearchQuerySet limited to a model by
calling SearchQuerySet().models()
- pagination_function: Helper function for use in paginating
the search results
Return: Dictionary with keys coming from pagination_function. Two
New keys will be added to it:
- query: search query
- suggestion: backend-suggested search query
Author: Nnoduka Eruchalu
"""
query = ''
results = EmptySearchQuerySet()
suggestion = False
search_list = []
if request.GET.get('q'):
form = SearchForm(request.GET,
searchqueryset=searchqueryset,
load_all=True)
if form.is_valid():
query = form.cleaned_data['q']
results = form.search()
# for odd reasons there are duplicates in the haystack results...
search_list = list_dedup([r.object for r in results])
if results.query.backend.include_spelling:
suggestion = form.get_suggestion()
context = pagination_function(request, search_list)
context['query'] = query
context['suggestion'] = suggestion
return context
def newsearchView(request):
if request.user.is_authenticated:
user = request.user
else:
user = get_user(request)
username = request.user.username
searchForm = SearchForm()
if request.method == 'GET':
keyword = request.GET['q']
all_result = SearchQuerySet().filter(content=AutoQuery(keyword))
content = {
'searchResult': all_result,
'curruser': user,
'msgcount': getmsgcount(username),
'searchform': searchForm,
'query': keyword
}
else:
content = {
'curruser': user,
'msgcount': getmsgcount(username),
'searchform': searchForm
}
return render(request, 'myblog/newsearch.html', content)
def search_all(request):
rs = request.GET.get('q', False)
form = SearchForm(request.GET)
searchResult = form.search()
# print(searchResult.query)
# for i in posts:
# print(i.object.title)
paginator = Paginator(searchResult, 6)
page = request.GET.get('page')
try:
posts = paginator.page(page)
except PageNotAnInteger:
posts = paginator.page(1)
except EmptyPage:
posts = paginator.page(paginator.num_pages)
studyNotes = studyNote.objects.all()
ckeditorBlogs = ckeditorBlog.objects.all()
return render(
request, 'search/search_result.html', {
'posts': posts,
'rs': rs,
'studyNotes': studyNotes,
'ckeditorBlogs': ckeditorBlogs
})
def find_keywords(cls, text):
whoosh_backend = SearchForm().searchqueryset.query.backend
if not whoosh_backend.setup_complete:
whoosh_backend.setup()
with whoosh_backend.index.searcher() as searcher:
keywords = searcher.key_terms_from_text("text",
text,
numterms=10,
normalize=False)
keywords = list(zip(*keywords))[0] if keywords else []
keywords = [
cls._find_representative(keyword, text) for keyword in keywords
]
keywords = [
keyword for keyword in keywords if cls._is_good_keyword(keyword)
]
# no double keywords in list
keywords = list(set(keywords))
# no punctuation in suggested keywords
keywords = [
"".join(c for c in s if c not in string.punctuation)
for s in keywords
]
return keywords
def search_form(request):
additions = {
'search_form': SearchForm(),
}
return additions
def test_form_suggestion(self):
form = SearchForm({'q': 'exampl'})
self.assertEqual(form.get_suggestion(), 'example')
def full_search(request):
sform = SearchForm(request.GET)
return render(request, 'search/s.html', {'posts': posts, 'form': sform})
def full_search(request):
sform = SearchForm(request.GET)
members = sform.search()
return render(request, 'union/full_search.html', {'members': members})
def test_form_suggestion(self):
form = SearchForm({"q": "exampl"},
searchqueryset=SearchQuerySet("whoosh"))
self.assertEqual(form.get_suggestion(), "example")
def test_form_suggestion(self):
form = SearchForm({'q': 'exampl'},
searchqueryset=SearchQuerySet('whoosh'))
self.assertEqual(form.get_suggestion(), 'example')
def extra_context(self):
context = super(blogSearchView, self).extra_context()
searchform = SearchForm()
context['searchform'] = searchform
return context
def Search(request):
form = SearchForm(request.GET)
results = form.search()
return render_to_response('search/search.html', {'results': results})
def search(request):
""" Returns messages corresponding to a query """
mlist_fqdn = request.GET.get("mlist")
if mlist_fqdn is None:
mlist = None
else:
try:
mlist = MailingList.objects.get(name=mlist_fqdn)
except MailingList.DoesNotExist:
raise Http404("No archived mailing-list by that name.")
if not is_mlist_authorized(request, mlist):
return render(request,
"hyperkitty/errors/private.html", {
"mlist": mlist,
},
status=403)
query = ''
results = EmptySearchQuerySet()
sqs = RelatedSearchQuerySet()
# Remove private non-subscribed lists
if mlist is not None:
sqs = sqs.filter(mailinglist__exact=mlist.name)
else:
excluded_mlists = MailingList.objects.filter(
archive_policy=ArchivePolicy.private.value)
if request.user.is_authenticated:
subscriptions = get_subscriptions(request.user)
excluded_mlists = excluded_mlists.exclude(
list_id__in=subscriptions.keys())
excluded_mlists = excluded_mlists.values_list("name", flat=True)
sqs = sqs.exclude(mailinglist__in=excluded_mlists)
# Sorting
sort_mode = request.GET.get('sort')
if sort_mode == "date-asc":
sqs = sqs.order_by("date")
elif sort_mode == "date-desc":
sqs = sqs.order_by("-date")
# Handle data
if request.GET.get('q'):
form = SearchForm(request.GET, searchqueryset=sqs, load_all=True)
if form.is_valid():
query = form.cleaned_data['q']
results = form.search()
else:
form = SearchForm(searchqueryset=sqs, load_all=True)
try:
emails = paginate(
results,
request.GET.get('page'),
request.GET.get('count'),
)
except Exception as e:
backend = settings.HAYSTACK_CONNECTIONS[DEFAULT_ALIAS]["ENGINE"]
if backend == "haystack.backends.whoosh_backend.WhooshEngine":
from whoosh.qparser.common import QueryParserError
search_exception = QueryParserError
if backend == "xapian_backend.XapianEngine":
from xapian import QueryParserError
search_exception = QueryParserError
if not isinstance(e, search_exception):
raise
emails = paginate([])
form.add_error(
"q",
ValidationError(
_('Parsing error: %(error)s'),
params={"error": e},
code="parse",
))
for email in emails:
if request.user.is_authenticated:
email.object.myvote = email.object.votes.filter(
user=request.user).first()
else:
email.object.myvote = None
context = {
'mlist': mlist,
'form': form,
'emails': emails,
'query': query,
'sort_mode': sort_mode,
'suggestion': None,
}
if results.query.backend.include_spelling:
context['suggestion'] = form.get_suggestion()
return render(request, "hyperkitty/search_results.html", context)
def search_form(request):
context = {'search_form': SearchForm()}
return context
def images_search(request):
"""
View to make search of images.
:param request: Request to serve
"""
query = ''
time_start = ''
time_end = ''
post = request.POST
enable_checkboxes = False
if request.method == 'GET' and request.GET.get('q') is not None:
request.method = 'POST'
enable_checkboxes = True
post = {'q': request.GET['q'],
'time_start': request.GET.get('time_start', ''),
'time_end': request.GET.get('time_end', '')}
if request.method == 'POST':
# Check if session have to be deleted
if post.get('clear_form'):
request.session.flush()
pass
# New search, clear data stored in session
request.session['results_images'] = None
form = SearchForm(post)
restart = post.get('restart') is not None
if form.is_valid():
images = []
categories_to_search = []
query = form.cleaned_data['q'] if not restart else ''
# Get categories to search and get left menu data
for i in ImageCategory.objects.filter(visible_on_website=True):
category_images = {}
category_images["label_name"] = i.label
category_images["label_code"] = i.value
category_images["images"] = []
search_set = SearchQuerySet().models(Image).filter(category_label__exact=i.label,
ready_to_go=True).order_by('date')
category_images["number_of_images"] = len(search_set)
if restart or enable_checkboxes or post.get("checkbox" + str(i.value)):
categories_to_search.append(i.label)
images.append(category_images)
images = sorted(images, key=lambda k: k["label_name"])
time_start = post.get('time_start') if not restart else ''
time_end = post.get('time_end') if not restart else ''
# Options if query is provided
if query != "":
if time_start != "" and time_end != "":
results = \
SearchQuerySet().filter(imgtext__icontains=query, ready_to_go=True,
category_label__in=categories_to_search,
date__gte=time_start,
date__lte=time_end).models(Image).\
order_by('date')
elif time_start != "":
results = \
SearchQuerySet().filter(imgtext__icontains=query, ready_to_go=True,
category_label__in=categories_to_search,
date__gte=time_start).models(Image).\
order_by('date')
elif time_end != "":
results = \
SearchQuerySet().filter(imgtext__icontains=query, ready_to_go=True,
category_label__in=categories_to_search,
date__lte=time_end).models(Image).\
order_by('date')
else:
results = \
SearchQuerySet().filter(imgtext__icontains=query, ready_to_go=True,
category_label__in=categories_to_search).models(Image).\
order_by('date')
elif time_start != "" or time_end != "":
if time_start != "" and time_end != "":
results = \
SearchQuerySet().filter(ready_to_go=True,
category_label__in=categories_to_search,
date__gte=time_start,
date__lte=time_end).models(Image).\
order_by('date')
elif time_start != "":
results = \
SearchQuerySet().filter(ready_to_go=True,
category_label__in=categories_to_search,
date__gte=time_start).models(Image).\
order_by('date')
elif time_end != "":
results = \
SearchQuerySet().filter(ready_to_go=True,
category_label__in=categories_to_search,
date__lte=time_end).models(Image).\
order_by('date')
else:
if len(categories_to_search) == 1:
return HttpResponseRedirect(reverse('resources:images-category',
kwargs={'category': categories_to_search.pop()}))
else:
results = SearchQuerySet().all().filter(ready_to_go=True,
category_label__in=categories_to_search).\
order_by('date')
else:
if len(categories_to_search) > 1:
results = SearchQuerySet().all().filter(ready_to_go=True,
category_label__in=categories_to_search).\
order_by('date')
else:
return HttpResponseRedirect(reverse('resources:images-category',
kwargs={'category': categories_to_search.pop()}))
else:
results = SearchQuerySet().model(Image).all()
# Store results in session
request.session['results_images'] = results
request.session['images_images'] = images
request.session['enabled_categories'] = categories_to_search
request.session['query'] = query
request.session['time_start'] = time_start
request.session['time_end'] = time_end
else:
results = request.session.get('results_images')
images = request.session.get('images_images')
return render(request, 'resources/images-search-results.html',
{'results': results,
'images': images,
'query': request.session['query'],
'time_start': request.session['time_start'],
'time_end': request.session['time_end'],
'enabled_categories': request.session['enabled_categories']})
