search.py

import haystack.backends.solr_backend
from haystack.query import SearchQuerySet, RelatedSearchQuerySet
from haystack.constants import ID, DJANGO_CT, DJANGO_ID
from haystack.utils import get_identifier
from haystack.backends import EmptyResults

from pysolr import SolrError

from django import forms
from django.conf import settings
from django.utils.translation import ugettext_lazy as _

from emissions.models import Emission, Episode, NewsItem, SoundFile


class MoreLikeThisSearchQuerySet(SearchQuerySet):
    def more_like_this(self, model_instance, **kwargs):
        clone = self._clone()
        clone.query.more_like_this(model_instance, **kwargs)
        return clone


class CustomSolrSearchQuery(haystack.backends.solr_backend.SolrSearchQuery):
    def more_like_this(self, model_instance, **kwargs):
        self._more_like_this = True
        self._mlt_instance = model_instance

    def run_mlt(self, **kwargs):
        """Builds and executes the query. Returns a list of search results."""
        if self._more_like_this is False or self._mlt_instance is None:
            raise MoreLikeThisError("No instance was provided to determine 'More Like This' results.")

        additional_query_string = self.build_query()
        search_kwargs = {
            'start_offset': self.start_offset,
            'result_class': self.result_class,
            'models': self.models,
            'mlt.fl': 'tags',
        }

        if self.end_offset is not None:
            search_kwargs['end_offset'] = self.end_offset - self.start_offset

        results = self.backend.more_like_this(self._mlt_instance, additional_query_string, **search_kwargs)
        self._results = results.get('results', [])
        self._hit_count = results.get('hits', 0)


class CustomSolrSearchBackend(haystack.backends.solr_backend.SolrSearchBackend):
    def more_like_this(self, model_instance, additional_query_string=None,
                       start_offset=0, end_offset=None, models=None,
                       limit_to_registered_models=None, result_class=None, **kwargs):
        from haystack import connections

        # Deferred models will have a different class ("RealClass_Deferred_fieldname")
        # which won't be in our registry:
        model_klass = model_instance._meta.concrete_model

        index = connections[self.connection_alias].get_unified_index().get_index(model_klass)
        field_name = index.get_content_field()
        params = {
            'fl': '*,score',
            'mlt.fl': 'text,title',
            'mlt.qf': 'text^0.3 tags^2.0 title^1.0',
        }

        if start_offset is not None:
            params['start'] = start_offset

        if end_offset is not None:
            params['rows'] = end_offset

        narrow_queries = set()

        if limit_to_registered_models is None:
            limit_to_registered_models = getattr(settings, 'HAYSTACK_LIMIT_TO_REGISTERED_MODELS', True)

        if models and len(models):
            model_choices = sorted(['%s.%s' % (model._meta.app_label, model._meta.module_name) for model in models])
        elif limit_to_registered_models:
            # Using narrow queries, limit the results to only models handled
            # with the current routers.
            model_choices = self.build_models_list()
        else:
            model_choices = []

        if len(model_choices) > 0:
            if narrow_queries is None:
                narrow_queries = set()

            narrow_queries.add('%s:(%s)' % (DJANGO_CT, ' OR '.join(model_choices)))

        if additional_query_string:
            narrow_queries.add(additional_query_string)

        if narrow_queries:
            params['fq'] = list(narrow_queries)

        query = "%s:%s" % (ID, get_identifier(model_instance))

        try:
            raw_results = self.conn.more_like_this(query, field_name, **params)
        except (IOError, SolrError) as e:
            if not self.silently_fail:
                raise

            self.log.error("Failed to fetch More Like This from Solr for document '%s': %s", query, e)
            raw_results = EmptyResults()

        return self._process_results(raw_results, result_class=result_class)


haystack.backends.solr_backend.SolrEngine.query = CustomSolrSearchQuery
haystack.backends.solr_backend.SolrEngine.backend = CustomSolrSearchBackend

import haystack.views
from haystack.views import search_view_factory, FacetedSearchView
from haystack.forms import FacetedSearchForm, SearchForm


class GlobalSearchForm(FacetedSearchForm):
    def no_query_found(self):
        sqs = super(GlobalSearchForm, self).no_query_found()
        if self.selected_facets:
            sqs = self.searchqueryset.all()
            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


class SearchView(FacetedSearchView):
    def extra_context(self):
        context = super(SearchView, self).extra_context()
        context['sectionName'] = 'Search'
        context['selected_categories'] = [
                x.split(':', 1)[1] for x in self.request.GET.getlist('selected_facets')
                if x.startswith('categories_exact')]
        context['selected_tags'] = [
                x.split(':', 1)[1] for x in self.request.GET.getlist('selected_facets')
                if x.startswith('tags_exact')]
        context['facets']['fields']['categories'] = [x for x in
                context['facets']['fields']['categories'] if x[1] > 0]
        context['facets']['fields']['categories'].sort()
        context['facets']['fields']['tags'] = [x for x in
                context['facets']['fields']['tags'] if x[1] > 0]
        return context

sqs = SearchQuerySet().models(Emission, Episode, NewsItem).facet('categories').facet('tags')

view = search_view_factory(SearchView,
        form_class=GlobalSearchForm,
        searchqueryset=sqs)



class ListenArchivesForm(FacetedSearchForm):
    q = forms.CharField(required=False, label=_('Search Sounds'))

    def no_query_found(self):
        return self.searchqueryset.all()

    def search(self):
        sqs = super(ListenArchivesForm, self).search()
        return sqs.load_all()


class ListenArchivesView(FacetedSearchView):
    template = 'listen/archives.html'

    def __init__(self):
        sqs = RelatedSearchQuerySet().models(SoundFile).facet('categories').facet('tags').order_by('-date')
        super(ListenArchivesView, self).__init__(searchqueryset=sqs,
                form_class=ListenArchivesForm, results_per_page=20)

    def extra_context(self):
        context = super(ListenArchivesView, self).extra_context()
        context['sectionName'] = "Listen"
        context['selected_categories'] = [
                x.split(':', 1)[1] for x in self.request.GET.getlist('selected_facets')
                if x.startswith('categories_exact')]
        context['selected_tags'] = [
                x.split(':', 1)[1] for x in self.request.GET.getlist('selected_facets')
                if x.startswith('tags_exact')]
        context['facets']['fields']['categories'] = [x for x in
                context['facets']['fields']['categories'] if x[1] > 0]
        context['facets']['fields']['categories'].sort()
        context['facets']['fields']['tags'] = [x for x in
                context['facets']['fields']['tags'] if x[1] > 0]
        return context

listenArchives = search_view_factory(ListenArchivesView)


class NewsArchivesForm(FacetedSearchForm):
    q = forms.CharField(required=False, label=_('Search News'))

    def no_query_found(self):
        return self.searchqueryset.all()

    def search(self):
        sqs = super(NewsArchivesForm, self).search()
        return sqs.load_all()


class NewsArchivesView(FacetedSearchView):
    template = 'news/archives.html'

    def __init__(self):
        sqs = RelatedSearchQuerySet().models(NewsItem).facet('news_categories').facet('tags').order_by('-date')
        super(NewsArchivesView, self).__init__(searchqueryset=sqs,
                form_class=NewsArchivesForm, results_per_page=20)

    def extra_context(self):
        context = super(NewsArchivesView, self).extra_context()
        context['sectionName'] = 'News'
        context['selected_news_categories'] = [
                x.split(':', 1)[1] for x in self.request.GET.getlist('selected_facets')
                if x.startswith('news_categories_exact')]
        context['selected_tags'] = [
                x.split(':', 1)[1] for x in self.request.GET.getlist('selected_facets')
                if x.startswith('tags_exact')]
        context['facets']['fields']['news_categories'] = [x for x in
                context['facets']['fields']['news_categories'] if x[1] > 0]
        context['facets']['fields']['news_categories'].sort()
        context['facets']['fields']['tags'] = [x for x in
                context['facets']['fields']['tags'] if x[1] > 0]
        return context

newsArchives = search_view_factory(NewsArchivesView)