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 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 TestSearch(TestCase):
def setUp(self):
for key, opts in haystack.connections.connections_info.items():
haystack.connections.reload(key)
call_command('clear_index', interactive=False, verbosity=0)
self.u = User.objects.create_user(username="******", password="******")
self.u.first_name = "FirstName"
self.u.last_name = "LastName"
self.u.save()
self.profile = UserProfile.objects.get(user=self.u)
self.profile.phone_number = "(111) 111-1111"
self.profile.save()
self.sqs = SearchQuerySet()
self.client.login(username="******", password="******")
def test_search_view(self):
response = self.client.get("/search/")
self.assertEqual(response.status_code, 200)
self.assertContains(response, "Search")
def test_model_backend(self):
self.assertEqual(UserProfile.objects.count(),
self.sqs.models(UserProfile).count())
self.assertEqual(self.profile,
self.sqs.facet(self.u.first_name)[0].object)
self.assertEqual(self.profile,
self.sqs.facet(self.u.last_name)[0].object)
self.assertEqual(self.profile,
self.sqs.facet(self.profile.phone_number)[0].object)
def get_searchqueryset(self, request):
query = request.GET.get('q', '')
sqs = SearchQuerySet().models(PublicBody).load_all()
if len(query) > 2:
sqs = sqs.filter(name_auto=AutoQuery(query))
else:
sqs = sqs.all()
sqs = sqs.facet('jurisdiction', size=30)
juris = request.GET.get('jurisdiction')
if juris:
sqs = sqs.filter(jurisdiction=juris)
sqs = sqs.facet('classification', size=100)
classification = request.GET.get('classification')
if classification:
sqs = sqs.filter(classification=classification)
sqs = sqs.facet('categories', size=100)
categories = request.GET.getlist('categories')
if categories:
for cat in categories:
sqs = sqs.filter(categories=cat)
return SearchQuerySetWrapper(sqs, PublicBody)
def get_urls(self):
sqs = SearchQuerySet()
for field_name, field in ProductIndex.fields.items():
if field.faceted is True:
# Ensure we facet the results set by the defined facetable fields
sqs.facet(field_name)
urlpatterns = patterns('',
url(r'^suggest/$', self.suggestions_view.as_view(), name='suggest'),
url(r'^$', self.search_view(form_class=MultiFacetedSearchForm,
searchqueryset=sqs), name='search'),
)
return self.post_process_urls(urlpatterns)
def get_sqs():
"""
Return the SQS required by a the Haystack search view
"""
sqs = SearchQuerySet().models(Doctor).order_by('last_name')
sqs = sqs.facet('services')
sqs = sqs.facet('hospitals')
sqs = sqs.facet('languages')
sqs = sqs.facet('locations')
sqs = sqs.facet('gender')
sqs = sqs.facet('accepting')
return sqs
def extra_context(self):
#Facet
categories = None
tags = None
if self.results:
sqs = SearchQuerySet()
for item in self.results:
sqs = sqs.filter(id=item.pk)
categories = sqs.facet("category").facet_counts()
tags = sqs.facet("tags").facet_counts()
return {
'categories': categories,
'tags': tags,
}
def _do_search(self, request, model):
self.method_check(request, allowed=['get'])
self.is_authenticated(request)
self.throttle_check(request)
# Do the query.
query = request.GET.get('q', '')
facet = request.GET.get('facet', '')
sqs = SearchQuerySet().models(model).auto_query(query)
if facet:
sqs = sqs.facet(facet)
paginator = Paginator(sqs, 20)
try:
page = paginator.page(int(request.GET.get('page', 1)))
except InvalidPage:
raise Http404("Sorry, no results on that page.")
objects = []
for result in page.object_list:
highlighter = Highlighter(query)
text = highlighter.highlight(result.text)
bundle = self.full_dehydrate(result.object)
bundle.data['text'] = text
objects.append(bundle)
object_list = {
'objects': objects,
}
self.log_throttled_access(request)
return self.create_response(request, object_list)
class LiveSearchQuerySetTestCase(HaystackBackendTestCase, TestCase):
"""
SearchQuerySet specific tests
"""
fixtures = ['base_data.json']
def get_index(self):
return MockSearchIndex()
def setUp(self):
super(LiveSearchQuerySetTestCase, self).setUp()
self.backend.update(self.index, MockModel.objects.all())
self.sq = connections['default'].get_query()
self.sqs = SearchQuerySet()
def test_result_class(self):
# Assert that we're defaulting to ``SearchResult``.
sqs = self.sqs.all()
self.assertTrue(isinstance(sqs[0], SearchResult))
# Custom class.
sqs = self.sqs.result_class(MockSearchResult).all()
self.assertTrue(isinstance(sqs[0], MockSearchResult))
# Reset to default.
sqs = self.sqs.result_class(None).all()
self.assertTrue(isinstance(sqs[0], SearchResult))
def test_facet(self):
self.assertEqual(len(self.sqs.facet('name').facet_counts()['fields']['name']), 3)
class LiveSearchQuerySetTestCase(HaystackBackendTestCase, TestCase):
"""
SearchQuerySet specific tests
"""
fixtures = ['initial_data.json']
def get_index(self):
return MockSearchIndex()
def setUp(self):
super(LiveSearchQuerySetTestCase, self).setUp()
self.backend.update(self.index, MockModel.objects.all())
self.sq = connections['default'].get_query()
self.sqs = SearchQuerySet()
def test_result_class(self):
# Assert that we're defaulting to ``SearchResult``.
sqs = self.sqs.all()
self.assertTrue(isinstance(sqs[0], SearchResult))
# Custom class.
sqs = self.sqs.result_class(MockSearchResult).all()
self.assertTrue(isinstance(sqs[0], MockSearchResult))
# Reset to default.
sqs = self.sqs.result_class(None).all()
self.assertTrue(isinstance(sqs[0], SearchResult))
def test_facet(self):
self.assertEqual(
len(self.sqs.facet('name').facet_counts()['fields']['name']), 3)
def get_queryset(self):
'''
Fully override the get_queryset() method in order to pass additional
parameters (mincount) to the facet() call.
'''
sqs = SearchQuerySet()
for field in self.facet_fields:
sqs = sqs.facet(field, mincount=1)
entity_type = self.request.GET.get('entity_type', 'Organization')
sort = self.request.GET.get('sort', None)
search_filter = SQ(entity_type=entity_type)
for bound, filter_kwarg in (('start_date', 'start_date__gte'),
('end_date', 'end_date__lte')):
if self.request.GET.get(bound, None):
formatted_date = parse_solr_date(self.request.GET[bound])
search_filter &= SQ(**{filter_kwarg: formatted_date})
sqs = sqs.filter(search_filter)
if not self.request.user.is_authenticated:
sqs = sqs.filter(published=True)
if sort:
sqs = sqs.order_by(sort)
return sqs
def get_sqs():
"""
Get custom SearchQuerySet for LORE.
Calling .facet() for every field must be done for the field
to be in the "facets" context variable provided by Haystack.
"""
sqs = SearchQuerySet()
# Add hard-coded facets.
for facet in ("course", "run", "resource_type"):
sqs = sqs.facet(facet)
# Add dynamic facets (from taxonomy). Certain characters cause problems,
# so use the primary key.
for vocabulary_id in Vocabulary.objects.all().values_list("id", flat=True):
sqs = sqs.facet(vocabulary_id)
return sqs
def search(self):
sqs = SearchQuerySet()
sqs = sqs.facet('bureaux').facet('section').facet('annee').facet(
'partenaire')
if self.q:
sqs = sqs.filter(content=sqs.query.clean(self.q))
# if self.courant:
# sqs = sqs.filter(date_fin__gte=datetime.date.today())
# if self.cloture:
# sqs = sqs.filter(date_fin__lt=datetime.date.today())
self.selected_facets = list(
set(self.selected_facets.split('&') + self.selected_facets_get))
for facet in self.selected_facets:
if "__" not in facet:
continue
field, value = facet.split("__", 1)
if value:
sqs = sqs.narrow(u'%s:"%s"' % (field, sqs.query.clean(value)))
return sqs
def get_urls(self):
# Build SQS
sqs = SearchQuerySet()
for facet in settings.OSCAR_SEARCH_FACETS["fields"].values():
sqs = sqs.facet(facet["field"])
for facet in settings.OSCAR_SEARCH_FACETS["queries"].values():
for query in facet["queries"]:
sqs = sqs.query_facet(facet["field"], query[1])
# The form class has to be passed to the __init__ method as that is how
# Haystack works. It's slightly different to normal CBVs.
urlpatterns = patterns(
"",
url(r"^$", self.search_view(form_class=forms.MultiFacetedSearchForm), name="search"),
url(r"^suggest/$", self.suggest_view.as_view(), name="suggest"),
url(
r"^default/$",
search_view_factory(
view_class=views.FacetedSearchView,
form_class=forms.PriceRangeSearchForm,
searchqueryset=sqs,
template="search/results.html",
),
name="search_default",
),
)
return self.post_process_urls(urlpatterns)
def get_context(self, request):
context = super(RecordIndexPage, self).get_context(request)
# Get selected facets
selected_facets = set(request.GET.getlist('selected_facets'))
# Init a search query set
sqs = SearchQuerySet().models(RecordPage)
# Apply currently selected facets
for facet in selected_facets:
sqs = sqs.narrow(facet)
# Get facet counts
sqs = sqs.facet('language').facet('word_type').facet('first_letter')
# Generate presentable facet data
selected_facets_ui = []
for facet in selected_facets:
f = {
'value':
facet.split(':')[1],
'remove_url':
request.get_full_path().replace(
'&selected_facets={}'.format(facet), '')
}
selected_facets_ui.append(f)
context['selected_facets'] = selected_facets_ui
context['sqs'] = sqs
return context
def search(self):
sqs = SearchQuerySet()
sqs = sqs.facet('bureaux').facet(
'section').facet('annee').facet('partenaire')
if self.q:
sqs = sqs.filter(content=sqs.query.clean(self.q))
if self.courant:
sqs = sqs.filter(date_fin__gte=datetime.date.today())
if self.cloture:
sqs = sqs.filter(date_fin__lt=datetime.date.today())
self.selected_facets = list(
set(self.selected_facets.split('&') + self.selected_facets_get))
for facet in self.selected_facets:
if "__" not in facet:
continue
field, value = facet.split("__", 1)
if value:
sqs = sqs.narrow(u'%s:"%s"' % (field, sqs.query.clean(value)))
return sqs
def _do_search(self, request, model):
self.method_check(request, allowed=['get'])
self.is_authenticated(request)
self.throttle_check(request)
# Do the query.
query = request.GET.get('q', '')
facet = request.GET.get('facet', '')
sqs = SearchQuerySet().models(model).auto_query(query)
if facet:
sqs = sqs.facet(facet)
paginator = Paginator(sqs, 20)
try:
page = paginator.page(int(request.GET.get('page', 1)))
except InvalidPage:
raise Http404("Sorry, no results on that page.")
objects = []
for result in page.object_list:
highlighter = Highlighter(query)
text = highlighter.highlight(result.text)
bundle = self.full_dehydrate(result.object)
bundle.data['text'] = text
objects.append(bundle)
object_list = {
'objects': objects,
}
self.log_throttled_access(request)
return self.create_response(request, object_list)
def get_urls(self):
# Build SQS based on the OSCAR_SEARCH_FACETS settings
sqs = SearchQuerySet()
for facet in settings.OSCAR_SEARCH_FACETS['fields'].values():
sqs = sqs.facet(facet['field'])
for facet in settings.OSCAR_SEARCH_FACETS['queries'].values():
for query in facet['queries']:
sqs = sqs.query_facet(facet['field'], query[1])
# The form class has to be passed to the __init__ method as that is how
# Haystack works. It's slightly different to normal CBVs.
urlpatterns = patterns(
'',
# This view is used in the default templates (at the moment)
url(r'^$', self.search_view(
form_class=forms.MultiFacetedSearchForm),
name='search'),
# This view is used in the demo site.
url(r'^default/$', search_view_factory(
view_class=views.FacetedSearchView,
form_class=forms.PriceRangeSearchForm,
searchqueryset=sqs,
template='search/results.html'),
name='search-default'),
)
return self.post_process_urls(urlpatterns)
def index(request):
profile = request.user.userprofile
queryset = Item.objects.filter(owner=request.user).order_by('-created').prefetch_related('tags')
sqs = SearchQuerySet().filter(owner_id=request.user.id)
if not profile.show_excluded:
excluded_tags = profile.excluded_tags.names()
queryset = queryset.without(*excluded_tags)
for tag in excluded_tags:
sqs = sqs.exclude(tags__in=[tag])
facets = sqs.facet('tags').facet_counts()
tag_objects = []
for name, count in facets.get('fields', {}).get('tags', []):
if name is not None:
tag_objects.append(Tag(name, count, []))
paginator = Paginator(queryset, profile.items_per_page)
try:
page = paginator.page(request.GET.get('page'))
except PageNotAnInteger:
page = paginator.page(1)
except EmptyPage:
page = paginator.page(paginator.num_pages)
context = {
'item_list': queryset,
'tags': tag_objects,
'tag_names': json.dumps([tag.name for tag in tag_objects]),
'current_item_list': page,
'user': request.user,
}
return TemplateResponse(request, 'readme/item_list.html', context)
def explore_get_result_list(self, request):
sqs = SearchQuerySet().models(Story)
filter_fields = self._meta.explore_filter_fields
for filter_field in filter_fields:
facet_field = self._get_facet_field_name(filter_field)
sqs = sqs.facet(facet_field)
return sqs
def get_facets_for_field(field, model=None):
query = SearchQuerySet()
if model is not None:
query = query.models(model)
query = query.narrow("is_displayed:true")
query = query.facet(field)
return query.facet_counts().get("fields", {}).get(field, [])
def get_urls(self):
sqs = SearchQuerySet()
for field_name, field in ProductIndex.fields.items():
if field.faceted is True:
# Ensure we facet the results set by the defined facetable fields
sqs.facet(field_name)
urlpatterns = patterns(
'',
url(r'^suggest/$', self.suggestions_view.as_view(),
name='suggest'),
url(r'^$',
self.search_view(form_class=MultiFacetedSearchForm,
searchqueryset=sqs),
name='search'),
)
return self.post_process_urls(urlpatterns)
def explore_get_result_list(self, request):
sqs = SearchQuerySet().models(Story)
filter_fields = self._meta.explore_filter_fields
for filter_field in filter_fields:
facet_field = self._get_facet_field_name(filter_field)
sqs = sqs.facet(facet_field)
return sqs
def microsite(request, microsite):
microsite = get_object_or_404(Microsite, slug=microsite)
page_title = u"%s Home" % microsite.name
breadcrumbs = [{"url": reverse("materials:microsite", kwargs=dict(microsite=microsite.slug)), "title": page_title}]
query = SearchQuerySet().narrow("is_displayed:true")
query = query.narrow("microsites:%i" % microsite.id)
query = query.order_by("-rating")
query = query.facet("indexed_topics").facet("keywords").facet("grade_levels").facet("course_material_types")
items = []
results = query[0:8]
for result in results:
items.append(populate_item_from_search_result(result))
facets = query.facet_counts()["fields"]
topics = []
topic_counts = dict(facets["indexed_topics"])
for topic, tree_info in tree_item_iterator(microsite.topics.all()):
topic.count = topic_counts.get(str(topic.id), 0)
topics.append((topic, tree_info))
grade_levels = []
grade_level_counts = dict(facets["grade_levels"])
for level in GradeLevel.objects.all():
level.count = grade_level_counts.get(str(level.id), 0)
grade_levels.append(level)
course_material_types = []
course_material_type_counts = dict(facets["course_material_types"])
for material_type in CourseMaterialType.objects.all():
material_type.count = course_material_type_counts.get(str(material_type.id), 0)
course_material_types.append(material_type)
keywords = query.count() and facets.get("keywords", []) or []
if len(keywords) > MAX_TOP_KEYWORDS:
keywords = keywords[:MAX_TOP_KEYWORDS]
keywords = get_tag_cloud(dict(keywords), 3, 0, 0)
for keyword in keywords:
name = get_name_from_slug(Keyword, keyword["slug"]) or \
get_name_from_slug(Tag, keyword["slug"]) or \
keyword["slug"]
keyword["name"] = name
featured_k12 = SearchQuerySet().filter(workflow_state=PUBLISHED_STATE, featured=True, grade_levels__in=(1, 2), microsites=microsite.id).order_by("-featured_on").load_all()[:3]
featured_k12 = [r.object for r in featured_k12 if r]
featured_highered = SearchQuerySet().filter(workflow_state=PUBLISHED_STATE, featured=True, grade_levels=3, microsites=microsite.id).order_by("-featured_on").load_all()[:3]
featured_highered = [r.object for r in featured_highered if r]
slides = Slide.objects.filter(microsite=microsite)
resource_number = SearchQuerySet().filter(workflow_state=PUBLISHED_STATE, microsites=microsite.id).count()
return direct_to_template(request, "materials/microsites/%s.html" % microsite.slug, locals())
def get_queryset(self):
if len(self.request.GET.get('q', '')):
qs = super(FacetedSearchMixin, self).get_queryset()
else:
qs = SearchQuerySet().all()
for field in self.facet_fields:
qs = qs.facet(field)
return qs
def __init__(self, *args, **kwargs):
sqs = SearchQuerySet(using=self.using).order_by('-end_year')
for facet in self.facets:
sqs = sqs.facet(facet, mincount=1, limit=300)
super(SearchFacetedAbstractView, self).__init__(
form_class=FacetedProjectSearchForm, searchqueryset=sqs, *args, **kwargs)
def get_queryset(self):
if len(self.request.GET.get('q', '')):
qs = super(FacetedSearchMixin, self).get_queryset()
else:
qs = SearchQuerySet().all()
for field in self.facet_fields:
qs = qs.facet(field)
return qs
def search_api(request):
query = request.REQUEST.get("q", "")
start = int(request.REQUEST.get("start", 0))
limit = int(request.REQUEST.get("limit", getattr(settings, "HAYSTACK_SEARCH_RESULTS_PER_PAGE", 25)))
sort = request.REQUEST.get("sort", "relevance")
type = request.REQUEST.get("bytype")
sqs = SearchQuerySet()
if type is not None:
if type in ["map", "layer", "contact", "group"]:
# Type is one of our Major Types (not a sub type)
sqs = sqs.narrow("type:%s" % type)
elif type in ["vector", "raster"]:
# Type is one of our sub types
sqs = sqs.narrow("subtype:%s" % type)
if query:
sqs = sqs.filter(content=AutoQuery(query))
sqs = sqs.facet("type").facet("subtype")
if sort.lower() == "newest":
sqs = sqs.order_by("-date")
elif sort.lower() == "oldest":
sqs = sqs.order_by("date")
elif sort.lower() == "alphaaz":
sqs = sqs.order_by("title")
elif sort.lower() == "alphaza":
sqs = sqs.order_by("-title")
results = []
for i, result in enumerate(sqs[start:start + limit]):
data = json.loads(result.json)
data.update({"iid": i + start})
results.append(data)
facets = sqs.facet_counts()
counts = {"map": 0, "layer": 0, "vector": 0, "raster": 0, "contact": 0, "group": 0}
for t, c in facets.get("fields", {}).get("type", []):
counts[t] = c
for t, c in facets.get("fields", {}).get("subtype", []):
counts[t] = c
data = {
"success": True,
"total": sqs.count(),
"rows": results,
"counts": counts,
}
return HttpResponse(json.dumps(data), mimetype="application/json")
def get_sqs(self):
"""
Return the SQS required by a the Haystack search view
"""
# Build SQS based on the OSCAR_SEARCH_FACETS settings
sqs = SearchQuerySet()
for facet in settings.OSCAR_SEARCH_FACETS['fields'].values():
sqs = sqs.facet(facet['field'])
for facet in settings.OSCAR_SEARCH_FACETS['queries'].values():
for query in facet['queries']:
sqs = sqs.query_facet(facet['field'], query[1])
return sqs
def base_sqs():
"""
Return the base SearchQuerySet for Haystack searches.
"""
sqs = SearchQuerySet()
for facet in settings.OSCAR_SEARCH_FACETS["fields"].values():
options = facet.get("options", {})
sqs = sqs.facet(facet["field"], **options)
for facet in settings.OSCAR_SEARCH_FACETS["queries"].values():
for query in facet["queries"]:
sqs = sqs.query_facet(facet["field"], query[1])
return sqs
def base_sqs():
"""
Return the base SearchQuerySet for Haystack searches.
"""
sqs = SearchQuerySet()
for facet in settings.OSCAR_SEARCH_FACETS['fields'].values():
options = facet.get('options', {})
sqs = sqs.facet(facet['field'], **options)
for facet in settings.OSCAR_SEARCH_FACETS['queries'].values():
for query in facet['queries']:
sqs = sqs.query_facet(facet['field'], query[1])
return sqs
def base_sqs():
"""
Return the base SearchQuerySet for Haystack searches.
"""
sqs = SearchQuerySet()
for facet in settings.GRAVYBOAT_SEARCH_FACETS['fields'].values():
options = facet.get('options', {})
sqs = sqs.facet(facet['field'], **options)
for facet in settings.GRAVYBOAT_SEARCH_FACETS['queries'].values():
for query in facet['queries']:
sqs = sqs.query_facet(facet['field'], query[1])
return sqs
def get_sqs(self):
"""
Return the SQS required by a the Haystack search view
"""
# Build SQS based on the OSCAR_SEARCH_FACETS settings
sqs = SearchQuerySet()
for facet in settings.OSCAR_SEARCH_FACETS['fields'].values():
sqs = sqs.facet(facet['field'])
for facet in settings.OSCAR_SEARCH_FACETS['queries'].values():
for query in facet['queries']:
sqs = sqs.query_facet(facet['field'], query[1])
return sqs
def search_haystack(request, species_wid, query):
#search
if species_wid is None:
species_wid = Species.objects.all()[0].wid
results = SearchQuerySet().filter(species_wid=species_wid).filter(content=query)
#calculate facets
facets = results.facet('model_type')
tmp = facets.facet_counts()['fields']['model_type']
modelNameFacet = []
objectTypes = getObjectTypes()
models = []
for tmp2 in tmp:
modelName = objectTypes[objectTypes.index(tmp2[0])]
modelNameFacet.append({
'name':modelName,
'verbose_name': getModel(modelName)._meta.verbose_name,
'count':tmp2[1],
})
models.append(getModel(modelName))
modelNameFacet.sort(lambda x, y:cmp(x['verbose_name'], y['verbose_name']))
#narrow search by facets
model_type = request.GET.get('model_type', '')
if model_type:
results = results.models(getModel(model_type))
#order results
results = results.order_by('wid')
#convert results to query set
queryset = EmptyQuerySet()
for object in results:
tmp = object.model.objects.none()
tmp._result_cache.append(object.object)
queryset = chain(queryset, tmp)
#form response
return render_queryset_to_response(
species_wid = species_wid,
request = request,
models = models,
queryset = queryset,
templateFile = 'public/search.html',
data = {
'query': query,
'engine': 'haystack',
'model_type': model_type,
'modelNameFacet': modelNameFacet,
})
def get_sqs(facets):
"""
Return the SQS required by a the Haystack search view
"""
# Build SQS based on the OSCAR_SEARCH_FACETS settings
sqs = SearchQuerySet()
if facets is not None:
for facet in facets['fields'].values():
options = facet.get('options', {})
sqs = sqs.facet(facet['field'], **options)
for facet in facets['queries'].values():
for query in facet['queries']:
sqs = sqs.query_facet(facet['field'], query[1])
return sqs
def search_haystack(request, species_wid, query):
#search
if species_wid is None:
species_wid = Species.objects.all()[0].wid
results = SearchQuerySet().filter(species_wid=species_wid).filter(
content=query)
#calculate facets
facets = results.facet('model_type')
tmp = facets.facet_counts()['fields']['model_type']
modelNameFacet = []
objectTypes = getObjectTypes()
models = []
for tmp2 in tmp:
modelName = objectTypes[objectTypes.index(tmp2[0])]
modelNameFacet.append({
'name': modelName,
'verbose_name': getModel(modelName)._meta.verbose_name,
'count': tmp2[1],
})
models.append(getModel(modelName))
modelNameFacet.sort(lambda x, y: cmp(x['verbose_name'], y['verbose_name']))
#narrow search by facets
model_type = request.GET.get('model_type', '')
if model_type:
results = results.models(getModel(model_type))
#order results
results = results.order_by('wid')
#convert results to query set
queryset = EmptyQuerySet()
for object in results:
tmp = object.model.objects.none()
tmp._result_cache.append(object.object)
queryset = chain(queryset, tmp)
#form response
return render_queryset_to_response(species_wid=species_wid,
request=request,
models=models,
queryset=queryset,
templateFile='public/search.html',
data={
'query': query,
'engine': 'haystack',
'model_type': model_type,
'modelNameFacet': modelNameFacet,
})
def featured_counts(obj):
try:
featured_counts = {}
sqs = SearchQuerySet()
sqs = sqs.facet("featured")
sqs = sqs.narrow("featured:[* TO *]")
for featured in sqs.facet_counts()['fields']['featured']:
key = featured[0].replace(' ', '')
key = key.replace('-', '')
featured_counts[key] = featured[1]
return featured_counts
except:
return None
def get(self, request, *agrs, **kwargs):
facet_key = kwargs.get('facet_key')
models = [apps.get_model(app_label='main', model_name=kwargs.get('model'))]
qs = SearchQuerySet().models(*models)
fkwargs = {
u'order': u'count',
u'size': 20
}
for key, val in request.GET.items():
if key == 'order':
fkwargs['order'] = val
if key == 'size':
fkwargs['size'] = val
qs = qs.facet(facet_key, **fkwargs)
return Response(qs.facet_counts())
def get_facets_for_field(field, model=None, facet_limit=None, facet_mincount=None):
query = SearchQuerySet()
if model is not None:
if isinstance(model, (tuple, list)):
query = query.models(*model)
else:
query = query.models(model)
query = query.narrow("is_displayed:true")
query = query.facet(field)
if facet_limit:
query = query.facet_limit(facet_limit)
if facet_mincount:
query = query.facet_mincount(facet_mincount)
return query.facet_counts().get("fields", {}).get(field, [])
def featured_counts(obj):
try:
featured_counts = {}
sqs = SearchQuerySet()
sqs = sqs.facet("featured")
sqs = sqs.narrow("featured:[* TO *]")
for featured in sqs.facet_counts()['fields']['featured']:
key = featured[0].replace(' ', '')
key = key.replace('-', '')
featured_counts[key] = featured[1]
return featured_counts
except KeyError:
return None
class TestSearch(TestCase):
def setUp(self):
for key, opts in haystack.connections.connections_info.items():
haystack.connections.reload(key)
call_command('clear_index', interactive=False, verbosity=0)
self.u = User.objects.create_user(username="******", password="******")
self.u.first_name = "FirstName"
self.u.last_name = "LastName"
self.u.save()
self.profile = UserProfile.objects.get(user=self.u)
self.profile.phone_number = "+15101111111"
self.profile.save()
self.sqs = SearchQuerySet()
self.client.login(username="******", password="******")
def test_search_view(self):
url = reverse("haystack_search")
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, "Search")
def test_model_backend(self):
self.assertEqual(UserProfile.objects.count(),
self.sqs.models(UserProfile).count())
self.assertEqual(self.profile,
self.sqs.facet(self.u.first_name)[0].object)
self.assertEqual(self.profile,
self.sqs.facet(self.u.last_name)[0].object)
self.assertEqual(
self.profile,
self.sqs.facet(self.profile.phone_number.as_national)[0].object)
def search_listing(request, model, template_name='search/search.html'):
# Extract the model type from the full path, which should be the plural name
# of a valid model type (ex: '/users/')
if model not in MODEL_FACETS.keys():
raise Http404
sqs = SearchQuerySet().models(model, )
sqs = sqs.order_by('name')
for facet in MODEL_FACETS[model]:
sqs = sqs.facet(facet)
view = search_view_factory(
view_class=FacetedSearchCustomView,
template=template_name,
searchqueryset=sqs,
form_class=FacetedSearchListingForm,
)
return view(request)
def facet_counts(obj, facetName):
try:
counts = {}
sqs = SearchQuerySet()
sqs = sqs.facet(facetName)
sqs = sqs.narrow(facetName + ":[* TO *]")
for x in sqs.facet_counts()['fields'][facetName]:
key = x[0].replace(' ', '')
key = key.replace('-', '')
counts[key] = x[1]
return counts
except KeyError:
return None
def facet_counts(obj, facetName):
try:
counts = {}
sqs = SearchQuerySet()
sqs = sqs.facet(facetName)
sqs = sqs.narrow(facetName + ":[* TO *]")
for x in sqs.facet_counts()['fields'][facetName]:
key = x[0].replace(' ', '')
key = key.replace('-', '')
counts[key] = x[1]
return counts
except:
return None
def infrastructure_counts(obj):
try:
infrastructure_counts = {}
sqs = SearchQuerySet()
sqs = sqs.facet("infrastructure")
sqs = sqs.narrow("infrastructure:[* TO *]")
for infrastructure in sqs.facet_counts()['fields']['infrastructure']:
key = infrastructure[0].replace(' ', '')
key = key.replace('-', '')
infrastructure_counts[key] = infrastructure[1]
return infrastructure_counts
except:
return None
def infrastructure_counts(obj):
try:
infrastructure_counts = {}
sqs = SearchQuerySet()
sqs = sqs.facet("infrastructure")
sqs = sqs.narrow("infrastructure:[* TO *]")
for infrastructure in sqs.facet_counts()['fields']['infrastructure']:
key = infrastructure[0].replace(' ', '')
key = key.replace('-', '')
infrastructure_counts[key] = infrastructure[1]
return infrastructure_counts
except KeyError:
return None
def test_facet_counts_caches_results(self):
""" Verify that facet_counts cache results when it is forced to run the query."""
course = CourseFactory()
runs = [
CourseRunFactory(title='foo',
pacing_type='self_paced',
hidden=True,
course=course),
CourseRunFactory(title='foo',
pacing_type='self_paced',
hidden=True,
course=course),
CourseRunFactory(title='foo',
pacing_type='instructor_paced',
hidden=False,
course=course),
]
queryset = SearchQuerySet().filter(title='foo').models(CourseRun)
queryset = queryset.facet('pacing_type').query_facet(
'hidden', 'hidden:true')
dc_queryset = DistinctCountsSearchQuerySet.from_queryset(
queryset).with_distinct_counts('aggregation_key')
# This should force the query to run and the results to be cached
facet_counts = dc_queryset.facet_counts()
with mock.patch.object(DistinctCountsSearchQuery, 'run') as mock_run:
# Calling facet_counts again shouldn't result in an additional query
cached_facet_counts = dc_queryset.facet_counts()
assert not mock_run.called
assert facet_counts == cached_facet_counts
# Calling count shouldn't result in another query, as we should have already cached it with the
# first request.
count = dc_queryset.count()
assert not mock_run.called
assert count == len(runs)
# Fetching the results shouldn't result in another query, as we should have already cached them
# with the initial request.
results = dc_queryset[:]
assert not mock_run.called
expected = {run.key for run in runs}
actual = {run.key for run in results}
assert expected == actual
def _search_objects(query, filters, facets, model_object, order_by=None):
"""
Search objects via solR.
query: the user search query
filters: list containing filters
facets: the list of facets
model_object: the model the search is refering to
If a filter key is repeated, we apply a OR lookup.
return a queryset
"""
log.debug('search_objects',
query=query,
filter=filters,
facets=facets,
model_object=model_object,
order_by=order_by)
# start queryset
queryset = SearchQuerySet().models(
model_object) # .narrow("namespace:(%s)" % namespace.name)
# filter by facets filters
for key, values in filters.items():
tmp = None
if isinstance(values, (list, tuple)):
# apply OR lookup if same key is repeated.
for value in values:
if tmp is None:
tmp = Q(**{key: Exact(value)})
else:
tmp &= Q(**{key: Exact(value)})
else:
# only one value, no need to loop.
tmp = Q(**{key: Exact(values)})
queryset = queryset.filter(tmp)
# execute the query
if query:
queryset = queryset.filter(content=AutoQuery(query))
# get facets
if facets:
for field in facets:
queryset = queryset.facet(field)
# apply order_by if any
if order_by:
queryset = queryset.order_by(order_by)
return queryset
def list(self):
from haystack.query import SearchQuerySet
results = SearchQuerySet()
for facet in Facet.asset_facets:
results = results.facet(facet)
types = self.search_criteria.split(';')
for t in types:
criteria = t.split(',')
q = ''
for c in criteria:
if len(q):
q += ' OR '
q += c.strip()
results = results.narrow(q)
return results.order_by("name")
def list(self):
from haystack.query import SearchQuerySet
results = SearchQuerySet()
for facet in Facet.asset_facets:
results = results.facet(facet)
types = self.search_criteria.split(';')
for t in types:
criteria = t.split(',')
q = ''
for c in criteria:
if len(q):
q += ' OR '
q += c.strip()
results = results.narrow(q)
return results.order_by("name")
def green_browse(request):
microsite = get_object_or_404(Microsite, slug="green")
query = SearchQuerySet().narrow("is_displayed:true")
query = query.narrow("microsites:%i" % microsite.id)
query = query.facet("indexed_topics").facet("keywords").facet("grade_levels").facet("course_material_types")
facets = query.facet_counts()["fields"]
topics = []
topic_counts = dict(facets["indexed_topics"])
for topic, tree_info in tree_item_iterator(microsite.topics.all()):
topic.count = topic_counts.get(str(topic.id), 0)
topics.append((topic, tree_info))
grade_levels = []
grade_level_counts = dict(facets["grade_levels"])
for level in GradeLevel.objects.all():
level.count = grade_level_counts.get(str(level.id), 0)
grade_levels.append(level)
course_material_types = []
course_material_type_counts = dict(facets["course_material_types"])
for material_type in CourseMaterialType.objects.all():
material_type.count = course_material_type_counts.get(str(material_type.id), 0)
course_material_types.append(material_type)
keywords = query.count() and facets.get("keywords", []) or []
if len(keywords) > MAX_TOP_KEYWORDS:
keywords = keywords[:MAX_TOP_KEYWORDS]
keywords = get_tag_cloud(dict(keywords), 3, 0, 0)
for keyword in keywords:
name = get_name_from_slug(Keyword, keyword["slug"]) or \
get_name_from_slug(Tag, keyword["slug"]) or \
keyword["slug"]
keyword["name"] = name
query = SearchQuerySet().narrow("is_displayed:true")
query = query.narrow("microsites:%i" % microsite.id)
query = query.order_by("-published_on").load_all()
recently_added = [r.object for r in query[:7]]
return direct_to_template(request, "materials/microsites/green-browse.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_listing(request, model, template_name='search/search.html'):
# Extract the model type from the full path, which should be the plural name
# of a valid model type (ex: '/users/')
if model not in MODEL_FACETS.keys():
raise Http404
sqs = SearchQuerySet().models(model, )
# import pdb; pdb.set_trace()
field = request.GET.get("sort", "created")
asc = "-" if not request.GET.get("dir") == "asc" else ""
ordering = "{direction}{field}".format(field=field, direction=asc)
sqs = sqs.order_by(ordering)
for facet in MODEL_FACETS[model]:
sqs = sqs.facet(facet)
view = search_view_factory(
view_class=FacetedSearchCustomView,
template=template_name,
searchqueryset=sqs,
form_class=FacetedSearchListingForm,
)
return view(request)
def test_facet_counts_includes_distinct_counts(self):
""" Verify that facet_counts include distinct counts. """
course = CourseFactory()
CourseRunFactory(title='foo',
pacing_type='self_paced',
hidden=True,
course=course)
CourseRunFactory(title='foo',
pacing_type='self_paced',
hidden=True,
course=course)
CourseRunFactory(title='foo',
pacing_type='instructor_paced',
hidden=False,
course=course)
# Make sure to add both a field facet and a query facet so that we can be sure that both work.
queryset = SearchQuerySet().filter(title='foo').models(CourseRun)
queryset = queryset.facet('pacing_type').query_facet(
'hidden', 'hidden:true')
dc_queryset = DistinctCountsSearchQuerySet.from_queryset(
queryset).with_distinct_counts('aggregation_key')
facet_counts = dc_queryset.facet_counts()
# Field facets are expected to be formatted as a list of three-tuples (field_value, count, distinct_count)
for val, count, distinct_count in facet_counts['fields'][
'pacing_type']:
assert val in {'self_paced', 'instructor_paced'}
if val == 'self_paced':
assert count == 2
assert distinct_count == 1
elif val == 'instructor_paced':
assert count == 1
assert distinct_count == 1
# Query facets are expected to be formatted as a dictionary mapping facet_names to two-tuples (count,
# distinct_count)
hidden_count, hidden_distinct_count = facet_counts['queries']['hidden']
assert hidden_count == 2
assert hidden_distinct_count == 1
def get_urls(self):
# Build SQS
sqs = SearchQuerySet()
for facet in settings.OSCAR_SEARCH_FACETS['fields'].values():
sqs = sqs.facet(facet['field'])
for facet in settings.OSCAR_SEARCH_FACETS['queries'].values():
for query in facet['queries']:
sqs = sqs.query_facet(facet['field'], query[1])
# The form class has to be passed to the __init__ method as that is how
# Haystack works. It's slightly different to normal CBVs.
urlpatterns = patterns('',
url(r'^$', self.search_view(form_class=forms.MultiFacetedSearchForm),
name='search'),
url(r'^default/$', search_view_factory(
view_class=views.FacetedSearchView,
form_class=forms.PriceRangeSearchForm,
searchqueryset=sqs,
template='search/results.html'),
name='search-default'),
)
return self.post_process_urls(urlpatterns)
def get_queryset(self, *args, **kwargs):
# This will return a dict of the first known
# unit of distance found in the query
request = self.request
queryset = EmptySearchQuerySet()
fieldlist = []
if request.GET.get('fields'):
rawfields = request.GET.get('fields')
fieldlist = rawfields.split(',')
facetlist = []
if request.GET.get('facets'):
rawfacets = request.GET.get('facets')
facetlist = rawfacets.split(',')
if request.GET.get('q'):
query = request.GET.get('q')
sqs = SearchQuerySet()
for item in facetlist:
sqs = sqs.facet(item)
if not fieldlist:
sqs = sqs.filter(content=AutoQuery(query))
else:
for idx, field in enumerate(fieldlist):
if idx==0:
sqs = sqs.filter(SQ(**{field+"__icontains":query}))
else:
sqs = sqs.filter_or(SQ(**{field+"__icontains":query}))
finalResult=[]
for m in list(sqs):
if request.user.has_perm('filemaster.view_archivefile',m.object):
finalResult.append(m)
else:
continue
return finalResult
def all_notes(request, project_slug=None):
o = {}
template = 'all-notes.html'
o['filtered'] = False
if request.GET.get('filter'):
template = 'filtered-notes.html'
o['filtered'] = True
qs = SearchQuerySet().models(Note)
query = []
if request.GET.get('topic'):
query += [ ' AND '.join([ 'related_topic_id:%s' % topic for topic
in request.GET.get('topic').split(',') ]) ]
if request.GET.get('project'):
query += [ ' AND '.join([ 'project_id:%s' % project for project
in request.GET.get('project').split(',') ]) ]
qs = qs.narrow(' AND '.join(query)) if query else qs
qs = qs.facet('related_topic_id').facet('project_id')
facet_fields = qs.facet_counts()['fields']
topic_facets = sorted(facet_fields['related_topic_id'],
key=lambda t: t[1], reverse=True)
project_facets = sorted(facet_fields['project_id'],
key=lambda p: p[1], reverse=True)
topic_facets = [ (Topic.objects.get(id=t_id), t_count)
for t_id, t_count in topic_facets[:16] ]
o['topic_facets_1'] = topic_facets[:8]
o['topic_facets_2'] = topic_facets[8:] if (len(topic_facets) > 8) else []
o['project_facets'] = [ (Project.objects.get(id=p_id), p_count)
for p_id, p_count in project_facets ]
o['notes'] = qs
return render_to_response(
template, o, context_instance=RequestContext(request))
url(r'^book_rate/$', 'book_rate_view', name='bookshelf_book_rate_view'),
url(r'^bibliography/$',
'bibliography_view',
name="bookshelf_bibliography_view"),
) + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
sqs = SearchQuerySet()
facet_list = (
'language',
'status',
'publisher',
'category',
'location',
)
for facet in facet_list:
sqs = sqs.facet(facet)
# urlpatterns += patterns('haystack.views',
# url(r'^search/$',
# FacetedSearchCustomView(form_class=FacetedSearchForm, searchqueryset=sqs),
# name='bookshelf_search_view',
# ),
# )+ static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
urlpatterns += patterns(
'haystack.views',
url(r"^search/", SearchBookshelf.as_view(), name='bookshelf_search_view'),
) + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
urlpatterns += patterns(
'bookshelf.search',
