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})
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 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))
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 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 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__]
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"])
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})
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, })