332 lines
14 KiB
Python
332 lines
14 KiB
Python
# combo - content management system
|
|
# Copyright (C) 2014-2017 Entr'ouvert
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify it
|
|
# under the terms of the GNU Affero General Public License as published
|
|
# by the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU Affero General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
from django import template
|
|
from django.contrib.auth.models import Group
|
|
from django.contrib.contenttypes import fields
|
|
from django.contrib.contenttypes.models import ContentType
|
|
from django.core.exceptions import PermissionDenied
|
|
from django.db import models
|
|
from django.db.models import JSONField
|
|
from django.http import HttpResponse, HttpResponseBadRequest
|
|
from django.shortcuts import get_object_or_404
|
|
from django.template import RequestContext, Template
|
|
from django.utils.functional import cached_property
|
|
from django.utils.http import quote
|
|
from django.utils.translation import gettext_lazy as _
|
|
|
|
from combo.data.library import register_cell_class
|
|
from combo.data.models import CellBase, Page
|
|
from combo.utils import get_templated_url, requests
|
|
|
|
from . import engines
|
|
|
|
|
|
def get_root_page_and_children(service_slug):
|
|
if not service_slug.startswith('_text_page_'):
|
|
return
|
|
page_slug = service_slug.replace('_text_page_', '')
|
|
try:
|
|
root_page = Page.objects.get(slug=page_slug, sub_slug='')
|
|
except (Page.DoesNotExist, Page.MultipleObjectsReturned):
|
|
return
|
|
return root_page.get_descendants_and_me()
|
|
|
|
|
|
@register_cell_class
|
|
class SearchCell(CellBase):
|
|
default_template_name = 'combo/search-cell.html'
|
|
manager_form_template = 'combo/manager/search-cell-form.html'
|
|
exclude_from_search = True
|
|
|
|
_search_services = JSONField(_('Search Services'), default=dict, blank=True)
|
|
title = models.CharField(_('Title'), max_length=150, blank=True)
|
|
autofocus = models.BooleanField(_('Autofocus'), default=False)
|
|
input_placeholder = models.CharField(_('Placeholder'), max_length=64, default="", blank=True)
|
|
|
|
class Meta:
|
|
verbose_name = _('Search')
|
|
|
|
def is_visible(self, request, **kwargs):
|
|
if not self._search_services.get('data'):
|
|
return False
|
|
return super().is_visible(request, **kwargs)
|
|
|
|
def get_default_form_class(self):
|
|
from .forms import SearchCellForm
|
|
|
|
return SearchCellForm
|
|
|
|
@property
|
|
def varname(self):
|
|
if self.slug:
|
|
# no hyphen in varname, could be used in context and templates
|
|
return self.slug.replace('-', '_')
|
|
return ''
|
|
|
|
@cached_property
|
|
def search_services(self):
|
|
services = []
|
|
for service_slug in self._search_services.get('data') or []:
|
|
service = engines.get(service_slug)
|
|
if service_slug.startswith('_text_page_'):
|
|
service = engines.get('_text')
|
|
if service_slug.startswith('cards:'):
|
|
parts = service_slug.split(':')
|
|
without_user = False
|
|
if parts[2].endswith('__without-user__'):
|
|
without_user = True
|
|
parts[2] = parts[2].replace('__without-user__', '')
|
|
if not service:
|
|
# retry with cleaned parts
|
|
service = engines.get(':'.join(parts[:3]))
|
|
if not service:
|
|
# still not found
|
|
continue
|
|
if len(parts) > 3:
|
|
custom_views_by_id = {c['id']: c['text'] for c in service.get('custom_views') or []}
|
|
service['label'] = '%s - %s' % (service['label'], custom_views_by_id.get(parts[3]))
|
|
service['selected_custom_view'] = parts[3]
|
|
if without_user:
|
|
service['without_user'] = True
|
|
service['label'] = '%s (%s)' % (service['label'], _('logged-in user ignored'))
|
|
if service and (service.get('url') or service.get('function')):
|
|
service['slug'] = service_slug
|
|
service['options'] = self._search_services.get('options', {}).get(service_slug)
|
|
services.append(service)
|
|
return services
|
|
|
|
@cached_property
|
|
def available_engines(self):
|
|
all_engines = engines.get_engines()
|
|
# always remove _text engine: we can add search on page and sub pages
|
|
current_engines = [
|
|
e['slug']
|
|
for e in self.search_services
|
|
if e['slug'] != '_text' and not e['slug'].startswith('cards:')
|
|
]
|
|
return {k: v for k, v in all_engines.items() if k not in current_engines}
|
|
|
|
def get_search_services_for_display(self):
|
|
# get pages for _text engines
|
|
page_slugs = [
|
|
e['slug'].replace('_text_page_', '')
|
|
for e in self.search_services
|
|
if e['slug'].startswith('_text_page_')
|
|
]
|
|
pages = Page.objects.filter(snapshot__isnull=True, sub_slug='', slug__in=page_slugs).values(
|
|
'slug', 'title'
|
|
)
|
|
pages_by_slug = {'_text_page_%s' % p['slug']: p['title'] for p in pages}
|
|
services = []
|
|
for service in self.search_services:
|
|
label = service['label']
|
|
if service['slug'] in pages_by_slug:
|
|
label = _('Page "%(page)s" and sub pages Contents') % {'page': pages_by_slug[service['slug']]}
|
|
services.append((service['slug'], label, service['options']))
|
|
return services
|
|
|
|
@property
|
|
def has_multiple_search_services(self):
|
|
return len(self._search_services.get('data') or []) > 1
|
|
|
|
@classmethod
|
|
def get_cells_by_search_service(cls, search_service):
|
|
for cell in cls.objects.all():
|
|
if search_service in (cell._search_services.get('data') or []):
|
|
yield cell
|
|
|
|
def get_serialized_cell(self):
|
|
serialized_cell = super().get_serialized_cell()
|
|
for options in (serialized_cell['fields']['_search_services'].get('options') or {}).values():
|
|
if options.get('target_page') not in ['', None]:
|
|
try:
|
|
target_page = Page.objects.get(pk=options['target_page'])
|
|
options['target_page'] = target_page.natural_key()[0]
|
|
except Page.DoesNotExist:
|
|
options['target_page'] = ''
|
|
return serialized_cell
|
|
|
|
@classmethod
|
|
def prepare_serialized_data(cls, cell_data):
|
|
if not cell_data['fields'].get('_search_services'):
|
|
return cell_data
|
|
if not cell_data['fields']['_search_services'].get('options'):
|
|
return cell_data
|
|
for options in cell_data['fields']['_search_services']['options'].values():
|
|
if options.get('target_page'):
|
|
options['target_page'] = Page.get_page_ids_by_uuids().get(options['target_page'])
|
|
return cell_data
|
|
|
|
def modify_global_context(self, context, request):
|
|
# if self.varname is in the query string (of the page),
|
|
# add it to the global context; so it can be used by others cells
|
|
# for example by a JsonCell with ...[self.varname]... in its URL
|
|
if self.varname and self.varname in request.GET:
|
|
context[self.varname] = request.GET.get(self.varname)
|
|
|
|
def get_cell_extra_context(self, context):
|
|
extra_context = super().get_cell_extra_context(context)
|
|
# if there is a q_<slug> in query_string, send it to the template (to be
|
|
# used as an initial query) and remove it from query_string
|
|
initial_q = None
|
|
initial_query_string = None
|
|
if context.get('request'):
|
|
request_get = context['request'].GET.copy()
|
|
if self.varname and context.get('request'):
|
|
q_varname = 'q_%s' % self.varname
|
|
if q_varname in request_get:
|
|
initial_q = request_get[q_varname]
|
|
del request_get[q_varname]
|
|
initial_query_string = request_get.urlencode()
|
|
extra_context.update({'initial_q': initial_q, 'initial_query_string': initial_query_string})
|
|
return extra_context
|
|
|
|
@classmethod
|
|
def ajax_results_view(cls, request, cell_pk, service_slug):
|
|
cell = get_object_or_404(cls, pk=cell_pk)
|
|
if not cell.is_visible(request) or not cell.page.is_visible(request.user):
|
|
raise PermissionDenied
|
|
|
|
if 'q' not in request.GET:
|
|
return HttpResponseBadRequest('missing query parameter')
|
|
|
|
query = request.GET.get('q')
|
|
if '\x00' in query: # nul byte
|
|
return HttpResponseBadRequest('invalid query string')
|
|
|
|
def render_response(service=None, results=None, pages=None):
|
|
service = service or {}
|
|
results = results or {'err': 0, 'data': []}
|
|
template_names = ['combo/search-cell-results.html']
|
|
if cell.slug:
|
|
template_names.insert(0, 'combo/cells/%s/search-cell-results.html' % cell.slug)
|
|
tmpl = template.loader.select_template(template_names)
|
|
service_label = service.get('label')
|
|
if pages:
|
|
service_label = _('Page "%(page)s" and sub pages Contents') % {'page': pages[0].title}
|
|
custom_title = None
|
|
try:
|
|
# optional label defined with engine
|
|
if service['options']['title']:
|
|
custom_title = service['options']['title']
|
|
except (KeyError, TypeError):
|
|
pass
|
|
context = {
|
|
'cell': cell,
|
|
'results': results,
|
|
'search_service': service,
|
|
'search_service_label': service_label,
|
|
'search_service_title': custom_title,
|
|
'query': query,
|
|
}
|
|
return HttpResponse(tmpl.render(context, request), content_type='text/html')
|
|
|
|
for service in cell.search_services:
|
|
if service.get('slug') == service_slug:
|
|
break
|
|
else:
|
|
return render_response()
|
|
|
|
if not query:
|
|
return render_response(service)
|
|
|
|
pages = None
|
|
if service.get('function'): # internal search engine
|
|
pages = get_root_page_and_children(service_slug)
|
|
try:
|
|
with_description = service['options']['with_description']
|
|
except (KeyError, TypeError):
|
|
with_description = None
|
|
results = {
|
|
'data': service['function'](request, query, pages=pages, with_description=with_description)
|
|
}
|
|
else:
|
|
url = get_templated_url(
|
|
service['url'], context={'request': request, 'q': query, 'search_service': service}
|
|
)
|
|
if '%(q)s' in url:
|
|
# escape percent signs by doubling them, then restore %(q)s
|
|
url = url.replace('%', '%%').replace('%%(q)s', '%(q)s')
|
|
url = url % {'q': quote(query.encode('utf-8'))}
|
|
if url.startswith('/'):
|
|
url = request.build_absolute_uri(url)
|
|
|
|
if not url:
|
|
return render_response(service)
|
|
|
|
kwargs = {}
|
|
kwargs['cache_duration'] = service.get('cache_duration', 0)
|
|
kwargs['remote_service'] = 'auto' if service.get('signature') else None
|
|
# don't automatically add user info to query string, if required it can
|
|
# be set explicitely in the URL template in the engine definition (via
|
|
# {{user_nameid}} or {{user_email}}).
|
|
kwargs['without_user'] = True
|
|
# don't send error traces on HTTP errors
|
|
kwargs['log_errors'] = 'warn'
|
|
|
|
response = requests.get(url, **kwargs)
|
|
try:
|
|
results = response.json()
|
|
except ValueError:
|
|
return render_response(service)
|
|
|
|
if service.get('data_key'):
|
|
results['data'] = results.get(service['data_key']) or []
|
|
hit_templates = {}
|
|
options = service.get('options') or {}
|
|
if options.get('target_page'):
|
|
try:
|
|
page = Page.objects.get(pk=options['target_page'])
|
|
page_base_url = page.get_online_url()
|
|
hit_templates['url'] = Template('%s{{ id }}/' % page_base_url)
|
|
except Page.DoesNotExist:
|
|
pass
|
|
if not hit_templates.get('url') and service.get('hit_url_template'):
|
|
hit_templates['url'] = Template(service['hit_url_template'])
|
|
if service.get('hit_label_template'):
|
|
hit_templates['text'] = Template(service['hit_label_template'])
|
|
if options.get('description_template'):
|
|
hit_templates['description'] = Template(service['options']['description_template'])
|
|
if not hit_templates.get('description') and service.get('hit_description_template'):
|
|
hit_templates['description'] = Template(service['hit_description_template'])
|
|
if hit_templates:
|
|
for hit in results.get('data') or []:
|
|
for k, v in hit_templates.items():
|
|
hit[k] = v.render(RequestContext(request, hit))
|
|
|
|
return render_response(service, results, pages=pages)
|
|
|
|
def has_text_search_service(self):
|
|
return any(key.startswith('_text') for key in self._search_services.get('data', []))
|
|
|
|
def missing_index(self):
|
|
return IndexedCell.objects.all().count() == 0
|
|
|
|
|
|
class IndexedCell(models.Model):
|
|
cell_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
|
|
cell_pk = models.PositiveIntegerField(null=True)
|
|
cell = fields.GenericForeignKey('cell_type', 'cell_pk')
|
|
page = models.ForeignKey(Page, on_delete=models.CASCADE, blank=True, null=True)
|
|
url = models.CharField(max_length=5000, blank=True, null=True)
|
|
title = models.CharField(max_length=500, blank=True, null=True)
|
|
indexed_text = models.TextField(blank=True, null=True)
|
|
public_access = models.BooleanField(default=False)
|
|
restricted_groups = models.ManyToManyField(Group, blank=True, related_name='+')
|
|
excluded_groups = models.ManyToManyField(Group, blank=True, related_name='+')
|
|
last_update_timestamp = models.DateTimeField(auto_now=True)
|