eea.facetednavigation 16.5__py3-none-any.whl

eea/facetednavigation/browser/app/query.py

@@ -0,0 +1,209 @@
+""" Faceted query
+"""
+from eea.facetednavigation.caching import cacheKeyFacetedNavigation
+from eea.facetednavigation.caching import ramcache
+from eea.facetednavigation.interfaces import ICriteria
+from eea.facetednavigation.interfaces import IEEASettings
+from eea.facetednavigation.interfaces import IFacetedCatalog
+from eea.facetednavigation.interfaces import IFacetedLayout
+from eea.facetednavigation.interfaces import IFacetedWrapper
+from eea.facetednavigation.interfaces import ILanguageWidgetAdapter
+from eea.facetednavigation.interfaces import IWidgetFilterBrains
+from plone.app.contentlisting.interfaces import IContentListing
+from plone.app.contenttypes.browser.folder import FolderView
+from plone.registry.interfaces import IRegistry
+from Products.CMFPlone.PloneBatch import Batch
+from Products.CMFPlone.utils import safeToInt
+from types import GeneratorType
+from zope.component import getUtility
+from zope.component import queryAdapter
+from zope.component import queryMultiAdapter
+
+import logging
+import time
+
+
+logger = logging.getLogger("eea.facetednavigation")
+
+
+class FacetedQueryHandler(FolderView):
+    """Faceted Query"""
+
+    def __init__(self, context, request):
+        super(FacetedQueryHandler, self).__init__(context, request)
+        if request.get("HTTP_X_REQUESTED_WITH", "") == "XMLHttpRequest":
+            registry = getUtility(IRegistry)
+            settings = registry.forInterface(IEEASettings, check=False)
+            if settings.disable_diazo_rules_ajax:
+                request.response.setHeader("X-Theme-Disabled", "1")
+
+    def macros(self, name="content-core"):
+        """Return macro from default layout"""
+        return IFacetedLayout(self.context).get_macro(macro=name)
+
+    @property
+    def language(self):
+        """Get context language"""
+        lang = getattr(self.context, "getLanguage", None)
+        if lang:
+            return lang()
+        return self.request.get("LANGUAGE", "")
+
+    @property
+    def default_criteria(self):
+        """Return default criteria"""
+        query = {}
+        criteria = queryAdapter(self.context, ICriteria)
+        for cid, criterion in criteria.items():
+            widget = criteria.widget(cid=cid)
+            widget = widget(self.context, self.request, criterion)
+            default = widget.default
+            if not default:
+                continue
+            query[cid] = default
+        return query
+
+    def get_context(self, content=None):
+        """Return context"""
+        wrapper = queryAdapter(self.context, IFacetedWrapper)
+        if not wrapper:
+            return self.context
+        return wrapper(content)
+
+    def criteria(self, sort=False, **kwargs):
+        """Process catalog query"""
+        if self.request:
+            kwargs.update(self.request.form)
+
+        # jQuery >= 1.4 adds type to params keys
+        # $.param({ a: [2,3,4] }) // "a[]=2&a[]=3&a[]=4"
+        # Let's fix this
+        kwargs = dict((key.replace("[]", ""), val) for key, val in kwargs.items())
+
+        logger.debug("REQUEST: %r", kwargs)
+
+        # Generate the catalog query
+        criteria = ICriteria(self.context)
+        query = {}
+        for cid, criterion in criteria.items():
+            widget = criteria.widget(cid=cid)
+            widget = widget(self.context, self.request, criterion)
+
+            widget_query = widget.query(kwargs)
+            if getattr(widget, "faceted_field", False):
+                widget_index = widget.data.get("index", "")
+                if "facet.field" in query and widget_index not in query["facet.field"]:
+                    query["facet.field"].append(widget_index)
+                else:
+                    query["facet.field"] = [widget_index]
+            query.update(widget_query)
+
+            # Handle language widgets
+            if criterion.get("index", "") == "Language":
+                language_widget = queryMultiAdapter(
+                    (widget, self.context), ILanguageWidgetAdapter
+                )
+                if not language_widget:
+                    continue
+                query.update(language_widget(kwargs))
+
+        # Add default sorting criteria
+        if sort and "sort_on" not in query:
+            query["sort_on"] = "effective"
+            query["sort_order"] = "reverse"
+
+        # Add default language.
+        # Also make sure to return language-independent content.
+        lang = self.language
+        if lang:
+            lang = [lang, ""]
+        query.setdefault("Language", lang)
+
+        logger.debug("QUERY: %s", query)
+        return query
+
+    def query(self, batch=True, sort=False, **kwargs):
+        """Search using given criteria"""
+        if self.request:
+            kwargs.update(self.request.form)
+            kwargs.pop("sort[]", None)
+            kwargs.pop("sort", None)
+
+        # jQuery >= 1.4 adds type to params keys
+        # $.param({ a: [2,3,4] }) // "a[]=2&a[]=3&a[]=4"
+        # Let's fix this
+        kwargs = dict((key.replace("[]", ""), val) for key, val in kwargs.items())
+
+        query = self.criteria(sort=sort, **kwargs)
+        # We don't want to do an unnecessary sort for a counter query
+        counter_query = kwargs.pop("counter_query", False)
+        if counter_query:
+            query.pop("sort_on", None)
+            query.pop("sort_order", None)
+
+        catalog = getUtility(IFacetedCatalog)
+        num_per_page = 20
+        criteria = ICriteria(self.context)
+        brains_filters = []
+        for cid, criterion in criteria.items():
+            widgetclass = criteria.widget(cid=cid)
+            widget = widgetclass(self.context, self.request, criterion)
+
+            if widget.widget_type == "resultsperpage":
+                num_per_page = widget.results_per_page(kwargs)
+
+            brains_filter = queryAdapter(widget, IWidgetFilterBrains)
+            if brains_filter:
+                brains_filters.append(brains_filter)
+
+        b_start = safeToInt(kwargs.get("b_start", 0))
+        # make sure orphans is an integer, // is used so in Python3 we have an
+        # integer division as by default, a division result is a float
+        orphans = num_per_page * 20 // 100  # orphans = 20% of items per page
+        if batch and not brains_filters:
+            # add b_start and b_size to query to use better sort algorithm
+            query["b_start"] = b_start
+            query["b_size"] = num_per_page + orphans
+
+        try:
+            brains = catalog(self.context, **query)
+        except Exception as err:
+            logger.exception(err)
+            return Batch([], 20, 0)
+        if not brains:
+            return Batch([], 20, 0)
+
+        # Apply after query (filter) on brains
+        start = time.time()
+        for brains_filter in brains_filters:
+            brains = brains_filter(brains, kwargs)
+
+        if not batch:
+            return brains
+
+        if isinstance(brains, GeneratorType):
+            brains = [brain for brain in brains]
+
+        delta = time.time() - start
+        if delta > 30:
+            logger.warn(
+                "Very slow IWidgetFilterBrains adapters: %s at %s",
+                brains_filters,
+                self.context.absolute_url(),
+            )
+        return Batch(brains, num_per_page, b_start, orphan=orphans)
+
+    def results(self, **kwargs):
+        """Faceted results"""
+        kwargs["batch"] = False
+        results = self.query(**kwargs)
+        if isinstance(results, GeneratorType):
+            results = [i for i in results]
+        results = IContentListing(results)
+        return results
+
+    @ramcache(cacheKeyFacetedNavigation, dependencies=["eea.facetednavigation"])
+    def __call__(self, *args, **kwargs):
+        self.brains = self.query(**kwargs)
+        html = self.index()
+        return html

eea/facetednavigation/browser/app/schema.py

@@ -0,0 +1,39 @@
+""" Schema
+"""
+from eea.facetednavigation.widgets.storage import Criterion
+from eea.facetednavigation.widgets.schema import Schema
+from eea.facetednavigation.interfaces import ICriteria
+
+
+class FacetedSchemaGetter(object):
+    """Faceted Query"""
+
+    def __init__(self, context, request):
+        self.context = context
+        self.request = request
+
+    def get_criterion(self, cid):
+        """Criterion"""
+        return ICriteria(self.context).get(cid)
+
+    def get_widget(self, wid):
+        """Widget"""
+        if not wid:
+            return None
+        return ICriteria(self.context).widget(wid=wid)
+
+    def __call__(self, **kwargs):
+        kwargs.update(self.request.form)
+        criterion_id = kwargs.get("criterion", "").split("_")[0]
+
+        criterion = self.get_criterion(criterion_id)
+        # Not added yet use an empty one
+        if not criterion:
+            criterion = Criterion()
+
+        widget_id = kwargs.get("widget", criterion.get("widget", ""))
+        widget = self.get_widget(widget_id)
+        if not widget:
+            return ""
+
+        return Schema(self.context, self.request, widget, criterion)()

eea/facetednavigation/browser/app/view.py

@@ -0,0 +1,169 @@
+""" Faceted views
+"""
+from zope.component import getUtility
+from zope.component import queryAdapter
+from zope.schema.interfaces import IVocabularyFactory
+from eea.facetednavigation.interfaces import ICriteria
+from eea.facetednavigation.interfaces import IFacetedWrapper
+from eea.facetednavigation.interfaces import IHidePloneLeftColumn
+from eea.facetednavigation.interfaces import IHidePloneRightColumn
+from eea.facetednavigation.interfaces import IDisableSmartFacets
+from eea.facetednavigation.interfaces import IFacetedSearchMode
+from Products.Five.browser import BrowserView
+
+
+class FacetedContainerView(object):
+    """Faceted view"""
+
+    def __init__(self, context, request):
+        self.context = context
+        self.request = request
+
+    @property
+    def mode(self):
+        """Display mode"""
+        if IFacetedSearchMode.providedBy(self.context):
+            return "search"
+        return "view"
+
+    @property
+    def positions(self):
+        """Return available columns"""
+        voc = getUtility(IVocabularyFactory, "eea.faceted.vocabularies.WidgetPositions")
+        return voc(self.context)
+
+    @property
+    def hide_left_portlets(self):
+        """Disable plone portlets left column"""
+        return IHidePloneLeftColumn.providedBy(self.context)
+
+    @property
+    def hide_right_portlets(self):
+        """Disable plone portlets right column"""
+        return IHidePloneRightColumn.providedBy(self.context)
+
+    @property
+    def disable_smart_facets(self):
+        """Disable 'smart facets hiding'"""
+        return IDisableSmartFacets.providedBy(self.context)
+
+    def get_context(self, content=None):
+        """Return context"""
+        wrapper = queryAdapter(self.context, IFacetedWrapper)
+        if not wrapper:
+            return self.context
+        return wrapper(content)
+
+    def get_sections(self, position="", mode="view"):
+        """Get sections for given position or return all sections"""
+        voc = getUtility(IVocabularyFactory, "eea.faceted.vocabularies.WidgetSections")
+        voc = voc(self.context)
+        if not position or mode not in ("view", "search"):
+            return [t for t in voc]
+
+        widgets = self.get_view_widgets(position=position)
+        sections = [widget.data.get("section") for widget in widgets]
+        return [term for term in voc if term.value in sections]
+
+    def get_view_widgets(self, position="", section=""):
+        """Get not hidden widgets"""
+        widgets = self.get_widgets(position, section)
+        for widget in widgets:
+            if widget.hidden:
+                continue
+            widget.mode = "display"
+            yield widget
+
+    def get_widgets(self, position="", section=""):
+        """Get all widgets"""
+        criteria = ICriteria(self.context)
+        for criterion in criteria.values():
+            if position and criterion.get("position", "right") != position:
+                continue
+            if section and criterion.get("section", "default") != section:
+                continue
+            widget = criteria.widget(wid=criterion.get("widget"))
+            yield widget(self.context, self.request, criterion)
+
+    def check_display_criteria(self, faceted_html):
+        """Check criteria"""
+        if self.disable_smart_facets:
+            return True
+        return self.context.unrestrictedTraverse(
+            "@@faceted_display_criteria_checker"
+        ).check(faceted_html)
+
+    def has_left_widgets(self):
+        for widget in self.get_widgets(position="left"):
+            if widget.hidden:
+                continue
+            return True
+
+    def has_right_widgets(self):
+        for widget in self.get_widgets(position="right"):
+            if widget.hidden:
+                continue
+            return True
+
+    def left_col(self, mode):
+        """Show faceted left col"""
+        if mode == "edit":
+            return True
+        if not self.has_left_widgets():
+            return False
+        if not self.hide_left_portlets:
+            return False
+        return True
+
+    def right_col(self, mode):
+        """Show faceted right col"""
+        if mode == "edit":
+            return True
+        if not self.has_right_widgets():
+            return False
+        if not self.hide_right_portlets:
+            return False
+        return True
+
+    def left_col_grid(self, mode):
+        """Grid for left facets column"""
+        if self.left_col(mode):
+            return "col-lg-3"
+        return "col-lg-12"
+
+    def right_col_grid(self, mode):
+        """Return right column bootstrap grid col"""
+        if self.right_col(mode):
+            return "col-lg-3"
+        return "col-lg-12"
+
+    def center_col_grid(self, mode):
+        """Return center column bootstrap grid col"""
+        if self.left_col(mode) and self.right_col(mode):
+            return "col-lg-6"
+        if self.left_col(mode) or self.right_col(mode):
+            return "col-lg-9"
+        return "col-lg-12"
+
+
+class DisplayCriteriaCheckerView(BrowserView):
+    """This views checks if criteria are displayed on faceted navigation"""
+
+    def check(self, faceted_html):
+        """Check"""
+        if "pagination" in faceted_html:
+            return True
+        elif self.language_present():
+            return True
+        else:
+            return False
+
+    def language_present(self):
+        """Is there any widget for Language index?"""
+
+        criteria = ICriteria(self.context)
+        for criterion in criteria.values():
+            if criterion.get("index", None) == "Language":
+                if not criterion.hidden:
+                    return True
+        return False

eea/facetednavigation/browser/configure.zcml

@@ -0,0 +1,155 @@
+<configure
+    xmlns="http://namespaces.zope.org/zope"
+    xmlns:browser="http://namespaces.zope.org/browser"
+    xmlns:plone="http://namespaces.plone.org/plone"
+    i18n_domain="eea"
+    >
+
+  <browser:page
+      name="facetednavigation_view"
+      for="..interfaces.IFacetedNavigable"
+      class=".app.view.FacetedContainerView"
+      template="template/view.pt"
+      permission="zope2.View"
+      />
+
+  <browser:page
+      name="faceted_display_criteria_checker"
+      for="..interfaces.IFacetedNavigable"
+      class=".app.view.DisplayCriteriaCheckerView"
+      permission="zope2.View"
+      />
+
+  <browser:page
+      name="facetednavigation_simple_view"
+      for="..interfaces.IFacetedNavigable"
+      class=".app.view.FacetedContainerView"
+      template="template/simple_view.pt"
+      permission="zope2.View"
+      />
+
+  <browser:page
+      name="faceted_widgets"
+      for="..interfaces.IFacetedNavigable"
+      class=".app.view.FacetedContainerView"
+      template="template/widgets.pt"
+      permission="zope2.View"
+      />
+
+  <browser:page
+      name="faceted_widgets_macros"
+      for="..interfaces.IFacetedNavigable"
+      template="template/widgets.pt"
+      permission="zope2.View"
+      />
+
+  <browser:page
+      name="faceted_macros"
+      for="..interfaces.IFacetedNavigable"
+      template="template/macros.pt"
+      permission="zope2.View"
+      />
+
+  <browser:page
+      name="configure_faceted.html"
+      for="..interfaces.IFacetedNavigable"
+      class=".app.configure.FacetedConfigureView"
+      template="template/configure.pt"
+      permission="eea.faceted.configure"
+      />
+
+  <browser:page
+      name="faceted_configure"
+      for="..interfaces.IFacetedNavigable"
+      class=".app.configure.FacetedFormHandler"
+      allowed_interface=".interfaces.IFacetedFormHandler"
+      permission="eea.faceted.configure"
+      />
+
+  <browser:page
+      name="faceted_update_criteria"
+      for="..interfaces.IFacetedNavigable"
+      class=".app.configure.FacetedCriteriaHandler"
+      permission="eea.faceted.configure"
+      />
+
+  <browser:page
+      name="faceted_update_criterion"
+      for="..interfaces.IFacetedNavigable"
+      class=".app.configure.FacetedCriterionHandler"
+      permission="eea.faceted.configure"
+      />
+
+  <browser:page
+      name="faceted_update_position"
+      for="..interfaces.IFacetedNavigable"
+      class=".app.configure.FacetedPositionHandler"
+      permission="eea.faceted.configure"
+      />
+
+  <browser:page
+      name="faceted_query"
+      for="..interfaces.IFacetedNavigable"
+      class=".app.query.FacetedQueryHandler"
+      template="template/query.pt"
+      permission="zope2.View"
+      />
+
+  <browser:page
+      name="faceted_counter"
+      for="..interfaces.IFacetedNavigable"
+      class=".app.counter.FacetedQueryCounter"
+      template="template/counter.pt"
+      permission="zope2.View"
+      />
+
+  <browser:page
+      name="faceted_exportimport"
+      for="..interfaces.IFacetedNavigable"
+      class=".app.exportimport.FacetedExportImport"
+      permission="eea.faceted.configure"
+      />
+
+  <browser:page
+      name="faceted_schema"
+      for="..interfaces.IFacetedNavigable"
+      class=".app.schema.FacetedSchemaGetter"
+      permission="eea.faceted.configure"
+      />
+
+  <browser:page
+      name="default_widgets.xml"
+      for="..interfaces.IPossibleFacetedNavigable"
+      template="template/default.xml"
+      permission="eea.faceted.configure"
+      />
+
+  <browser:page
+      name="faceted.widget.error"
+      for="..interfaces.IFacetedNavigable"
+      class=".app.error.FacetedError"
+      template="template/error.pt"
+      permission="zope2.View"
+      />
+
+  <browser:page
+      name="faceted.catalog.types.json"
+      for="..interfaces.IFacetedNavigable"
+      class=".app.catalog.FacetedCatalog"
+      attribute="json_types"
+      permission="zope2.View"
+      />
+
+  <!-- BBB -->
+  <browser:resourceDirectory
+      name="facetednavigation"
+      directory="./static"
+      />
+
+  <plone:static
+      directory="static"
+      name="facetednavigation"
+      type="plone"
+      />
+
+</configure>

eea/facetednavigation/browser/interfaces.py

@@ -0,0 +1,52 @@
+""" Browser interfaces
+"""
+from zope.interface import Interface
+
+
+class IFacetedCriteriaHandler(Interface):
+    """Edit faceted criteria"""
+
+    def add():
+        """Add empty criterion"""
+
+    def edit():
+        """Update criteria properties"""
+
+    def delete(paths):
+        """Delete criteria by given paths (ids)"""
+
+    def __call__():
+        """Call handler with"""
+
+
+class IFacetedCriterionHandler(Interface):
+    """Edit faceted criterion in criteria"""
+
+    def add():
+        """Add a criterion with properties"""
+
+    def edit(cid):
+        """Edit criterion"""
+
+    def delete(cid):
+        """Delete criterion by given cid"""
+
+
+class IFacetedPositionHandler(Interface):
+    """Handle criteria positions"""
+
+    def update():
+        """Update position by given slots"""
+
+    def move_up():
+        """Move criterion up"""
+
+    def move_down():
+        """Move criterion down"""
+
+
+class IFacetedFormHandler(Interface):
+    """Handle criteria from a static form"""
+
+    def __call__():
+        """Run appropiate handler"""