def setUp(self):
super(EmptySearchQuerySetTestCase, self).setUp()
self.esqs = EmptySearchQuerySet()
class SearchView(object):
template = 'search/search.html'
extra_context = {}
query = ''
results = EmptySearchQuerySet()
request = None
form = None
results_per_page = RESULTS_PER_PAGE
def __init__(self, template=None, load_all=True, form_class=None, searchqueryset=None, results_per_page=None):
self.load_all = load_all
self.form_class = form_class
self.searchqueryset = searchqueryset
if form_class is None:
self.form_class = ModelSearchForm
if not results_per_page is None:
self.results_per_page = results_per_page
if template:
self.template = template
def __call__(self, request):
"""
Generates the actual response to the search.
Relies on internal, overridable methods to construct the response.
"""
self.request = request
self.form = self.build_form()
self.query = self.get_query()
self.results = self.get_results()
return self.create_response()
def build_form(self, form_kwargs=None):
"""
Instantiates the form the class should use to process the search query.
"""
data = None
kwargs = {
'load_all': self.load_all,
}
if form_kwargs:
kwargs.update(form_kwargs)
if len(self.request.GET):
data = self.request.GET
if self.searchqueryset is not None:
kwargs['searchqueryset'] = self.searchqueryset
return self.form_class(data, **kwargs)
def get_query(self):
"""
Returns the query provided by the user.
Returns an empty string if the query is invalid.
"""
if self.form.is_valid():
return self.form.cleaned_data['q']
return ''
def get_results(self):
"""
Fetches the results via the form.
Returns an empty list if there's no query to search with.
"""
return self.form.search()
def build_page(self):
"""
Paginates the results appropriately.
In case someone does not want to use Django's built-in pagination, it
should be a simple matter to override this method to do what they would
like.
"""
try:
page_no = int(self.request.GET.get('page', 1))
except (TypeError, ValueError):
raise Http404("Not a valid number for page.")
if page_no < 1:
raise Http404("Pages should be 1 or greater.")
start_offset = (page_no - 1) * self.results_per_page
self.results[start_offset:start_offset + self.results_per_page]
paginator = Paginator(self.results, self.results_per_page)
try:
page = paginator.page(page_no)
except InvalidPage:
raise Http404("No such page!")
return (paginator, page)
def extra_context(self):
"""
Allows the addition of more context variables as needed.
Must return a dictionary.
"""
return {}
def get_context(self):
(paginator, page) = self.build_page()
context = {
'query': self.query,
'form': self.form,
'page': page,
'paginator': paginator,
'suggestion': None,
}
if self.results and hasattr(self.results, 'query') and self.results.query.backend.include_spelling:
context['suggestion'] = self.form.get_suggestion()
context.update(self.extra_context())
return context
def create_response(self):
"""
Generates the actual HttpResponse to send back to the user.
"""
context = self.get_context()
return render(self.request, self.template, context)
def basic_search(request,
load_all=True,
form_class=ModelSearchForm,
searchqueryset=None,
extra_context=None,
results_per_page=None):
query = ''
results = EmptySearchQuerySet()
if request.GET.get('q'):
form = form_class(request.GET,
searchqueryset=searchqueryset,
load_all=load_all)
if form.is_valid():
query = form.cleaned_data['q']
results = form.search()
else:
form = form_class(searchqueryset=searchqueryset, load_all=load_all)
paginator = Paginator(results, results_per_page or RESULTS_PER_PAGE)
try:
page = paginator.page(int(request.GET.get('page', 1)))
except InvalidPage:
result = {"code": 404, "msg": 'No file found！', "data": []}
return HttpResponse(json.dumps(result),
content_type="application/json")
context = {
'form': form,
'page': page,
'paginator': paginator,
'query': query,
'suggestion': None,
}
if results.query.backend.include_spelling:
context['suggestion'] = form.get_suggestion()
if extra_context:
context.update(extra_context)
jsondata = []
print(len(page.object_list))
for result in page.object_list:
tagList = []
tag = Poetry.objects.get(
poetry_no=result.object.poetry_no).poetry_tag.all()
for t in tag:
tagList.append(t.tag_name)
# 返回的响应
data = {
'no': result.object.poetry_no,
'title': result.object.poetry_title,
'author': result.object.poetry_author.author_name,
'dynasty': result.object.poetry_dynasty.dynasty_name,
'text': result.object.poetry_text,
'translation': result.object.poetry_translation,
'annotation': result.object.poetry_annotation,
'appreciation': result.object.poetry_appreciation,
'tag': tuple(tagList)
}
jsondata.append(data)
tagList.clear()
if len(jsondata) == 0:
result = {"code": 200, "msg": 'Search successfully！', "data": "None"}
else:
result = {"code": 200, "msg": 'Search successfully！', "data": jsondata}
return JsonResponse(result, content_type="application/json")
def form_invalid(self, form):
context = self.get_context_data(**{
self.form_name: form,
'object_list': EmptySearchQuerySet()
})
return self.render_to_response(context)
def get_empty_query_set(self):
return EmptySearchQuerySet(using=self.using)
def basic_search(request,
template='search/search.html',
load_all=True,
form_class=ModelSearchForm,
searchqueryset=None,
context_class=RequestContext,
extra_context=None,
results_per_page=None):
"""
A more traditional view that also demonstrate an alternative
way to use Haystack.
Useful as an example of for basing heavily custom views off of.
Also has the benefit of thread-safety, which the ``SearchView`` class may
not be.
Template:: ``search/search.html``
Context::
* form
An instance of the ``form_class``. (default: ``ModelSearchForm``)
* page
The current page of search results.
* paginator
A paginator instance for the results.
* query
The query received by the form.
"""
query = ''
results = EmptySearchQuerySet()
if request.GET.get('q'):
form = form_class(request.GET,
searchqueryset=searchqueryset,
load_all=load_all)
if form.is_valid():
query = form.cleaned_data['q']
results = form.search()
else:
form = form_class(searchqueryset=searchqueryset, load_all=load_all)
paginator = Paginator(results, results_per_page or RESULTS_PER_PAGE)
try:
page = paginator.page(int(request.GET.get('page', 1)))
except InvalidPage:
raise Http404("No such page of results!")
context = {
'form': form,
'page': page,
'paginator': paginator,
'query': query,
'suggestion': None,
}
if results.query.backend.include_spelling:
context['suggestion'] = form.get_suggestion()
if extra_context:
context.update(extra_context)
return render_to_response(template,
context,
context_instance=context_class(request))
def get_queryset(self):
queryset = EmptySearchQuerySet()
query = self.request.GET.get('q', None)
if query:
queryset = SearchQuerySet().autocomplete(content_auto=query)[:6]
return queryset
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 (backend == "haystack.backends.elasticsearch_backend.Elastic"
"searchSearchEngine" or backend
== "haystack.backends.elasticsearch2_backend.Elastic"
"search2SearchEngine" or backend
== "haystack.backends.elasticsearch5_backend.Elastic"
"search5SearchEngine"):
from elasticsearch import RequestError
search_exception = RequestError
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(request,
template='search/search.html',
load_all=True,
form_class=ModelSearchForm,
searchqueryset=None,
context_class=RequestContext,
extra_context=None,
results_per_page=None):
query = ''
results = EmptySearchQuerySet()
if request.GET.get('q'):
searchqueryset = SearchQuerySet() \
.filter(Q(public=True) | Q(author=request.user)) \
.order_by('-pub_date')
if request.user.is_authenticated() and \
'mine-only' in request.GET:
searchqueryset = SearchQuerySet().filter(author=request.user) \
.order_by('-pub_date')
elif request.user.is_authenticated() and \
('author' in request.GET and
request.GET.get('author')):
author = request.GET.get('author')
if author == request.user.username:
searchqueryset = SearchQuerySet().filter(author=request.user) \
.order_by('-pub_date')
else:
team = get_object_or_None(Team, slug=author)
if team and team.user_is_member(request.user):
searchqueryset = SearchQuerySet().filter(author=team) \
.order_by('-pub_date')
form = ModelSearchForm(request.GET,
searchqueryset=searchqueryset,
load_all=load_all)
if form.is_valid():
query = form.cleaned_data['q']
results = form.search()
else:
form = form_class(searchqueryset=searchqueryset, load_all=load_all)
paginator = Paginator(results, results_per_page or RESULTS_PER_PAGE)
try:
page = paginator.page(int(request.GET.get('page', 1)))
except InvalidPage:
raise Http404("No such page of results!")
context = {
'form': form,
'has_snipts': True,
'page': page,
'paginator': paginator,
'query': query,
'suggestion': None,
}
if results.query.backend.include_spelling:
context['suggestion'] = form.get_suggestion()
if extra_context:
context.update(extra_context)
return render(request, template, context)
class SearchView(object):
template = "search/search.html"
extra_context = {}
query = ""
results = EmptySearchQuerySet()
request = None
form = None
results_per_page = RESULTS_PER_PAGE
def __init__(
self,
template=None,
load_all=True,
form_class=None,
searchqueryset= None,
results_per_page=None,
zipcode_provided = False,
sqs=None,
zipcode_form=None,
zipcode=None,
):
self.load_all = load_all
self.form_class = form_class
self.searchqueryset = SearchQuerySet().order_by('-update_date')
#self.searchqueryset = None
self.zipcode_provided = zipcode_provided
self.sqs = sqs
self.zipcode_form = zipcode_form
self.zipcode= zipcode
self.city = None
self.state = None
if form_class is None:
self.form_class = ModelSearchForm
if not results_per_page is None:
self.results_per_page = results_per_page
if template:
self.template = template
def __call__(self, request):
"""
Generates the actual response to the search.
Relies on internal, overridable methods to construct the response.
"""
self.request = request
if self.is_zipcode_provided(self.request):
self.zipcode_provided = True
self.form = self.build_form()
self.query = self.get_query()
self.results = self.get_results()
#import pdb; pdb.set_trace()
return self.create_response()
def is_zipcode_provided(self, request):
#self.zipcode = self.request.GET.get('zipcode')
if request.GET.get('zipcode'):
return True
else:
return False
def build_form(self, form_kwargs=None):
"""
Instantiates the form the class should use to process the search query.
"""
data = None
kwargs = {"load_all": self.load_all}
if form_kwargs:
kwargs.update(form_kwargs)
if len(self.request.GET):
data = self.request.GET
# Radius is defaulted to 30 miles
#import pdb; pdb.set_trace()
if self.request.GET.get('zipcode'):
self.zipcode = self.request.GET.get('zipcode')
"""
search = ZipcodeSearchEngine()
zip = search.by_zipcode(zip_code)
longitude = zip['Longitude']
lat = zip['Latitude']
"""
zip = zipcode.isequal(str(self.zipcode))
longitude = zip.lng
lat = zip.lat
self.city = zip.city
self.state = zip.state
self.searchqueryset = SearchQuerySet().dwithin('location', Point(longitude, lat), D(mi=30))
#f = PostingFilter(self.request.GET, queryset=sqs)
else:
ip = '24.6.173.143'
g = GeoIP2()
location_dict = g.city(ip)
self.city = location_dict['city']
self.state = location_dict['region']
lat = location_dict['latitude']
longitude = location_dict['longitude']
self.zipcode = location_dict['postal_code']
self.searchqueryset = SearchQuerySet().dwithin('location', Point(longitude, lat), D(mi=30))
#f = PostingFilter(self.request.GET, queryset=sqs)
if self.searchqueryset is not None:
kwargs["searchqueryset"] = self.searchqueryset
self.zipcode_form = Zipcode_Form(self.request.GET)
return self.form_class(data, **kwargs)
def get_query(self):
"""
Returns the query provided by the user.
Returns an empty string if the query is invalid.
"""
if self.form.is_valid():
return self.form.cleaned_data["q"]
return ""
def get_results(self):
"""
Fetches the results via the form.
Returns an empty list if there's no query to search with.
"""
#import ipdb; ipdb.set_trace()
return self.form.search()
def build_page(self):
"""
Paginates the results appropriately.
In case someone does not want to use Django's built-in pagination, it
should be a simple matter to override this method to do what they would
like.
"""
try:
page_no = int(self.request.GET.get("page", 1))
except (TypeError, ValueError):
raise Http404("Not a valid number for page.")
if page_no < 1:
raise Http404("Pages should be 1 or greater.")
start_offset = (page_no - 1) * self.results_per_page
self.results[start_offset : start_offset + self.results_per_page]
paginator = Paginator(self.results, self.results_per_page)
try:
page = paginator.page(page_no)
except InvalidPage:
raise Http404("No such page!")
return (paginator, page)
def extra_context(self):
"""
Allows the addition of more context variables as needed.
Must return a dictionary.
"""
return {}
def get_context(self):
(paginator, page) = self.build_page()
context = {
"query": self.query,
"zipcode_provided": self.zipcode_provided,
"zipcode_form": self.zipcode_form,
"sqs": self.sqs,
"form": self.form,
"page": page,
"paginator": paginator,
"suggestion": None,
"zipcode": self.zipcode,
"city" : self.city,
"state": self.state,
}
if (
hasattr(self.results, "query")
and self.results.query.backend.include_spelling
):
context["suggestion"] = self.form.get_suggestion()
context.update(self.extra_context())
return context
def create_response(self):
"""
Generates the actual HttpResponse to send back to the user.
"""
context = self.get_context()
return render(self.request, self.template, context)
class SearchMixin(MultipleObjectMixin, FormMixin):
"""
A mixin that allows adding in Haystacks search functionality into
another view class.
This mixin exhibits similar end functionality as the base Haystack search
view, but with some important distinctions oriented around greater
compatibility with Django's built-in class based views and mixins.
Normal flow:
self.request = request
self.form = self.build_form()
self.query = self.get_query()
self.results = self.get_results()
return self.create_response()
This mixin should:
1. Make the form
2. Get the queryset
3. Return the paginated queryset
"""
template_name = 'search/search.html'
load_all = True
form_class = ModelSearchForm
queryset = EmptySearchQuerySet()
context_object_name = None
paginate_by = RESULTS_PER_PAGE
paginate_orphans = 0
paginator_class = Paginator
page_kwarg = 'page'
form_name = 'form'
search_field = 'q'
def get_form_kwargs(self):
"""
Returns the keyword arguments for instantiating the form.
"""
kwargs = {'initial': self.get_initial()}
if self.request.method == 'GET':
kwargs.update({
'data': self.request.GET,
})
kwargs.update({'searchqueryset': self.get_query_set()})
return kwargs
def get_query_set(self):
return self.queryset
def form_invalid(self, form):
return self.render_to_response(
self.get_context_data(**{
self.form_name: form,
'object_list': self.get_query_set()
}))
def form_valid(self, form):
self.queryset = form.search()
return self.render_to_response(
self.get_context_data(
**{
self.form_name: form,
'query': form.cleaned_data.get(self.search_field),
'object_list': self.queryset
}))
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 = request.user.hyperkitty_profile.get_subscriptions()
excluded_mlists = excluded_mlists.exclude(
name__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)
messages = paginate(results, page_num=request.GET.get('page'))
for message in messages:
if request.user.is_authenticated():
message.object.myvote = message.object.votes.filter(user=request.user).first()
else:
message.object.myvote = None
context = {
'mlist' : mlist,
'form': form,
'messages': messages,
'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 no_query_found(self):
return EmptySearchQuerySet()
class SearchView(TemplateView):
template_name = "search/base_facet.html"
results = EmptySearchQuerySet()
form_class = FacetedSearchForm
form = None
query = ''
selected_facets = None
selected_facets_list = None
def get_context_data(self, request, **kwargs):
context = super(SearchView, self).get_context_data(**kwargs)
context['request'] = self.request
# causes solr request #1
context['facets'] = self.results.facet_counts()
context['form'] = self.form
context['query'] = self.query
context['selected_facets'] = ('&'.join(self.selected_facets)
if self.selected_facets else '')
context['selected_facets_list'] = self.selected_facets_list
context['results'] = self.results
context['count'] = len(self.results) # causes solr request #2
return context
def get(self, request, **kwargs):
"""
Performing the search causes three requests to be sent to Solr.
1. For the facets
2. For the count (unavoidable, as pagination will cause this anyay)
3. For the results
"""
self.request = request
self.form = self.build_form()
self.selected_facets = self.get_selected_facets()
self.selected_facets_list = self.get_selected_facets_list()
self.query = self.get_query()
if self.form.is_valid():
self.results = self.get_results()
context = self.get_context_data(request, **kwargs)
# For returning results partials for javascript
if request.is_ajax() or request.GET.get('ajax'):
self.template_name = 'search/faceted_results.html'
return self.render_to_response(context)
def build_form(self):
"""
Instantiates the form the class should use to process the search query.
"""
data = self.request.GET if len(self.request.GET) else None
return self.form_class(data, facets=('project', ))
def get_selected_facets_list(self):
return [tuple(s.split(':')) for s in self.selected_facets if s]
def get_selected_facets(self):
"""
Returns the a list of facetname:value strings
e.g. [u'project_exact:Read The Docs', u'author_exact:Eric Holscher']
"""
return self.request.GET.getlist('selected_facets')
def get_query(self):
"""
Returns the query provided by the user.
Returns an empty string if the query is invalid.
"""
return self.request.GET.get('q')
def get_results(self):
"""
Fetches the results via the form.
"""
return self.form.search()
def setUp(self):
super().setUp()
self.esqs = EmptySearchQuerySet()
class ItemsMatchView(SearchView):
template = 'search_engine/search.html'
extra_context = {}
query = ''
results = EmptySearchQuerySet()
request = None
form = None
results_per_page = RESULTS_PER_PAGE
def __init__(self, template=None, load_all=True, form_class=None, searchqueryset=None, context_class=RequestContext, results_per_page=None):
self.load_all = load_all
self.form_class = form_class
self.context_class = context_class
self.searchqueryset = searchqueryset
if form_class is None:
self.form_class = ItemsMatchForm
if not results_per_page is None:
self.results_per_page = results_per_page
if template:
self.template = template
def get(self, request):
"""
Generates the actual response to the search.
Relies on internal, overridable methods to construct the response.
"""
self.request = request
self.form = self.build_form()
self.query = self.get_query()
self.results = self.get_results()
return self.create_response()
def build_form(self, form_kwargs=None):
"""
Instantiates the form the class should use to process the search query.
"""
data = None
kwargs = {
'load_all': self.load_all,
}
if form_kwargs:
kwargs.update(form_kwargs)
if len(self.request.GET):
data = self.request.GET
if self.searchqueryset is not None:
kwargs['searchqueryset'] = self.searchqueryset
return self.form_class(data, **kwargs)
def get_query(self):
"""
Returns the query provided by the user.
Returns an empty string if the query is invalid.
"""
if self.form.is_valid():
return self.form.cleaned_data['q']
return ''
def get_results(self):
"""
Fetches the results via the form.
Returns an empty list if there's no query to search with.
"""
return self.form.search()
def build_page(self):
"""
Paginates the results appropriately.
In case someone does not want to use Django's built-in pagination, it
should be a simple matter to override this method to do what they would
like.
"""
try:
page_no = int(self.request.GET.get('page', 1))
except (TypeError, ValueError):
raise Http404("Not a valid number for page.")
if page_no < 1:
raise Http404("Pages should be 1 or greater.")
start_offset = (page_no - 1) * self.results_per_page
self.results[start_offset:start_offset + self.results_per_page]
paginator = Paginator(self.results, self.results_per_page)
try:
page = paginator.page(page_no)
except InvalidPage:
raise Http404("No such page!")
return (paginator, page)
def extra_context(self):
return {'MEDIA_URL':MEDIA_URL}
def create_response(self):
"""
Generates the actual HttpResponse to send back to the user.
"""
(paginator, page) = self.build_page()
search_results = []
recent_feeds = []
if self.query:
for item in page.object_list:
if item.object.status == 'FOUND':
media = Media.objects.all().filter(of_item=item.object)
if not media:
item.media = media
else:
item.media = media[0]
search_results.append(item)
return search_results
def no_query_found(self):
""" Overriding default behaviour to allow topic searches without textual query. """
if hasattr(self, 'cleaned_data') and self.cleaned_data.get(
'topics', None):
return self.searchqueryset.all()
return EmptySearchQuerySet()
