| #!/usr/bin/env python |
| # -*- coding: UTF-8 -*- |
| |
| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # KIND, either express or implied. See the License for the |
| # specific language governing permissions and limitations |
| # under the License. |
| |
| r"""Bloodhound Search user interface.""" |
| import copy |
| from collections import defaultdict |
| |
| import pkg_resources |
| from bhsearch import BHSEARCH_CONFIG_SECTION |
| import re |
| |
| from trac.core import Component, implements, TracError |
| from genshi.builder import tag |
| from genshi import HTML |
| from trac.perm import IPermissionRequestor |
| from trac.search import shorten_result |
| from trac.config import OrderedExtensionsOption, ListOption, Option, BoolOption |
| from trac.util.presentation import Paginator |
| from trac.util.datefmt import format_datetime, user_time |
| from trac.web import IRequestHandler, IRequestFilter |
| from trac.util.translation import _ |
| from trac.util.html import find_element |
| from trac.web.chrome import (ITemplateProvider, |
| add_link, add_stylesheet, prevnext_nav, |
| web_context) |
| from bhsearch.api import (BloodhoundSearchApi, ISearchParticipant, SCORE, ASC, |
| DESC, IndexFields, SortInstruction) |
| from bhsearch.utils import get_global_env, using_multiproduct |
| from trac.wiki.formatter import extract_link |
| from multiproduct.env import ProductEnvironment |
| from multiproduct.web_ui import ProductModule |
| |
| SEARCH_PERMISSION = 'SEARCH_VIEW' |
| DEFAULT_RESULTS_PER_PAGE = 10 |
| SEARCH_URL = '/search' |
| BHSEARCH_URL = '/bhsearch' |
| SEARCH_URLS_RE = re.compile(r'/(?P<prefix>bh)?search(?P<suffix>.*)') |
| |
| |
| class RequestParameters(object): |
| """ |
| Helper class for parameter parsing and creation of bhsearch specific URLs. |
| |
| Lifecycle of the class must be per request |
| """ |
| QUERY = "q" |
| PAGE = "page" |
| TYPE = "type" |
| NO_QUICK_JUMP = "noquickjump" |
| PAGELEN = "pagelen" |
| FILTER_QUERY = "fq" |
| VIEW = "view" |
| SORT = "sort" |
| DEBUG = "debug" |
| PRODUCT = "product_prefix" |
| PRODUCT_ID = "productid" |
| |
| def __init__(self, req, href=None): |
| # pylint: disable=too-many-branches |
| self.req = req |
| self.href = href or req.href |
| |
| self.original_query = req.args.getfirst(self.QUERY) |
| if self.original_query is None: |
| self.query = "" |
| else: |
| self.query = self.original_query.strip() |
| |
| self.no_quick_jump = int(req.args.getfirst(self.NO_QUICK_JUMP, '0')) |
| |
| self.view = req.args.getfirst(self.VIEW) |
| self.filter_queries = req.args.getlist(self.FILTER_QUERY) |
| self.filter_queries = self._remove_possible_duplications( |
| self.filter_queries) |
| |
| self.sort_string = req.args.getfirst(self.SORT) |
| self.sort = self._parse_sort(self.sort_string) |
| |
| self.pagelen = int(req.args.getfirst( |
| RequestParameters.PAGELEN, |
| DEFAULT_RESULTS_PER_PAGE)) |
| self.page = int(req.args.getfirst(self.PAGE, '1')) |
| self.type = req.args.getfirst(self.TYPE) |
| |
| self.product = req.args.getfirst(self.PRODUCT) |
| self.debug = int(req.args.getfirst(self.DEBUG, '0')) |
| |
| self.params = { |
| RequestParameters.FILTER_QUERY: [] |
| } |
| |
| if self.original_query is not None: |
| self.params[self.QUERY] = self.original_query |
| if self.no_quick_jump > 0: |
| self.params[self.NO_QUICK_JUMP] = self.no_quick_jump |
| if self.view is not None: |
| self.params[self.VIEW] = self.view |
| if self.pagelen != DEFAULT_RESULTS_PER_PAGE: |
| self.params[self.PAGELEN] = self.pagelen |
| if self.page > 1: |
| self.params[self.PAGE] = self.page |
| if self.type: |
| self.params[self.TYPE] = self.type |
| if self.product is not None: |
| self.params[self.PRODUCT] = self.product |
| if self.filter_queries: |
| self.params[RequestParameters.FILTER_QUERY] = self.filter_queries |
| if self.sort_string: |
| self.params[RequestParameters.SORT] = self.sort_string |
| if self.debug: |
| self.params[RequestParameters.DEBUG] = self.debug |
| |
| def _parse_sort(self, sort_string): |
| if not sort_string: |
| return None |
| sort_terms = sort_string.split(",") |
| sort = [] |
| |
| for term in sort_terms: |
| term = term.strip() |
| if not term: |
| continue |
| term_parts = term.split() |
| parts_count = len(term_parts) |
| if parts_count == 1: |
| sort.append(SortInstruction(term_parts[0], ASC)) |
| elif parts_count == 2: |
| sort.append(SortInstruction(term_parts[0], term_parts[1])) |
| else: |
| raise TracError("Invalid sort term %s " % term) |
| |
| return sort if sort else None |
| |
| def _remove_possible_duplications(self, parameters_list): |
| seen = set() |
| return [parameter for parameter in parameters_list |
| if parameter not in seen and not seen.add(parameter)] |
| |
| def create_href( |
| self, |
| page=None, |
| type=None, |
| skip_type=False, |
| skip_page=False, |
| additional_filter=None, |
| force_filters=None, |
| view=None, |
| skip_view=False, |
| sort=None, |
| skip_sort=False, |
| query=None, |
| skip_query=False, |
| product=None, |
| skip_product=False, |
| ): |
| # pylint: disable=too-many-locals,too-many-branches |
| params = copy.deepcopy(self.params) |
| |
| if skip_sort: |
| self._delete_if_exists(params, self.SORT) |
| elif sort: |
| params[self.SORT] = self._create_sort_expression(sort) |
| |
| #noquickjump parameter should be always set to 1 for urls |
| params[self.NO_QUICK_JUMP] = 1 |
| |
| if skip_view: |
| self._delete_if_exists(params, self.VIEW) |
| elif view: |
| params[self.VIEW] = view |
| |
| if skip_page: |
| self._delete_if_exists(params, self.PAGE) |
| elif page: |
| params[self.PAGE] = page |
| |
| if skip_type: |
| self._delete_if_exists(params, self.TYPE) |
| elif type: |
| params[self.TYPE] = type |
| |
| if additional_filter and\ |
| additional_filter not in params[self.FILTER_QUERY]: |
| params[self.FILTER_QUERY].append(additional_filter) |
| elif force_filters is not None: |
| params[self.FILTER_QUERY] = force_filters |
| |
| if skip_query: |
| self._delete_if_exists(params, self.QUERY) |
| elif query is not None: |
| params[self.QUERY] = query |
| |
| if skip_product: |
| self._delete_if_exists(params, self.PRODUCT) |
| elif product is not None: |
| params[self.PRODUCT] = product |
| |
| return self.href.bhsearch(**params) |
| |
| def _create_sort_expression(self, sort): |
| """ |
| Accepts single sort instruction e.g. SortInstruction(field, ASC) or |
| list of sort instructions e.g. |
| [SortInstruction(field1, ASC), SortInstruction(field2, DESC)] |
| """ |
| if not sort: |
| return None |
| |
| if isinstance(sort, SortInstruction): |
| return sort.build_sort_expression() |
| |
| return ", ".join([item.build_sort_expression() for item in sort]) |
| |
| |
| def _delete_if_exists(self, params, name): |
| if name in params: |
| del params[name] |
| |
| |
| class BloodhoundSearchModule(Component): |
| """Main search page""" |
| implements(IPermissionRequestor, IRequestHandler, |
| ITemplateProvider, IRequestFilter |
| # IWikiSyntaxProvider #todo: implement later |
| ) |
| |
| search_participants = OrderedExtensionsOption( |
| 'bhsearch', |
| 'search_participants', |
| ISearchParticipant, |
| "TicketSearchParticipant, WikiSearchParticipant" |
| ) |
| |
| prefix = "all" |
| default_grid_fields = [ |
| IndexFields.PRODUCT, |
| IndexFields.ID, |
| IndexFields.TYPE, |
| IndexFields.TIME, |
| IndexFields.AUTHOR, |
| IndexFields.CONTENT, |
| ] |
| |
| default_facets = ListOption( |
| BHSEARCH_CONFIG_SECTION, |
| prefix + '_default_facets', |
| default=",".join([IndexFields.PRODUCT, IndexFields.TYPE]), |
| doc="""Default facets applied to search view of all resources""") |
| |
| default_view = Option( |
| BHSEARCH_CONFIG_SECTION, |
| prefix + '_default_view', |
| doc="""If true, show grid as default view for specific resource in |
| Bloodhound Search results""") |
| |
| all_grid_fields = ListOption( |
| BHSEARCH_CONFIG_SECTION, |
| prefix + '_default_grid_fields', |
| default=",".join(default_grid_fields), |
| doc="""Default fields for grid view for specific resource""") |
| |
| default_search = BoolOption( |
| BHSEARCH_CONFIG_SECTION, |
| 'is_default', |
| default=False, |
| doc="""Searching from quicksearch uses bhsearch.""") |
| |
| redirect_enabled = BoolOption( |
| BHSEARCH_CONFIG_SECTION, |
| 'enable_redirect', |
| default=False, |
| doc="""Redirect links pointing to trac search to bhsearch""") |
| |
| global_quicksearch = BoolOption( |
| BHSEARCH_CONFIG_SECTION, |
| 'global_quicksearch', |
| default=True, |
| doc="""Quicksearch searches all products, even when used |
| in product env.""") |
| |
| query_suggestions_enabled = BoolOption( |
| BHSEARCH_CONFIG_SECTION, |
| 'query_suggestions', |
| default=True, |
| doc="""Display query suggestions.""" |
| ) |
| |
| # IPermissionRequestor methods |
| def get_permission_actions(self): |
| return [SEARCH_PERMISSION] |
| |
| # IRequestHandler methods |
| def match_request(self, req): |
| return re.match('^%s' % BHSEARCH_URL, req.path_info) is not None |
| |
| def process_request(self, req): |
| req.perm.assert_permission(SEARCH_PERMISSION) |
| |
| if self._is_opensearch_request(req): |
| return ('opensearch.xml', {}, |
| 'application/opensearchdescription+xml') |
| |
| request_context = RequestContext( |
| self.env, |
| req, |
| self.search_participants, |
| self.default_view, |
| self.all_grid_fields, |
| self.default_facets, |
| self.global_quicksearch, |
| self.query_suggestions_enabled, |
| ) |
| |
| if request_context.requires_redirect: |
| req.redirect(request_context.parameters.create_href(), True) |
| |
| # compatibility with legacy search |
| req.search_query = request_context.parameters.query |
| |
| query_result = BloodhoundSearchApi(self.env).query( |
| request_context.parameters.query, |
| pagenum=request_context.page, |
| pagelen=request_context.pagelen, |
| sort=request_context.sort, |
| fields=request_context.fields, |
| facets=request_context.facets, |
| filter=request_context.query_filter, |
| highlight=True, |
| context=request_context, |
| ) |
| |
| request_context.process_results(query_result) |
| return self._return_data(req, request_context.data) |
| |
| def _is_opensearch_request(self, req): |
| return req.path_info == BHSEARCH_URL + '/opensearch' |
| |
| def _return_data(self, req, data): |
| add_stylesheet(req, 'common/css/search.css') |
| return 'bhsearch.html', data, None |
| |
| # ITemplateProvider methods |
| def get_htdocs_dirs(self): |
| # return [('bhsearch', |
| # pkg_resources.resource_filename(__name__, 'htdocs'))] |
| return [] |
| |
| def get_templates_dirs(self): |
| return [pkg_resources.resource_filename(__name__, 'templates')] |
| |
| # IRequestFilter methods |
| def pre_process_request(self, req, handler): |
| if SEARCH_URLS_RE.match(req.path_info): |
| if self.redirect_enabled: |
| return self |
| return handler |
| |
| def post_process_request(self, req, template, data, content_type): |
| if data is None: |
| return template, data, content_type |
| |
| if self.redirect_enabled: |
| data['search_handler'] = req.href.bhsearch() |
| elif req.path_info.startswith(SEARCH_URL): |
| data['search_handler'] = req.href.search() |
| elif self.default_search or req.path_info.startswith(BHSEARCH_URL): |
| data['search_handler'] = req.href.bhsearch() |
| else: |
| data['search_handler'] = req.href.search() |
| return template, data, content_type |
| |
| |
| class RequestContext(object): |
| DATA_ACTIVE_FILTER_QUERIES = 'active_filter_queries' |
| DATA_ACTIVE_PRODUCT = 'active_product' |
| DATA_ACTIVE_QUERY = 'active_query' |
| DATA_BREADCRUMBS_TEMPLATE = 'resourcepath_template' |
| DATA_HEADERS = "headers" |
| DATA_ALL_VIEWS = "all_views" |
| DATA_VIEW = "view" |
| DATA_VIEW_GRID = "grid" |
| DATA_FACET_COUNTS = 'facet_counts' |
| DATA_DEBUG = 'debug' |
| DATA_PAGE_HREF = 'page_href' |
| DATA_RESULTS = 'results' |
| DATA_PRODUCT_LIST = 'search_product_list' |
| DATA_QUERY = 'query' |
| DATA_QUICK_JUMP = "quickjump" |
| DATA_QUERY_SUGGESTION = 'query_suggestion' |
| DATA_SEARCH_EXTRAS = 'extra_search_fields' |
| |
| #bhsearch may support more pluggable views later |
| VIEWS_SUPPORTED = ( |
| (None, "Free text"), |
| (DATA_VIEW_GRID, "Grid"), |
| ) |
| |
| VIEWS_WITH_KNOWN_FIELDS = [DATA_VIEW_GRID] |
| OBLIGATORY_FIELDS_TO_SELECT = [IndexFields.ID, IndexFields.TYPE] |
| DEFAULT_SORT = [SortInstruction(SCORE, ASC), SortInstruction("time", DESC)] |
| |
| def __init__( |
| self, |
| env, |
| req, |
| search_participants, |
| default_view, |
| all_grid_fields, |
| default_facets, |
| global_quicksearch, |
| query_suggestions, |
| ): |
| self.env = env |
| self.req = req |
| self.requires_redirect = False |
| self._handle_multiproduct_parameters(req, global_quicksearch) |
| self.parameters = RequestParameters( |
| req, |
| href=get_global_env(self.env).href |
| ) |
| self.data = { |
| self.DATA_QUERY: self.parameters.query, |
| self.DATA_SEARCH_EXTRAS: [], |
| } |
| self.search_participants = search_participants |
| self.default_view = default_view |
| self.all_grid_fields = all_grid_fields |
| self.default_facets = default_facets |
| self.view = None |
| self.page = self.parameters.page |
| self.pagelen = self.parameters.pagelen |
| self.query_suggestions = query_suggestions |
| |
| if self.parameters.sort: |
| self.sort = self.parameters.sort |
| else: |
| self.sort = self.DEFAULT_SORT |
| |
| self.allowed_participants, self.sorted_participants = \ |
| self._get_allowed_participants(req) |
| |
| if self.parameters.type in self.allowed_participants: |
| self.active_type = self.parameters.type |
| self.active_participant = self.allowed_participants[ |
| self.active_type] |
| else: |
| self.active_type = None |
| self.active_participant = None |
| |
| self.active_product = self.parameters.product |
| |
| self._prepare_active_type() |
| self._prepare_hidden_search_fields() |
| self._prepare_quick_jump() |
| |
| # Compatibility with trac search |
| self._process_legacy_type_filters(req, search_participants) |
| if not req.path_info.startswith(BHSEARCH_URL): |
| self.requires_redirect = True |
| |
| self.fields = self._prepare_fields_and_view() |
| self.query_filter = self._prepare_query_filter() |
| self.facets = self._prepare_facets() |
| |
| def _handle_multiproduct_parameters(self, req, global_quicksearch): |
| if not using_multiproduct(self.env): |
| return |
| |
| if self.env.parent is not None: |
| if not global_quicksearch: |
| req.args[RequestParameters.PRODUCT] = \ |
| self.env.product.prefix |
| self.requires_redirect = True |
| |
| def _get_allowed_participants(self, req): |
| allowed_participants = {} |
| ordered_participants = [] |
| for participant in self.search_participants: |
| if participant.is_allowed(req): |
| allowed_participants[ |
| participant.get_participant_type()] = participant |
| ordered_participants.append(participant) |
| return allowed_participants, ordered_participants |
| |
| def _prepare_active_type(self): |
| active_type = self.parameters.type |
| if active_type and active_type not in self.allowed_participants: |
| raise TracError(_("Unsupported resource type: '%(name)s'", |
| name=active_type)) |
| |
| def _prepare_hidden_search_fields(self): |
| if self.active_type: |
| self.data[self.DATA_SEARCH_EXTRAS].append( |
| (RequestParameters.TYPE, self.active_type) |
| ) |
| |
| if self.parameters.product: |
| self.data[self.DATA_SEARCH_EXTRAS].append( |
| (RequestParameters.PRODUCT, self.parameters.product) |
| ) |
| |
| if self.parameters.view: |
| self.data[self.DATA_SEARCH_EXTRAS].append( |
| (RequestParameters.VIEW, self.parameters.view) |
| ) |
| if self.parameters.sort: |
| self.data[self.DATA_SEARCH_EXTRAS].append( |
| (RequestParameters.SORT, self.parameters.sort_string) |
| ) |
| for filter_query in self.parameters.filter_queries: |
| self.data[self.DATA_SEARCH_EXTRAS].append( |
| (RequestParameters.FILTER_QUERY, filter_query) |
| ) |
| |
| def _prepare_quick_jump(self): |
| if not self.parameters.query: |
| return |
| check_result = self._check_quickjump( |
| self.req, |
| self.parameters.query) |
| if check_result: |
| self.data[self.DATA_QUICK_JUMP] = check_result |
| |
| #the method below is "copy/paste" from trac search/web_ui.py |
| def _check_quickjump(self, req, kwd): |
| """Look for search shortcuts""" |
| # pylint: disable=maybe-no-member |
| noquickjump = int(req.args.get('noquickjump', '0')) |
| # Source quickjump FIXME: delegate to ISearchSource.search_quickjump |
| quickjump_href = None |
| if kwd[0] == '/': |
| quickjump_href = req.href.browser(kwd) |
| name = kwd |
| description = _('Browse repository path %(path)s', path=kwd) |
| else: |
| context = web_context(req, 'search') |
| link = find_element(extract_link(self.env, context, kwd), 'href') |
| if link is not None: |
| quickjump_href = link.attrib.get('href') |
| name = link.children |
| description = link.attrib.get('title', '') |
| if quickjump_href: |
| # Only automatically redirect to local quickjump links |
| base_path = req.base_path.replace('@', '%40') |
| redirect_href = quickjump_href.replace('@', '%40') |
| if not redirect_href.startswith(base_path or '/'): |
| noquickjump = True |
| if noquickjump: |
| return {'href': quickjump_href, 'name': tag.EM(name), |
| 'description': description} |
| else: |
| req.redirect(quickjump_href) |
| |
| def _prepare_fields_and_view(self): |
| self._add_views_selector() |
| self.view = self._get_view() |
| if self.view: |
| self.data[self.DATA_VIEW] = self.view |
| fields_to_select = None |
| if self.view in self.VIEWS_WITH_KNOWN_FIELDS: |
| if self.active_participant: |
| fields_in_view = self.active_participant.\ |
| get_default_view_fields(self.view) |
| elif self.view == self.DATA_VIEW_GRID: |
| fields_in_view = self.all_grid_fields |
| else: |
| raise TracError("Unsupported view: %s" % self.view) |
| self.data[self.DATA_HEADERS] = [self._create_headers_item(field) |
| for field in fields_in_view] |
| fields_to_select = self._add_obligatory_fields( |
| fields_in_view) |
| return fields_to_select |
| |
| def _add_views_selector(self): |
| active_view = self.parameters.view |
| |
| all_views = [] |
| for view, label in self.VIEWS_SUPPORTED: |
| all_views.append(dict( |
| label=_(label), |
| href=self.parameters.create_href( |
| view=view, skip_view=(view is None)), |
| is_active=(view == active_view) |
| )) |
| self.data[self.DATA_ALL_VIEWS] = all_views |
| |
| def _get_view(self): |
| view = self.parameters.view |
| if view is None: |
| if self.active_participant: |
| view = self.active_participant.get_default_view() |
| else: |
| view = self.default_view |
| if view is not None: |
| view = view.strip().lower() |
| if view == "": |
| view = None |
| return view |
| |
| def _add_obligatory_fields(self, fields_in_view): |
| fields_to_select = list(fields_in_view) |
| for obligatory_field in self.OBLIGATORY_FIELDS_TO_SELECT: |
| if obligatory_field is not fields_to_select: |
| fields_to_select.append(obligatory_field) |
| return fields_to_select |
| |
| def _create_headers_item(self, field): |
| current_sort_direction = self._get_current_sort_direction_for_field( |
| field) |
| href_sort_direction = DESC if current_sort_direction == ASC else ASC |
| return dict( |
| name=field, |
| href=self.parameters.create_href( |
| skip_page=True, |
| sort=SortInstruction(field, href_sort_direction) |
| ), |
| #TODO:add translated column label. Now it is really temporary |
| # workaround |
| label=field, |
| sort=current_sort_direction, |
| ) |
| |
| def _get_current_sort_direction_for_field(self, field): |
| if self.sort and len(self.sort) == 1: |
| single_sort = self.sort[0] |
| if single_sort.field == field: |
| return single_sort.order |
| return None |
| |
| def _prepare_query_filter(self): |
| query_filters = list(self.parameters.filter_queries) |
| if self.active_type: |
| query_filters.append( |
| self._create_term_expression( |
| IndexFields.TYPE, self.active_type)) |
| if self.active_product is not None: |
| query_filters.append(self._create_term_expression( |
| IndexFields.PRODUCT, self.active_product or None) |
| ) |
| return query_filters |
| |
| def _create_term_expression(self, field, field_value): |
| if field_value is None: |
| query = "NOT (%s:*)" % field |
| elif isinstance(field_value, basestring): |
| query = '%s:"%s"' % (field, field_value) |
| else: |
| query = '%s:%s' % (field, field_value) |
| return query |
| |
| def _prepare_facets(self): |
| #TODO: add possibility of specifying facets in query parameters |
| if self.active_participant: |
| facets = self.active_participant.get_default_facets() |
| else: |
| facets = self.default_facets |
| return facets |
| |
| def _process_legacy_type_filters(self, req, search_participants): |
| legacy_type_filters = [sp.get_participant_type() |
| for sp in search_participants |
| if sp.get_participant_type() in req.args] |
| if legacy_type_filters: |
| params = self.parameters.params |
| if len(legacy_type_filters) == 1: |
| self.parameters.type = params[RequestParameters.TYPE] = \ |
| legacy_type_filters[0] |
| else: |
| filter_queries = self.parameters.filter_queries |
| if params[RequestParameters.FILTER_QUERY] is not filter_queries: |
| params[RequestParameters.FILTER_QUERY] = filter_queries |
| filter_queries.append( |
| 'type:(%s)' % ' OR '.join(legacy_type_filters) |
| ) |
| self.requires_redirect = True |
| |
| def _process_doc(self, doc): |
| ui_doc = dict(doc) |
| if doc['product']: |
| product_href = ProductEnvironment(self.env, doc['product']).href |
| # pylint: disable=too-many-function-args |
| ui_doc["href"] = product_href(doc['type'], doc['id']) |
| else: |
| ui_doc["href"] = self.req.href(doc['type'], doc['id']) |
| |
| if doc['content']: |
| ui_doc['content'] = shorten_result(doc['content']) |
| |
| if doc['time']: |
| ui_doc['date'] = user_time(self.req, format_datetime, doc['time']) |
| |
| is_free_text_view = self.view is None |
| if is_free_text_view: |
| participant = self.allowed_participants[doc['type']] |
| ui_doc['title'] = participant.format_search_results(doc) |
| return ui_doc |
| |
| def _prepare_results(self, result_docs, hits): |
| ui_docs = [self._process_doc(doc) for doc in result_docs] |
| |
| results = Paginator( |
| ui_docs, |
| self.page - 1, |
| self.pagelen, |
| hits) |
| |
| self._prepare_shown_pages(results) |
| results.current_page = {'href': None, |
| 'class': 'current', |
| 'string': str(results.page + 1), |
| 'title': None} |
| |
| parameters = self.parameters |
| if results.has_next_page: |
| next_href = parameters.create_href(page=parameters.page + 1) |
| add_link(self.req, 'next', next_href, _('Next Page')) |
| |
| if results.has_previous_page: |
| prev_href = parameters.create_href(page=parameters.page - 1) |
| add_link(self.req, 'prev', prev_href, _('Previous Page')) |
| |
| self.data[self.DATA_RESULTS] = results |
| prevnext_nav(self.req, _('Previous'), _('Next')) |
| |
| def _prepare_shown_pages(self, results): |
| shown_pages = results.get_shown_pages(self.pagelen) |
| page_data = [] |
| for shown_page in shown_pages: |
| page_href = self.parameters.create_href(page=shown_page) |
| page_data.append([page_href, None, str(shown_page), |
| 'page ' + str(shown_page)]) |
| fields = ['href', 'class', 'string', 'title'] |
| results.shown_pages = [dict(zip(fields, p)) for p in page_data] |
| |
| def process_results(self, query_result): |
| docs = self._prepare_docs(query_result.docs, |
| query_result.highlighting) |
| self._prepare_results(docs, query_result.hits) |
| self._prepare_result_facet_counts(query_result.facets) |
| self._prepare_breadcrumbs() |
| self._prepare_query_suggestion(query_result.query_suggestion) |
| self.data[self.DATA_DEBUG] = query_result.debug |
| if self.parameters.debug: |
| self.data[self.DATA_DEBUG]['enabled'] = True |
| self.data[self.DATA_SEARCH_EXTRAS].append(('debug', '1')) |
| self.data[self.DATA_PAGE_HREF] = self.parameters.create_href() |
| |
| def _prepare_result_facet_counts(self, result_facets): |
| """ |
| Sample query_result.facets content returned by query |
| { |
| 'component': {None:2}, |
| 'milestone': {None:1, 'm1':1}, |
| } |
| |
| returned facet_count contains href parameters: |
| { |
| 'component': {None: {'count':2, href:'...'}, |
| 'milestone': { |
| None: {'count':1,, href:'...'}, |
| 'm1':{'count':1, href:'...'} |
| }, |
| } |
| |
| """ |
| facet_counts = [] |
| if result_facets: |
| for field in self.facets: |
| if field == IndexFields.PRODUCT and \ |
| not using_multiproduct(self.env): |
| continue |
| facets_dict = result_facets.get(field, {}) |
| per_field_dict = dict() |
| for field_value, count in facets_dict.iteritems(): |
| if field == IndexFields.TYPE: |
| href = self.parameters.create_href( |
| skip_page=True, |
| force_filters=[], |
| type=field_value) |
| elif field == IndexFields.PRODUCT: |
| href = self.parameters.create_href( |
| skip_page=True, |
| product=field_value or u'', |
| ) |
| else: |
| href = self.parameters.create_href( |
| skip_page=True, |
| additional_filter=self._create_term_expression( |
| field, |
| field_value) |
| ) |
| per_field_dict[field_value] = dict( |
| count=count, |
| href=href |
| ) |
| facet_counts.append((_(field), per_field_dict)) |
| |
| self.data[self.DATA_FACET_COUNTS] = facet_counts |
| |
| def _prepare_docs(self, docs, highlights): |
| new_docs = [] |
| for doc, highlight in zip(docs, highlights): |
| doc = defaultdict(str, doc) |
| for field in highlight.iterkeys(): |
| highlighted_field = 'hilited_%s' % field |
| if highlight[field]: |
| fragment = self._create_genshi_fragment(highlight[field]) |
| doc[highlighted_field] = fragment |
| else: |
| doc[highlighted_field] = '' |
| new_docs.append(doc) |
| return new_docs |
| |
| def _create_genshi_fragment(self, html_fragment): |
| return tag(HTML(html_fragment)) |
| |
| def _prepare_breadcrumbs(self): |
| self._prepare_breadcrumbs_template() |
| self._prepare_product_breadcrumb() |
| self._prepare_query_filter_breadcrumbs() |
| |
| def _prepare_breadcrumbs_template(self): |
| self.data[self.DATA_BREADCRUMBS_TEMPLATE] = 'bhsearch_breadcrumbs.html' |
| |
| def _prepare_product_breadcrumb(self): |
| if not using_multiproduct(self.env): |
| return |
| product_search = lambda x: self.parameters.create_href(product=x) |
| all_products_search = self.parameters.create_href(skip_product=True) |
| |
| global_product = [(u'', _(u'Global product'), product_search(u''))] |
| products = \ |
| ProductModule.get_product_list(self.env, self.req, product_search) |
| all_products = [(None, _(u'All products'), all_products_search)] |
| |
| search_product_list = global_product + products + all_products |
| |
| # pylint: disable=unused-variable |
| for prefix, name, url in search_product_list: |
| if prefix == self.active_product: |
| self.data[self.DATA_ACTIVE_PRODUCT] = name |
| break |
| else: |
| self.data[self.DATA_ACTIVE_PRODUCT] = self.active_product |
| self.data[self.DATA_PRODUCT_LIST] = search_product_list |
| |
| def _prepare_query_filter_breadcrumbs(self): |
| current_filters = self.parameters.filter_queries |
| |
| def remove_filter_from_list(filter_to_remove): |
| new_filters = list(current_filters) |
| new_filters.remove(filter_to_remove) |
| return new_filters |
| |
| if self.active_type: |
| type_query = self._create_term_expression('type', self.active_type) |
| type_filters = [dict( |
| href=self.parameters.create_href(skip_type=True, |
| force_filters=[]), |
| label=unicode(self.active_type).capitalize(), |
| query=type_query, |
| )] |
| else: |
| type_filters = [] |
| |
| active_filter_queries = [ |
| dict( |
| href=self.parameters.create_href( |
| force_filters=remove_filter_from_list(filter_query) |
| ), |
| label=filter_query, |
| query=filter_query, |
| ) for filter_query in self.parameters.filter_queries |
| ] |
| active_query = dict( |
| href=self.parameters.create_href(skip_query=True), |
| label=u'"%s"' % self.parameters.query, |
| query=self.parameters.query |
| ) |
| |
| self.data[self.DATA_ACTIVE_FILTER_QUERIES] = \ |
| type_filters + active_filter_queries |
| self.data[self.DATA_ACTIVE_QUERY] = active_query |
| |
| def _prepare_query_suggestion(self, suggestion): |
| if self.query_suggestions and suggestion is not None: |
| self.data[self.DATA_QUERY_SUGGESTION] = dict( |
| query=suggestion, |
| href=self.parameters.create_href(query=suggestion) |
| ) |
| else: |
| self.data[self.DATA_QUERY_SUGGESTION] = None |
