def create_response(self):
"""
Generates the actual HttpResponse to send back to the user.
"""
qu = self.request.GET.get('q','')
if qu:
contributors_qs = SearchQuerySet().models(Contributor)
tags_qs = SearchQuerySet().models(Tag)
matching_contributors = (contributors_qs.auto_query(qu))[:MAX_MCONTRIBS]
matching_tags = tags_qs.auto_query(qu)
else:
matching_contributors = None
matching_tags = None
(paginator, page) = self.build_page()
context = {
'query': self.query,
'form': self.form,
'page': page,
'paginator': paginator,
'mcontributors': matching_contributors,
'mtags': matching_tags,
'is_search': qu
}
context.update(self.extra_context())
if self.request.GET.has_key('ajax'):
t = 'ajax/search_results_page.html'
else:
t = self.template
return render_to_response(t, context,
context_instance=self.context_class(self.request))
class LiveSimpleSearchQuerySetTestCase(TestCase):
fixtures = ['bulk_data.json']
def setUp(self):
super(LiveSimpleSearchQuerySetTestCase, self).setUp()
# Stow.
self.old_debug = settings.DEBUG
settings.DEBUG = True
self.old_ui = connections['default'].get_unified_index()
self.ui = UnifiedIndex()
self.smmi = SimpleMockSearchIndex()
self.ui.build(indexes=[self.smmi])
connections['default']._index = self.ui
self.sample_objs = MockModel.objects.all()
self.sqs = SearchQuerySet()
def tearDown(self):
# Restore.
connections['default']._index = self.old_ui
settings.DEBUG = self.old_debug
super(LiveSimpleSearchQuerySetTestCase, self).tearDown()
def test_general_queries(self):
# For now, just make sure these don't throw an exception.
# They won't work until the simple backend is improved.
self.assertTrue(len(self.sqs.auto_query('daniel')) > 0)
self.assertTrue(len(self.sqs.filter(text='index')) > 0)
self.assertTrue(len(self.sqs.exclude(name='daniel')) > 0)
self.assertTrue(len(self.sqs.order_by('-pub_date')) > 0)
def test_general_queries_unicode(self):
self.assertEqual(len(self.sqs.auto_query(u'Привет')), 0)
def test_more_like_this(self):
# MLT shouldn't be horribly broken. This used to throw an exception.
mm1 = MockModel.objects.get(pk=1)
self.assertEqual(len(self.sqs.filter(text=1).more_like_this(mm1)), 0)
def test_values_queries(self):
sqs = self.sqs.auto_query('daniel')
self.assertTrue(len(sqs) > 0)
flat_scores = sqs.values_list("score", flat=True)
self.assertEqual(flat_scores[0], 0)
scores = sqs.values_list("id", "score")
self.assertEqual(scores[0], [1, 0])
scores_dict = sqs.values("id", "score")
self.assertEqual(scores_dict[0], {"id": 1, "score": 0})
def query(self):
try:
return self._searchquery
except AttributeError:
pass
sqs = SearchQuerySet()
if self._content:
sqs = sqs.auto_query(self._content)
if self._thread_name:
sqs = sqs.filter(thread_name=AutoQuery(self._thread_name))
if self._thread_start:
sqs = sqs.filter(start_post=1)
if self._user_name:
sqs = sqs.filter(username=self._user_name)
if self._before:
sqs = sqs.filter(date__lte=self._before)
if self._after:
sqs = sqs.filter(date__gte=self._after)
if self._threads:
sqs = sqs.filter(thread__in=self._threads)
if self._forums:
sqs = sqs.filter(forum__in=self._forums)
self._searchquery = sqs
return self._searchquery
class SearchForm(forms.Form):
q = forms.CharField(required=False, label=_("Search"))
def __init__(self, *args, **kwargs):
self.searchqueryset = kwargs.get("searchqueryset", None)
self.load_all = kwargs.get("load_all", False)
if self.searchqueryset is None:
self.searchqueryset = SearchQuerySet()
try:
del (kwargs["searchqueryset"])
except KeyError:
pass
try:
del (kwargs["load_all"])
except KeyError:
pass
super(SearchForm, self).__init__(*args, **kwargs)
def search(self):
if self.is_valid():
sqs = self.searchqueryset.auto_query(self.cleaned_data["q"])
if self.load_all:
sqs = sqs.load_all()
return sqs
else:
return []
def make_query(self, search_query):
sqs = SearchQuerySet()
if self.request.POST.get('search_thread_titles'):
sqs = sqs.filter(thread_name=AutoQuery(search_query))
else:
sqs = sqs.auto_query(search_query)
if self.request.POST.get('search_in') == 'private':
if not (self.request.acl.private_threads.can_participate()
and self.request.settings['enable_private_threads']):
raise ACLError404()
sqs = sqs.filter(thread__in=[t.pk for t in self.request.user.private_thread_set.all()])
elif self.request.POST.get('search_in') == 'reports':
if not self.request.acl.reports.can_handle():
raise ACLError404()
sqs = sqs.filter(forum=Forum.objects.special_pk('reports'))
elif self.request.POST.get('search_in') == 'thread':
try:
thread_id = int(self.request.POST.get('search_thread'))
thread_clean = Thread.objects.get(id=thread_id)
if not thread_clean.forum_id in Forum.objects.readable_forums(self.request.acl, True):
raise ACLError404()
self.thread_clean = thread_clean
sqs = sqs.filter(thread=thread_clean.pk)
except (TypeError, Thread.DoesNotExist):
raise ACLError404()
else:
sqs = sqs.filter(forum__in=Forum.objects.readable_forums(self.request.acl))
if self.request.POST.get('search_author'):
sqs = sqs.filter(author__exact=self.request.POST.get('search_author'))
return sqs
class LiveSimpleSearchQuerySetTestCase(TestCase):
fixtures = ['bulk_data.json']
def setUp(self):
super(LiveSimpleSearchQuerySetTestCase, self).setUp()
import haystack
# Stow.
self.old_debug = settings.DEBUG
settings.DEBUG = True
self.old_site = haystack.site
self.site = SearchSite()
self.backend = SearchBackend(site=self.site)
self.index = SimpleMockSearchIndex(MockModel, backend=self.backend)
self.site.register(MockModel, SimpleMockSearchIndex)
haystack.site = self.site
self.sample_objs = MockModel.objects.all()
self.sqs = SearchQuerySet()
def tearDown(self):
# Restore.
import haystack
haystack.site = self.old_site
settings.DEBUG = self.old_debug
super(LiveSimpleSearchQuerySetTestCase, self).tearDown()
def test_general_queries(self):
# For now, just make sure these don't throw an exception.
# They won't work until the simple backend is improved.
self.assertTrue(len(self.sqs.auto_query('daniel')) > 0)
self.assertTrue(len(self.sqs.filter(text='index')) > 0)
self.assertTrue(len(self.sqs.exclude(name='daniel')) > 0)
self.assertTrue(len(self.sqs.order_by('-pub_date')) > 0)
def test_workgroup_member_search_of_discussions(self):
self.logout()
# Only workgroup members should be able to see discussion posts
self.discussionPost = models.DiscussionPost.objects.create(
title="Hello World", body="Text text", workgroup=self.wg1)
# Remove viewer from workgroup
self.wg1.removeUser(self.viewer)
# Check that the viewer was successfully removed
self.assertFalse(perms.user_in_workgroup(self.viewer, self.wg1))
# Confirm discussion in QuerySet
from haystack.query import SearchQuerySet
sqs = SearchQuerySet()
self.assertEqual(len(sqs.auto_query('Hello')), 1)
# User is not in workgroup, so there should be no results
psqs = get_permission_sqs().auto_query(
'Hello').apply_permission_checks(self.viewer)
self.assertEqual(len(psqs), 0)
# Put the viewer in the correct workgroup
self.wg1.giveRoleToUser('manager', self.viewer)
self.assertTrue(perms.user_in_workgroup(self.viewer, self.wg1))
# Viewer is now in workgroup, so there should be results
psqs = get_permission_sqs().auto_query(
'Hello').apply_permission_checks(self.viewer)
self.assertEqual(len(psqs), 1)
self.login_viewer()
response = self.client.get(reverse('aristotle:search') + "?q=Hello")
self.assertEqual(len(response.context['page'].object_list), 1)
def search(self, query=None, *args, **kwargs):
"""
Uses haystack to query news.
Returns a SearchQuerySet
"""
sqs = SearchQuerySet()
user = kwargs.get('user', None)
# check to see if there is impersonation
if hasattr(user,'impersonated_user'):
if isinstance(user.impersonated_user, User):
user = user.impersonated_user
is_an_admin = user.profile.is_superuser
if query:
sqs = sqs.auto_query(sqs.query.clean(query))
if user:
if not is_an_admin:
return []
else:
sqs = sqs.all()
if user:
if not is_an_admin:
return []
return sqs.models(self.model).order_by('-update_dt')
def auto_search(request):
query = request.GET.get('q', None)
term = request.GET.get('term', None)
if not query or not term:
return error_response(Error.NO_SEARCH_PARAMETER)
qs = SearchQuerySet().models(Course)
results = qs.auto_query(query)
result_list = []
for result in results:
ret = Section.get_sections_by_course(result.object)
if ret.error is not Error.OK:
return error_response(ret.error)
if not ret.body:
continue
sections = ret.body
for section in sections:
if section.term == term:
result_list.append(result)
break
# result_list.append(result)
sorted_results = sorted(result_list, key=lambda x: x.score, reverse=True)
final_result = []
for result in sorted_results:
final_result.append(result.object.to_dict(term))
return response(body=final_result)
class LiveSimpleSearchQuerySetTestCase(TestCase):
fixtures = ['bulk_data.json']
def setUp(self):
super(LiveSimpleSearchQuerySetTestCase, self).setUp()
# Stow.
self.old_debug = settings.DEBUG
settings.DEBUG = True
self.old_ui = connections['default'].get_unified_index()
self.ui = UnifiedIndex()
self.smmi = SimpleMockSearchIndex()
self.ui.build(indexes=[self.smmi])
connections['default']._index = self.ui
self.sample_objs = MockModel.objects.all()
self.sqs = SearchQuerySet()
def tearDown(self):
# Restore.
connections['default']._index = self.old_ui
settings.DEBUG = self.old_debug
super(LiveSimpleSearchQuerySetTestCase, self).tearDown()
def test_general_queries(self):
# For now, just make sure these don't throw an exception.
# They won't work until the simple backend is improved.
self.assertTrue(len(self.sqs.auto_query('daniel')) > 0)
self.assertTrue(len(self.sqs.filter(text='index')) > 0)
self.assertTrue(len(self.sqs.exclude(name='daniel')) > 0)
self.assertTrue(len(self.sqs.order_by('-pub_date')) > 0)
def search(request):
query_string = prepare_solr_query_string(request.GET.get('q', ""))
search_terms = query_string.split()
index_query = SearchQuerySet().models(Project)
spelling_suggestion = None
if not FULLTEXT:
try:
results = index_query.auto_query(query_string)
count = results.count()
except TypeError:
count = 0
else:
try:
qfilter = fulltext_project_search_filter(query_string)
results = index_query.filter(qfilter)
spelling_suggestion = results.spelling_suggestion(query_string)
count = results.count()
except TypeError:
results = []
count = 0
logger.debug("Searched for %s. Found %s results." % (query_string, count))
return render_to_response("search.html", {
'query': query_string,
'terms': search_terms,
'results': results,
'spelling_suggestion': spelling_suggestion
},
context_instance=RequestContext(request))
def get_queryset(self, query_args):
# Create new queryset
qs = SearchQuerySet()
# Are we searching all models or just a specific one (depends on
# parameter set in View instantiation)
if self.search_model is not None:
qs = qs.models(self.search_model)
# Do we have a query or are we just getting all of them?
if 'q' in query_args:
qry = query_args['q']
## Currently deactivated due to policy decision to allow the users
## themselves to choose the granularity and fuzzyness of the search
##
# fuzzify search
# qry = u'{}~'.format(qry.replace(' ', '~ '))
qs = qs.auto_query(qry)
elif 'parl_id' in query_args:
qs = qs.filter(parl_id=query_args['parl_id'])
if 'llp_numeric' in query_args:
qs = qs.filter(llps_numeric=query_args['llp_numeric'])
return (qs.all(), None)
# Filter by facets
if query_args['facet_filters']:
for facet_field in query_args['facet_filters'].keys():
# We use narrow to limit the index entries beforehand, but
# need to use filter afterwards to remove partly correct results
# For instance, searching for Steyr (Oberoesterreich) yielded
# everyone from Oberoesterreich until filtering by it again.
qs = qs.narrow(u"{}:{}".format(
facet_field,
qs.query.clean(query_args['facet_filters'][facet_field])
)).filter(
**{facet_field: query_args['facet_filters'][facet_field]})
# Retrieve facets and facet_counts
facet_counts = []
if self.facet_fields:
facets = qs
for facet_field in self.facet_fields:
if self.facet_fields[facet_field]['type'] == 'date':
facets = facets.date_facet(
facet_field,
start_date=datetime.date(1900, 1, 1),
end_date=datetime.date(2050, 1, 1),
gap_by='month')
if self.facet_fields[facet_field]['type'] == 'field':
facets = facets.facet(facet_field)
facet_counts = facets.facet_counts()
# Get results and return them
if 'only_facets' in query_args:
result = {}
else:
result = qs.all()
return (result, facet_counts)
def personal_search(request):
"""
The user can search any item within his own collections and can search **only shared items** of other users
TODO: Build a hash table to store item_id in the result of user_item to reduce time from O(n^2) to O(n)
Reference: http://docs.haystacksearch.org/dev/searchqueryset_api.html#field-lookups
"""
#Two parameters to tune
RESULTS_PER_PAGE = 10
load_all = False
query = request.GET['q'].strip() #Heystack only accepts key name as 'q'
user_id = int(request.GET['pid'])
if query == '':
sqs = EmptySearchQuerySet()
else:
searchqueryset = SearchQuerySet()
if user_id == request.user.pk:
pronoun = '我'
own_items = User_Item.objects.filter(user__pk=request.user.pk)
else:
pronoun = Profile.objects.get(pk=user_id).name
own_items = User_Item.objects.filter(user__pk=user_id).exclude(status=1)
own_items_ids = []
for oi in own_items:
own_items_ids.append(int(oi.item_id))
sqs = searchqueryset.auto_query(query).filter(primary_key__in=own_items_ids)
if load_all:
sqs = sqs.load_all()
paginator = Paginator(sqs, RESULTS_PER_PAGE)
try:
page = paginator.page(request.GET.get('page', 1))
feeds_id = ''
for result in page.object_list:
feeds_id += str(result.object.id) + ','
feeds_id = feeds_id[:-1]
topics_of_item_dict = get_topics_of_item(feeds_id, request.user.pk)
friends_of_item_dict = get_friends_of_item(feeds_id, request.user.pk)
user_item_status_dict = get_user_items(feeds_id, request.user.pk)
except InvalidPage:
raise Http404
context = {
'query': query,
'page': page,
'page_type':'search',
'topics_of_item_dict':topics_of_item_dict,
'friends_of_item_dict':friends_of_item_dict,
'user_item_status_dict':user_item_status_dict,
'paginator': paginator,
'suggestion': None,
'pronoun': pronoun,
'num_results': len(sqs),
'user_id': user_id
}
from django.template import add_to_builtins
add_to_builtins('haystack.templatetags.highlight')
return render_to_response('main/search/personal_search_results.html', context, context_instance=RequestContext(request))
def get_search_results(modelcls, q, limit=DEFAULT_LIMIT):
sqs = SearchQuerySet().models(modelcls)
sqs = sqs.auto_query(q).filter().load_all()
total_results_count = sqs.count()
sresults = sqs[:limit]
results = [ccc.object for ccc in sqs._result_cache[:limit] if ccc]
return total_results_count, results
def get_results(self, name, branch, year, offset, branch_facet, year_facet, city_facet):
if year_facet:
year_facet = [int(x) for x in year_facet.split(",")]
sqs = SearchQuerySet().facet('branch')
sqs = sqs.facet('year_of_passing')
sqs = sqs.facet('city')
if name:
sqs = sqs.auto_query(name)
if branch:
sqs = sqs.filter(branch_exact=branch)
if year:
sqs = sqs.filter(year_of_passing_exact=year)
if branch_facet:
sqs = sqs.filter(branch_exact=branch_facet)
if year_facet:
sqs = sqs.filter(year_of_passing_exact__in=year_facet)
if city_facet:
sqs = sqs.filter(city_exact=city_facet)
offsetvalue = int(offset)
results = sqs.order_by('name')[offsetvalue:offsetvalue + INITIAL_RESULTS_COUNT]
resultcount = len(results)
return results, resultcount
def search(self, query=None, *args, **kwargs):
"""
Uses haystack to query forms.
Returns a SearchQuerySet
"""
sqs = SearchQuerySet()
user = kwargs.get('user', None)
# check to see if there is impersonation
if hasattr(user, 'impersonated_user'):
if isinstance(user.impersonated_user, User):
user = user.impersonated_user
is_an_admin = user.profile.is_superuser
if query:
sqs = sqs.auto_query(sqs.query.clean(query))
if user:
if not is_an_admin:
return []
else:
sqs = sqs.all()
if user:
if not is_an_admin:
return []
return sqs.models(self.model).order_by('-create_dt')
class SearchForm(forms.Form):
q = forms.CharField(required=False, label=_('Search'))
def __init__(self, *args, **kwargs):
self.searchqueryset = kwargs.pop('searchqueryset', None)
self.load_all = kwargs.pop('load_all', False)
if self.searchqueryset is None:
self.searchqueryset = SearchQuerySet()
super(SearchForm, self).__init__(*args, **kwargs)
def search(self):
if self.is_valid():
sqs = self.searchqueryset.auto_query(self.cleaned_data['q'])
if self.load_all:
sqs = sqs.load_all()
return sqs
else:
return []
def get_suggestion(self):
if not self.is_valid():
return None
return self.searchqueryset.spelling_suggestion(self.cleaned_data['q'])
def search(self, query=None, *args, **kwargs):
# """
# Uses haystack to query articles.
# Returns a SearchQuerySet
# """
# # update what the status detail should be instead of active
# kwargs.update({'status_detail': 'published'})
# return super(MemberAppManager, self).search(query=query, *args, **kwargs)
"""
Use Django Haystack search index
Returns a SearchQuerySet object
"""
sqs = SearchQuerySet()
user = kwargs.get('user', AnonymousUser())
user = impersonation(user)
if query:
sqs = sqs.auto_query(sqs.query.clean(query))
if user.profile.is_superuser:
sqs = sqs.all() # admin
else:
if user.is_anonymous():
sqs = anon2_sqs(sqs) # anonymous
else:
pass
sqs = user2_sqs(sqs, user=user) # user
return sqs.models(self.model)
def get_search(self, request, **kwargs):
self.method_check(request, allowed=['get'])
self.is_authenticated(request)
self.throttle_check(request)
sqs = SearchQuerySet().models(Tracks).load_all()
sqs = sqs.auto_query(request.GET.get('q', ''))
paginator = Paginator(sqs, RESULTS_PER_PAGE)
try:
page = paginator.page(int(request.GET.get('page', 1)))
except InvalidPage:
raise Http404("No such page exists.")
except ValueError:
raise Http404("Invalid page number.")
objects = []
for result in page.object_list:
if result is None:
continue
bundle = self.build_bundle(obj=result.object, request=request)
bundle = self.full_dehydrate(bundle)
objects.append(bundle)
self.log_throttled_access(request)
return self.create_response(request, {'objects': objects})
class LiveSimpleSearchQuerySetTestCase(TestCase):
fixtures = ['bulk_data.json']
def setUp(self):
super(LiveSimpleSearchQuerySetTestCase, self).setUp()
# Stow.
self.old_debug = settings.DEBUG
settings.DEBUG = True
self.old_ui = connections['default'].get_unified_index()
self.ui = UnifiedIndex()
self.smmi = SimpleMockSearchIndex()
self.ui.build(indexes=[self.smmi])
connections['default']._index = self.ui
self.sample_objs = MockModel.objects.all()
self.sqs = SearchQuerySet()
def tearDown(self):
# Restore.
connections['default']._index = self.old_ui
settings.DEBUG = self.old_debug
super(LiveSimpleSearchQuerySetTestCase, self).tearDown()
def test_general_queries(self):
# For now, just make sure these don't throw an exception.
# They won't work until the simple backend is improved.
self.assertTrue(len(self.sqs.auto_query('daniel')) > 0)
self.assertTrue(len(self.sqs.filter(text='index')) > 0)
self.assertTrue(len(self.sqs.exclude(name='daniel')) > 0)
self.assertTrue(len(self.sqs.order_by('-pub_date')) > 0)
def search_results(request, results=None):
sqs = SearchQuerySet()
if request.method=="POST":
results = sqs.auto_query(request.POST.get('q')).filter_and(author=request.user)
return render_to_response("search/search.html",
{"results": results},
context_instance=RequestContext(request))
def handle_reply(raw_content):
raw_content = raw_content.lower()
content = raw_content.decode('utf-8')
log.info(content)
if content == u'精选':
_refresh_datetime = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
entities = Selection_Entity.objects.published().filter(pub_time__lte=_refresh_datetime)
return [row.entity for row in entities[:5]]
elif content == u'热门':
popular_list = Entity_Like.objects.popular_random()
entities = Entity.objects.filter(id__in=popular_list)
return entities[:5]
elif content in auto_replies:
return auto_replies[content]
elif RobotDic.objects.filter(keyword=raw_content).count() == 1:
return RobotDic.objects.get(keyword=raw_content)
else:
sqs = SearchQuerySet()
results = sqs.auto_query(content).models(Entity).order_by('-like_count')
res = []
for row in results:
if Entity.objects.filter(pk=row.pk).exists():
res.append(Entity.objects.get(pk=row.pk))
if len(res) >= 10:
break
return res
def get_search_results(modelcls, q, limit=DEFAULT_LIMIT):
sqs = SearchQuerySet().models(modelcls)
sqs = sqs.auto_query(q).filter().load_all()
total_results_count = sqs.count()
sresults = sqs[:limit]
results = [ccc.object for ccc in sqs._result_cache[:limit] if ccc]
return total_results_count, results
def search_results(request, results=None):
sqs = SearchQuerySet()
if request.method == "POST":
results = sqs.auto_query(
request.POST.get('q')).filter_and(author=request.user)
return render_to_response("search/search.html", {"results": results},
context_instance=RequestContext(request))
def get_results(self, name, branch, year, offset, branch_facet, year_facet,
city_facet):
if year_facet:
year_facet = [int(x) for x in year_facet.split(",")]
sqs = SearchQuerySet().facet('branch')
sqs = sqs.facet('year_of_passing')
sqs = sqs.facet('city')
if name:
sqs = sqs.auto_query(name)
if branch:
sqs = sqs.filter(branch_exact=branch)
if year:
sqs = sqs.filter(year_of_passing_exact=year)
if branch_facet:
sqs = sqs.filter(branch_exact=branch_facet)
if year_facet:
sqs = sqs.filter(year_of_passing_exact__in=year_facet)
if city_facet:
sqs = sqs.filter(city_exact=city_facet)
offsetvalue = int(offset)
results = sqs.order_by('name')[offsetvalue:offsetvalue +
INITIAL_RESULTS_COUNT]
resultcount = len(results)
return results, resultcount
class SearchForm(forms.Form):
q = forms.CharField(required=False, label='Search')
def __init__(self, *args, **kwargs):
self.searchqueryset = kwargs.get('searchqueryset', None)
self.load_all = kwargs.get('load_all', False)
if self.searchqueryset is None:
self.searchqueryset = SearchQuerySet()
try:
del(kwargs['searchqueryset'])
except KeyError:
pass
try:
del(kwargs['load_all'])
except KeyError:
pass
super(SearchForm, self).__init__(*args, **kwargs)
def search(self):
self.clean()
sqs = self.searchqueryset.auto_query(self.cleaned_data['q'])
if self.load_all:
sqs = sqs.load_all()
return sqs
def search(request):
query_string = prepare_solr_query_string(request.GET.get('q', ""))
search_terms = query_string.split()
index_query = SearchQuerySet().models(Project)
spelling_suggestion = None
if not FULLTEXT:
try:
results = index_query.auto_query(query_string)
count = results.count()
except TypeError:
count = 0
else:
try:
qfilter = fulltext_project_search_filter(query_string)
results = index_query.filter(qfilter)
spelling_suggestion = results.spelling_suggestion(query_string)
count = results.count()
except TypeError:
results = []
count = 0
logger.debug("Searched for %s. Found %s results." % (query_string, count))
return render_to_response("search.html",
{'query': query_string,
'terms': search_terms,
'results': results,
'spelling_suggestion': spelling_suggestion},
context_instance = RequestContext(request))
def query(self):
try:
return self._searchquery
except AttributeError:
pass
sqs = SearchQuerySet()
if self._content:
sqs = sqs.auto_query(self._content)
if self._thread_name:
sqs = sqs.filter(thread_name=AutoQuery(self._thread_name))
if self._thread_start:
sqs = sqs.filter(start_post=1)
if self._user_name:
sqs = sqs.filter(username=self._user_name)
if self._before:
sqs = sqs.filter(date__lte=self._before)
if self._after:
sqs = sqs.filter(date__gte=self._after)
if self._threads:
sqs = sqs.filter(thread__in=self._threads)
if self._forums:
sqs = sqs.filter(forum__in=self._forums)
self._searchquery = sqs
return self._searchquery
def get_queryset(self, query_args):
# Create new queryset
qs = SearchQuerySet()
# Are we searching all models or just a specific one (depends on
# parameter set in View instantiation)
if self.search_model is not None:
qs = qs.models(self.search_model)
# Do we have a query or are we just getting all of them?
if 'q' in query_args:
qry = query_args['q']
# fuzzify search
qry = u'{}~'.format(qry.replace(' ', '~ '))
qs = qs.auto_query(qry)
elif 'parl_id' in query_args:
qs = qs.filter(parl_id=query_args['parl_id'])
if 'llp_numeric' in query_args:
qs = qs.filter(llps_numeric=query_args['llp_numeric'])
return (qs.all(), None)
# Filter by facets
if query_args['facet_filters']:
for facet_field in query_args['facet_filters'].keys():
# We use narrow to limit the index entries beforehand, but
# need to use filter afterwards to remove partly correct results
# For instance, searching for Steyr (Oberoesterreich) yielded
# everyone from Oberoesterreich until filtering by it again.
qs = qs.narrow(u"{}:{}".format(
facet_field,
qs.query.clean(query_args['facet_filters'][facet_field]))
).filter(
**{
facet_field: query_args['facet_filters'][facet_field]}
)
# Retrieve facets and facet_counts
facet_counts = []
if self.facet_fields:
facets = qs
for facet_field in self.facet_fields:
if self.facet_fields[facet_field]['type'] == 'date':
facets = facets.date_facet(
facet_field,
start_date=datetime.date(1900, 1, 1),
end_date=datetime.date(2050, 1, 1),
gap_by='month')
if self.facet_fields[facet_field]['type'] == 'field':
facets = facets.facet(facet_field)
facet_counts = facets.facet_counts()
# Get results and return them
if 'only_facets' in query_args:
result = {}
else:
result = qs.all()
return (result, facet_counts)
def projectsheet_search(self, request, **kwargs):
""" Search project sheets. """
self.method_check(request, allowed=['get'])
self.throttle_check(request)
self.is_authenticated(request)
# Query params
query = request.GET.get('q', '')
autocomplete = request.GET.get('auto', None)
selected_facets = request.GET.getlist('facet', None)
order = request.GET.getlist('order', None)
sqs = SearchQuerySet().models(self.Meta.object_class).facet('tags')
# narrow down QS with facets
if selected_facets:
for facet in selected_facets:
sqs = sqs.narrow('tags:%s' % (facet))
# A: if autocomplete, we return only a list of tags
# starting with "auto" along with their count.
if autocomplete is not None:
tags = sqs.facet_counts()
tags = tags['fields']['tags']
if len(autocomplete) > 0:
tags = [t for t in tags if t[0].startswith(autocomplete)]
tags = [{'name': t[0], 'count': t[1]} for t in tags]
object_list = {
'objects': tags,
}
# B: else, we return a list of projectsheets
else:
# launch query
if query != "":
sqs = sqs.auto_query(query)
uri = reverse('api_projectsheet_search',
kwargs={'api_name': self.api_name,
'resource_name': self._meta.resource_name})
paginator = Paginator(request.GET, sqs, resource_uri=uri)
objects = []
for result in paginator.page()['objects']:
if result:
bundle = self.build_bundle(obj=result.object,
request=request)
bundle = self.full_dehydrate(bundle, for_list=True)
objects.append(bundle)
object_list = {
'meta': paginator.page()['meta'],
'objects': objects,
}
self.log_throttled_access(request)
return self.create_response(request, object_list)
def get_searchqueryset(self, request):
query = request.GET.get('q', '')
sqs = SearchQuerySet().models(FoiRequest).load_all()
if len(query) > 2:
sqs = sqs.auto_query(query)
else:
sqs = sqs.none()
return SearchQuerySetWrapper(sqs, FoiRequest)
def file_search(self, request, **kwargs):
""" Implement file searching. """
self.method_check(request, allowed=['get'])
self.throttle_check(request)
self.is_authenticated(request)
# URL params
bucket_id = kwargs['bucket_id']
# Query params
query = request.GET.get('q', '')
autocomplete = request.GET.get('auto', None)
selected_facets = request.GET.getlist('facet', None)
order = request.GET.getlist('order', '-pub_date')
sqs = SearchQuerySet().models(BucketFile).filter(
bucket=bucket_id).order_by(order).facet('tags')
# 1st narrow down QS
if selected_facets:
for facet in selected_facets:
sqs = sqs.narrow('tags:%s' % (facet))
# A: if autocomplete, we return only a list of tags starting
# with "auto" along with their count.
if autocomplete is not None:
tags = sqs.facet_counts()
tags = tags['fields']['tags']
if len(autocomplete) > 0:
tags = [t for t in tags if t[0].startswith(autocomplete)]
tags = [
{'name': t[0], 'count':t[1]} for t in tags
]
object_list = {
'objects': tags,
}
# B: else, we return a list of files
else:
if query != "":
sqs = sqs.auto_query(query)
objects = []
# Building object list
for result in sqs:
bundle = self.build_bundle(obj=result.object, request=request)
bundle = self.full_dehydrate(bundle)
objects.append(bundle)
object_list = {
'objects': objects,
}
self.log_throttled_access(request)
return self.create_response(request, object_list)
def corp_roster_search(self, query=None, *args, **kwargs):
"""
Use Django Haystack search index
Used by the corporate membership roster search
which requires different security check
"""
sqs = SearchQuerySet()
if query:
sqs = sqs.auto_query(sqs.query.clean(query))
return sqs.models(self.model)
def getsearchresults(request):
name = request.GET.get("name", '')
branch = request.GET.get("branch", '')
year = request.GET.get("year_of_passing", '')
offset = request.GET.get("offset", '0')
branch_facet = request.GET.get("branch_facet", '')
year_facet = request.GET.get("year_of_passing_facet", '')
offsetvalue = int(offset)
sqs = SearchQuerySet().facet('branch')
sqs = sqs.facet('year_of_passing')
if name or branch or year:
sqs = sqs.auto_query(name + branch + year)
results = sqs.auto_query(branch_facet + year_facet).order_by(
'name')[offsetvalue:offsetvalue + 20]
return results
def corp_roster_search(self, query=None, *args, **kwargs):
"""
Use Django Haystack search index
Used by the corporate membership roster search
which requires different security check
"""
sqs = SearchQuerySet()
if query:
sqs = sqs.auto_query(sqs.query.clean(query))
return sqs.models(self.model)
def search(self, query=None, *args, **kwargs):
"""
Uses haystack to query events.
Returns a SearchQuerySet
"""
sqs = SearchQuerySet()
user = kwargs.get('user', None)
if query:
sqs = sqs.auto_query(sqs.query.clean(query))
return sqs.models(self.model)
def _search_reconciliation_results(self, query, filters, limit):
sqs = SearchQuerySet().models(self.RECONCILIATION_META.model)
for key, val in filters.items():
sqs = sqs.filter(**{key: val})
sqs = sqs.auto_query(query)[:limit]
for r in sqs:
yield {
'id': str(r.pk),
'name': r.name,
'type': [r.model_name],
'score': r.score,
'match': r.score >= 4 # FIXME: this is quite arbitrary
}
class BlogApi():
def __init__(self):
self.searchqueryset = SearchQuerySet()
self.searchqueryset.auto_query('')
self.__max_takecount__ = 8
def search_articles(self, query):
sqs = self.searchqueryset.auto_query(query)
sqs = sqs.load_all()
return sqs[:self.__max_takecount__]
def get_category_lists(self):
return Category.objects.all()
def get_category_articles(self, categoryname):
articles = Article.objects.filter(category__name=categoryname)
if articles:
return articles[:self.__max_takecount__]
return None
def get_recent_articles(self):
return Article.objects.all()[:self.__max_takecount__]
class BlogApi():
def __init__(self):
self.searchqueryset = SearchQuerySet()
self.searchqueryset.auto_query('')
self.__max_takecount__ = 8
def search_articles(self, query):
sqs = self.searchqueryset.auto_query(query)
sqs = sqs.load_all()
return sqs[:self.__max_takecount__]
def get_category_lists(self):
return Category.objects.all()
def get_category_articles(self, categoryname):
articles = Article.objects.filter(category__name=categoryname)
if articles:
return articles[:self.__max_takecount__]
return None
def get_recent_articles(self):
return Article.objects.all()[:self.__max_takecount__]
def get_filtered_queryset(request):
"""Return the QuerySet filtered by the request.
"""
options = { 'active': False, 'with_image': "", 'without_image': "", 'with_revision': "" }
basesqs = SearchQuerySet()
# selection is specified. First filter against the items.
sel = request.GET.get('selection', None)
if sel:
options['selection'] = sel
l = options['selectionset'] = sel.split(',')
basesqs = basesqs.filter(cote__in=l)
# Boolean option processing
for opt in ('with_image', 'without_image', 'with_revision', 'single_technique'):
if request.GET.get(opt, None):
if opt.startswith('without_'):
kw = { opt.replace('without_', 'with_'): False }
else:
kw = { opt: True }
basesqs = basesqs.filter(**kw)
options[opt] = "on"
options['active'] = True
# Parse query string
options['query_string'] = request.GET.get('q', "").strip()
if options['query_string']:
sqs = basesqs.auto_query(options['query_string'])
else:
sqs = basesqs
if 'f' in request.GET:
for facet in request.GET.getlist('f'):
field, value = facet.split(":", 1)
if value:
if field.endswith('__range'):
b, e = value.split("-")
try:
args = { field: [int(b), int(e)] }
sqs = sqs.filter(**args)
except ValueError:
logger.error("Undefined field passed in range filter: " + options['query_string'])
else:
sqs = sqs.narrow(u'%s:"%s"' % (field, sqs.query.clean(value)))
# Add facets to the result
sqs = sqs.facet('status').facet('creator').facet('tags').facet('creation_date_start').facet('creation_date_end').facet('serie').facet('technique').facet('support').facet('width').facet('height').facet('exhibition').facet('acquisition_location')
sqs = sqs.order_by('creation_date_start')
return sqs, options
class SearchForm(forms.Form):
q = forms.CharField(
required=False,
label=_('Search'),
widget=forms.TextInput(attrs={
'type': 'search',
'id': 'local-search-input'
}),
)
def __init__(self, *args, **kwargs):
self.searchqueryset = kwargs.pop('searchqueryset', None)
self.load_all = kwargs.pop('load_all', False)
if self.searchqueryset is None:
self.searchqueryset = SearchQuerySet()
super(SearchForm, self).__init__(*args, **kwargs)
def no_query_found(self):
"""
Determines the behavior when no query was found.
By default, no results are returned (``EmptySearchQuerySet``).
Should you want to show all results, override this method in your
own ``SearchForm`` subclass and do ``return self.searchqueryset.all()``.
"""
return EmptySearchQuerySet()
def search(self):
if not self.is_valid():
return self.no_query_found()
if not self.cleaned_data.get('q'):
return self.no_query_found()
sqs = self.searchqueryset.auto_query(self.cleaned_data['q'])
if self.load_all:
sqs = sqs.load_all()
return sqs
def get_suggestion(self):
if not self.is_valid():
return None
return self.searchqueryset.spelling_suggestion(self.cleaned_data['q'])
def search(request):
categories = Category.objects.filter(parent=None)
search_form = forms.SearchForm(request.GET)
if search_form.is_valid():
keyword = search_form.cleaned_data['keyword']
query = SearchQuerySet()
sqs = query.auto_query(keyword)
clo_list = []
for s in sqs:
clo = Product.objects.get(pk=s.pk)
if clo:
clo_list.append(clo)
clo_list = get_page(request, clo_list)
return render(request, "store/index.html", locals())
def getsearchresults(request):
name = request.GET.get("name", '')
branch = request.GET.get("branch", '')
year = request.GET.get("year_of_passing", '')
offset = request.GET.get("offset", '0')
branch_facet = request.GET.get("branch_facet", '')
year_facet = request.GET.get("year_of_passing_facet", '')
offsetvalue = int(offset)
sqs = SearchQuerySet().facet('branch')
sqs = sqs.facet('year_of_passing')
if name or branch or year:
sqs = sqs.auto_query(name + branch + year)
results = sqs.auto_query(
branch_facet +
year_facet).order_by(
'name')[
offsetvalue:offsetvalue +
20]
return results
def search(query):
s = SearchQuerySet()
for regex, handler in syntaxes.items():
regex = re.compile(regex, re.I)
matches = regex.findall(query)
query = regex.sub('', query)
if matches:
s = handler(s, matches)
# Strip leading and trailing punctuation -- fix for xapian, but shouldn't hurt for other backends
punct = ''.join(set(string.punctuation) ^ set("'\"-"))
querystring = ' '.join(word.strip(punct) for word in query.split())
return s.auto_query(query)
def search(request):
"""
Modification/Combination based on two haystack classes:
1,haystack/views/SearchView
2,haystack/forms/SearchForm/search()
Reference:
#. http://docs.haystacksearch.org/dev/
#. http://lucene.apache.org/solr/tutorial.html
"""
#Two parameters to tune
RESULTS_PER_PAGE = 10
load_all = False
query = request.GET['q'].strip() #Heystack only accepts key name as 'q'
if query == '':
sqs = EmptySearchQuerySet()
else:
searchqueryset = SearchQuerySet()
sqs = searchqueryset.auto_query(query) #The default auto_query method has been modified to use OR instead of AND
if load_all:
sqs = sqs.load_all()
paginator = Paginator(sqs, RESULTS_PER_PAGE)
try:
page = paginator.page(request.GET.get('page', 1))
feeds_id = ''
for result in page.object_list:
feeds_id += str(result.object.id) + ',' #If an item is deleted and not reindexed, then error
feeds_id = feeds_id[:-1]
topics_of_item_dict = get_topics_of_item(feeds_id, request.user.pk)
friends_of_item_dict = get_friends_of_item(feeds_id, request.user.pk)
user_item_status_dict = get_user_items(feeds_id, request.user.pk)
except InvalidPage:
raise Http404
context = {
'query': query,
'page': page,
'page_type':'search',
'topics_of_item_dict':topics_of_item_dict,
'friends_of_item_dict':friends_of_item_dict,
'user_item_status_dict':user_item_status_dict,
'paginator': paginator,
'suggestion': None,
'num_results': len(sqs),
}
from django.template import add_to_builtins
add_to_builtins('haystack.templatetags.highlight') #Changed haystack.utils.Highlighter.highliht to not use window
return render_to_response('main/search/web_search_results.html', context, context_instance=RequestContext(request))
def read(self, request):
required_args(request, ['term'])
sqs = SearchQuerySet()
sqs = sqs.auto_query(request.GET['term']).load_all()
sqs = sqs.exclude(name__startswith="unknown")
results = {}
for i, result in enumerate(sqs):
if request.GET.get('format') == 'kml':
r = add_kml_to_recipient(result.object).__dict__
else:
r = result.object
results[i] = r
return results
def search(self, query=None, *args, **kwargs):
"""
Uses haystack to query events.
Returns a SearchQuerySet
"""
sqs = SearchQuerySet()
user = kwargs.get('user', None)
# check to see if there is impersonation
if hasattr(user, 'impersonated_user'):
if isinstance(user.impersonated_user, User):
user = user.impersonated_user
if query:
sqs = sqs.auto_query(sqs.query.clean(query))
return sqs.models(self.model)
class SearchForm(forms.Form):
q = forms.CharField(
required=False,
label=_("Search"),
widget=forms.TextInput(attrs={"type": "search"}),
)
def __init__(self, *args, **kwargs):
self.searchqueryset = kwargs.pop("searchqueryset", None)
self.load_all = kwargs.pop("load_all", False)
if self.searchqueryset is None:
self.searchqueryset = SearchQuerySet()
super(SearchForm, self).__init__(*args, **kwargs)
def no_query_found(self):
"""
Determines the behavior when no query was found.
By default, no results are returned (``EmptySearchQuerySet``).
Should you want to show all results, override this method in your
own ``SearchForm`` subclass and do ``return self.searchqueryset.all()``.
"""
return EmptySearchQuerySet()
def search(self):
if not self.is_valid():
return self.no_query_found()
if not self.cleaned_data.get("q"):
return self.no_query_found()
sqs = self.searchqueryset.auto_query(self.cleaned_data["q"])
if self.load_all:
sqs = sqs.load_all()
return sqs
def get_suggestion(self):
if not self.is_valid():
return None
return self.searchqueryset.spelling_suggestion(self.cleaned_data["q"])
def search(self, query=None, *args, **kwargs):
"""
Uses haystack to query events.
Returns a SearchQuerySet
"""
sqs = SearchQuerySet()
user = kwargs.get('user', None)
# check to see if there is impersonation
if hasattr(user, 'impersonated_user'):
if isinstance(user.impersonated_user, User):
user = user.impersonated_user
if query:
sqs = sqs.auto_query(sqs.query.clean(query))
return sqs.models(self.model)
class SearchForm(forms.Form):
text_contains = forms.CharField(required=False, label='Keywords')
def __init__(self, *args, **kwargs):
self.searchqueryset = kwargs.pop('searchqueryset', None)
self.load_all = kwargs.pop('load_all', False)
if self.searchqueryset is None:
self.searchqueryset = SearchQuerySet() #.models(models.Summary)
super(SearchForm, self).__init__(*args, **kwargs)
def no_query_found(self):
"""
Determines the behavior when no query was found.
By default, no results are returned (``EmptySearchQuerySet``).
Should you want to show all results, override this method in your
own ``SearchForm`` subclass and do ``return self.searchqueryset.all()``.
"""
print(1)
return self.searchqueryset.all()
def search(self):
if not self.is_valid():
return self.no_query_found()
if not self.cleaned_data.get('text_contains'):
return self.no_query_found()
sqs = self.searchqueryset.auto_query(
self.cleaned_data['text_contains'])
if self.load_all:
sqs = sqs.load_all()
return sqs
def get_suggestion(self):
if not self.is_valid():
return None
return self.searchqueryset.spelling_suggestion(
self.cleaned_data['text_contains'])
def get_simple_search(self, request, **kwargs):
self.method_check(request, allowed=['get'])
query = request.GET.get("q", None)
result = []
if query:
sqs = SearchQuerySet().models(FoiRequest)
sqs = sqs.auto_query(query)
result = list(sqs[:5])
result = [{
"title": x.title,
"id": x.pk,
"public_body_name": x.public_body_name,
"description": x.description,
"url": x.url,
"score": x.score
} for x in result]
return self.create_response(request, {'objects': result})
def get_simple_search(self, request, **kwargs):
self.method_check(request, allowed=['get'])
query = request.GET.get("q", None)
result = []
if query:
sqs = SearchQuerySet().models(FoiRequest)
sqs = sqs.auto_query(query)
result = list(sqs[:5])
result = [{
"title": x.title,
"id": x.pk,
"public_body_name": x.public_body_name,
"description": x.description,
"url": x.url,
"score": x.score
} for x in result]
return self.create_response(request, {'objects': result})
class SearchForm(forms.Form):
q = forms.CharField(required=False, label=_("Search"), widget=forms.TextInput(attrs={"type": "search"}))
def __init__(self, *args, **kwargs):
self.searchqueryset = kwargs.pop("searchqueryset", None)
self.load_all = kwargs.pop("load_all", False)
if self.searchqueryset is None:
self.searchqueryset = SearchQuerySet()
super(SearchForm, self).__init__(*args, **kwargs)
self.helper = helper.FormHelper(self)
self.helper.form_show_labels = False
self.helper.form_tag = False
self.helper.disable_csrf = True
self.helper.layout = layout.Layout(
layout.Div(
layout.Div(
layout.HTML(fieldtostring(
"required", "autofocus", type="text", name="q", value="",
css_class="form-control form-control-sm", style="margin-left: 0px !important"
)),
layout.HTML(valuetolabel("q", "Search users...")),
css_class="md-form md-bg form-sm",
),
),
)
@staticmethod
def no_query_found():
return EmptySearchQuerySet()
def search(self):
if not self.is_valid(): return self.no_query_found()
if not self.cleaned_data.get("q"): return self.no_query_found()
sqs = self.searchqueryset.auto_query(self.cleaned_data["q"])
if self.load_all: sqs = sqs.load_all()
return sqs
def get_suggestion(self):
if not self.is_valid(): return None
return self.searchqueryset.spelling_suggestion(self.cleaned_data["q"])
def get_queryset(self, base_filter=None):
qs = super(BaseEvenementListView, self).get_queryset()
if base_filter is not None:
qs = qs.filter(base_filter)
data = self.request.GET
self.form = EvenementListForm(data, queryset=qs)
try:
self.valid_form = self.form.is_valid()
except:
self.form = EvenementListForm(queryset=qs)
self.valid_form = False
data = {}
if self.enable_default_page and not data:
self.default_page = True
return qs.none()
else:
self.default_page = False
if not self.valid_form:
return qs
search_query = data.get('q')
if search_query:
sqs = SearchQuerySet().models(self.model)
sqs = sqs.auto_query(search_query)
qs = qs.filter(pk__in=sqs.values_list('pk', flat=True))
filters = self.get_filters(data)
qs = qs.filter(filters).distinct()
try:
start, end = int(data.get('dates_0')), int(data.get('dates_1'))
if data.get('par_saison', 'False') == 'True':
qs &= Saison.objects.between_years(start, end).evenements()
else:
qs = qs.filter(debut_date__range=(f'{start}-1-1',
f'{end}-12-31'))
except (TypeError, ValueError):
pass
if data.get('order_by') == 'reversed':
qs = qs.reverse()
return qs
def get_results(self, request):
if SEARCH_VAR not in request.GET and len(request.GET.keys()) is 0:
return super(SearchChangeList, self).get_results(request)
filters = self.custom_get_filters(request)
# Note that pagination is 0-based, not 1-based.
sqs = SearchQuerySet(self.haystack_connection).models(self.model)
if request.GET.get(SEARCH_VAR, False):
sqs = sqs.auto_query(request.GET[SEARCH_VAR])
if filters:
sqs = sqs.filter(**filters)
sqs = sqs.load_all()
# Set ordering.
ordering = self.get_ordering(request, sqs)
sqs = sqs.order_by(*ordering)
paginator = Paginator(sqs, self.list_per_page)
# Get the number of objects, with admin filters applied.
result_count = paginator.count
full_result_count = SearchQuerySet(self.haystack_connection).models(self.model).all().count()
can_show_all = result_count <= list_max_show_all(self)
multi_page = result_count > self.list_per_page
# Get the list of objects to display on this page.
try:
result_list = paginator.page(self.page_num + 1).object_list
# Grab just the Django models, since that's what everything else is
# expecting.
result_list = [result.object for result in result_list if result]
except InvalidPage:
result_list = ()
self.result_count = result_count
self.full_result_count = full_result_count
self.result_list = result_list
self.can_show_all = can_show_all
self.multi_page = multi_page
self.paginator = paginator
class PatientSearchViewTestCase(TestCase):
#fixtures = ['patients_testdata.json']
def setUp(self):
haystack.connections.reload('default')
super(PatientSearchViewTestCase, self).setUp()
def test_search_view(self):
resp = self.client.get('/search/')
self.assertEqual(resp.status_code, 200)
def test_search_query_view(self):
resp = self.client.get('/search/?q=sarah')
self.assertEqual(resp.status_code, 200)
# Test Search Query
self.sqs = SearchQuerySet()
self.assertEqual(self.sqs.auto_query('sarah').count(), 1)
def tearDown(self):
call_command('clear_index', interactive=False, verbosity=0)
def search(self, query=None, *args, **kwargs):
"""
Uses haystack to query forms.
Returns a SearchQuerySet
"""
sqs = SearchQuerySet()
user = kwargs.get('user', None)
is_an_admin = user.profile.is_superuser
if query:
sqs = sqs.auto_query(sqs.query.clean(query))
if user:
if not is_an_admin:
return []
else:
sqs = sqs.all()
if user:
if not is_an_admin:
return []
return sqs.models(self.model).order_by('-create_dt')
def get(self, requset):
""" SKU商品数据搜索 """
# 1.获取参数并进行校验
keyword = requset.GET.get('q')
page = requset.GET.get('page', 1)
page_size = requset.GET.get('page_size', 6)
if not keyword:
return JsonResponse({'code': 400,
'message': '缺少搜索关键字!'})
# 2.使用haystack检索数据
query = SearchQuerySet()
search_res = query.auto_query(keyword).load_all()
# 3.对结果数据进行分页
paginator = Paginator(search_res, page_size)
results = paginator.get_page(page)
# 4.组织响应数据并返回
sku_li = []
nginx_url = 'http://192.168.19.131:8888/'
for res in results:
sku = res.object
sku_li.append({
'id': sku.id,
'name': sku.name,
'price': sku.price,
'default_image_url': nginx_url + sku.default_image.name,
'comments': sku.comments,
})
return JsonResponse({'code': 0,
'message': 'OK',
'count': paginator.count,
'page_size': paginator.per_page,
'query': keyword,
'skus': sku_li, })
