eea.facetednavigation 16.5__py3-none-any.whl

eea/facetednavigation/README.txt

@@ -0,0 +1,34 @@
+Overview
+========
+Faceted navigation is a revolutionary plone package that redefines search
+and navigation within plone sites.
+
+  * See more: http://plone.org/products/eea.facetednavigation
+
+
+Installation
+============
+  * Go to "admin > Site Setup > Add-ons"
+  * Activate "EEA Faceted Navigation"
+  * Go to "admin > Site Setup > Content Types"
+  * Select one content type and go to "Behaviors"
+  * Enable "Faceted navigable" behavior
+
+
+Extra
+=====
+You can extend faceted navigation functionality by installing the following
+addons:
+
+  * Cache (memcache)
+      - plone.memoize
+      - eea.cache
+
+Documentation
+=============
+  See the **docs** directory in this package.
+
+
+Authors
+=======
+  "European Environment Agency", mailto:webadmin@eea europa eu

eea/facetednavigation/__init__.py

@@ -0,0 +1,10 @@
+""" Main product initializer
+"""
+from zope.i18nmessageid.message import MessageFactory
+
+
+_ = MessageFactory("eea")
+
+
+def initialize(context):
+    """Initializer called when used as a Zope 2 product."""

eea/facetednavigation/browser/__init__.py

@@ -0,0 +1,2 @@
+""" Browser
+"""

eea/facetednavigation/browser/app/__init__.py

@@ -0,0 +1,2 @@
+""" Browser APP
+"""

eea/facetednavigation/browser/app/catalog.py

@@ -0,0 +1,43 @@
+""" Faceted catalog views
+"""
+import json
+import logging
+from Products.CMFCore.utils import getToolByName
+from Products.Five.browser import BrowserView
+from eea.facetednavigation.caching import ramcache
+
+logger = logging.getLogger("eea.facetednavigation")
+
+
+def cacheKey(method, self, *args, **kwargs):
+    """Generate unique cache id for faceted catalog indexes types"""
+    form = getattr(self.request, "form", {})
+    return form
+
+
+class FacetedCatalog(BrowserView):
+    """Render an error message when something is wrong with widgets"""
+
+    def types(self, **kwargs):
+        """Return a mapping between catalog indexes and types"""
+        ctool = getToolByName(self.context, "portal_catalog")
+        indexes = ctool.getIndexObjects()
+        res = {}
+        for index in indexes:
+            operator = "operator" in getattr(index, "query_options", [])
+            res[index.getId()] = {
+                "metatype": index.meta_type,
+                "operator": operator and ["or", "and"] or ["or"],
+            }
+        return res
+
+    @ramcache(cacheKey, dependencies=["eea.facetednavigation"])
+    def json_types(self, **kwargs):
+        """Return catalog indexes, types mapping as json object"""
+        if self.request:
+            kwargs.update(self.request.form)
+            self.request.response.setHeader(
+                "Content-Type", "application/json; charset=utf-8"
+            )
+
+        return json.dumps(self.types(**kwargs))

eea/facetednavigation/browser/app/configure.py

@@ -0,0 +1,307 @@
+""" Faceted configure
+"""
+from eea.facetednavigation import _
+from eea.facetednavigation.browser import interfaces
+from eea.facetednavigation.events import FacetedGlobalSettingsChangedEvent
+from eea.facetednavigation.events import FacetedSettingsWillBeChangedEvent
+from eea.facetednavigation.interfaces import ICriteria
+from eea.facetednavigation.interfaces import IWidgetsInfo
+from plone.protect.interfaces import IDisableCSRFProtection
+from Products.Five.browser import BrowserView
+from Products.statusmessages.interfaces import IStatusMessage
+from zope.component import getMultiAdapter
+from zope.component import getUtility
+from zope.event import notify
+from zope.interface import alsoProvides
+from zope.interface import implementer
+from zope.schema.interfaces import IVocabularyFactory
+
+import logging
+
+
+logger = logging.getLogger("eea.facetednavigation")
+#
+# Controllers
+#
+
+
+class FacetedBasicHandler(BrowserView):
+    """Define common methods for criteria handlers"""
+
+    def __init__(self, context, request=None):
+        self.context = context
+        self.request = request or getattr(context, "request", None)
+        self.redirect = context.absolute_url() + "/configure_faceted.html"
+
+    def _redirect(self, msg="", to=""):
+        """Return or redirect"""
+        if not to:
+            return msg
+
+        if not self.request:
+            return msg
+
+        if msg:
+            IStatusMessage(self.request).addStatusMessage(str(msg), type="info")
+        self.request.response.redirect(to)
+        return msg
+
+
+@implementer(interfaces.IFacetedCriteriaHandler)
+class FacetedCriteriaHandler(FacetedBasicHandler):
+    """Edit criteria"""
+
+    def add(self, **kwargs):
+        """See IFacetedCriteriaHandler"""
+        wid = kwargs.pop("wtype", None)
+        position = kwargs.pop("wposition", "right")
+        section = kwargs.pop("wsection", "default")
+        try:
+            ICriteria(self.context).add(wid, position, section)
+        except NameError as err:
+            msg = err
+        else:
+            msg = _("Filter added")
+        return self._redirect(msg=msg, to=self.redirect)
+
+    def edit(self, **kwargs):
+        """See IFacetedCriteriaHandler"""
+        criteria = ICriteria(self.context)
+        handler = getMultiAdapter(
+            (self.context, self.request), name="faceted_update_criterion"
+        )
+        for cid in criteria.keys():
+            properties = {}
+            for key, value in kwargs.items():
+                if not key.startswith(cid):
+                    continue
+                key = key[len(cid) + 1 :]
+                properties[key] = value
+            handler.edit(cid, **properties)
+        return self._redirect("Changes saved", to=self.redirect)
+
+    def delete(self, **kwargs):
+        """See IFacetedCriteriaHandler"""
+        to_delete = kwargs.get("paths", kwargs.get("ids", ()))
+        handler = getMultiAdapter(
+            (self.context, self.request), name="faceted_update_criterion"
+        )
+        for cid in to_delete:
+            handler.delete(cid)
+        return self._redirect(_("Filters deleted"), to=self.redirect)
+
+
+@implementer(interfaces.IFacetedCriterionHandler)
+class FacetedCriterionHandler(FacetedBasicHandler):
+    """Edit criterion"""
+
+    def extractData(self, widget, **kwargs):
+        """Extract form"""
+        widget.update()
+        form, _errors = widget.extractData()
+        form.update(kwargs)
+        return form
+
+    def add(self, **kwargs):
+        """See IFacetedCriterionHandler"""
+        wid = kwargs.pop("wtype", self.request.get("wtype", None))
+        position = kwargs.pop("wposition", self.request.get("wposition", "right"))
+        section = kwargs.pop("wsection", self.request.get("wsection", "default"))
+
+        criteria = ICriteria(self.context)
+        cid = criteria.add(wid, position, section)
+        return self.edit(cid, __new__=True, **kwargs)
+
+    def edit(self, cid, **kwargs):
+        """See IFacetedCriterionHandler"""
+        criteria = ICriteria(self.context)
+        widget = criteria.widget(cid=cid)
+        criterion = criteria.get(cid)
+        if kwargs.pop("__new__", False):
+            criterion = criterion.__class__(cid="c0")
+        widget = widget(self.context, self.request, criterion)
+
+        wid = kwargs.pop("widget", None)
+        properties = self.extractData(widget, **kwargs)
+        if wid:
+            properties["widget"] = wid
+
+        update = {}
+        for prop, value in properties.items():
+            form_key = "faceted.%s.%s" % (cid, prop)
+            if form_key not in kwargs and value is None:
+                continue
+            update[prop] = value
+
+        if update:
+            criteria.edit(cid, **update)
+            if widget.hidden:
+                notify(FacetedGlobalSettingsChangedEvent(self.context))
+            elif set(["hidden", "operator"]).intersection(list(update.keys())):
+                notify(FacetedGlobalSettingsChangedEvent(self.context))
+
+        return self._redirect("Changes saved")
+
+    def delete(self, cid, **kwargs):
+        """See IFacetedCriterionHandler"""
+        try:
+            ICriteria(self.context).delete(cid)
+        except (TypeError, KeyError) as err:
+            msg = err
+        else:
+            msg = _("Filter deleted")
+        return self._redirect(msg=msg)
+
+
+@implementer(interfaces.IFacetedPositionHandler)
+class FacetedPositionHandler(FacetedBasicHandler):
+    """Edit criteria position"""
+
+    def update(self, **kwargs):
+        """Update position by given slots"""
+        logger.debug(kwargs)
+        ICriteria(self.context).position(**kwargs)
+        return self._redirect("Position changed")
+
+    def move_up(self, cid, **kwargs):
+        """Move criterion up"""
+        ICriteria(self.context).up(cid)
+        return self._redirect("Position changed", to=self.redirect)
+
+    def move_down(self, cid, **kwargs):
+        """Move criterion down"""
+        ICriteria(self.context).down(cid)
+        return self._redirect("Position changed", to=self.redirect)
+
+
+@implementer(interfaces.IFacetedFormHandler)
+class FacetedFormHandler(FacetedBasicHandler):
+    """Edit criteria using a static form"""
+
+    def __init__(self, context, request):
+        super(FacetedFormHandler, self).__init__(context, request)
+        # XXX Quick fix until we figure out how to enable CSRF Protection
+        alsoProvides(request, IDisableCSRFProtection)
+
+    def __call__(self, **kwargs):
+        """This method is called from a form with more than one submit buttons"""
+        sanitized_form = {}
+        for key, value in getattr(self.request, "form", {}).items():
+            key = key.replace("[]", "")
+            if isinstance(value, bytes):
+                value = value.decode("utf-8")
+            sanitized_form[key] = value
+
+        if sanitized_form:
+            self.request.form = sanitized_form
+            kwargs.update(sanitized_form)
+
+        notify(FacetedSettingsWillBeChangedEvent(self.context))
+        #
+        # Criteria
+        #
+        handler = getMultiAdapter(
+            (self.context, self.request), name="faceted_update_criteria"
+        )
+
+        # Add button clicked
+        if kwargs.get("addWidget_button", None):
+            return handler.add(**kwargs)
+
+        # Delete button clicked
+        if kwargs.get("deleteWidgets_button", None):
+            return handler.delete(**kwargs)
+
+        # Save button clicked
+        if kwargs.get("saveChanges_button", None):
+            return handler.edit(**kwargs)
+        #
+        # Criterion
+        #
+        handler = getMultiAdapter(
+            (self.context, self.request), name="faceted_update_criterion"
+        )
+        # Add button clicked
+        if kwargs.pop("addPropertiesWidget_button", None):
+            return handler.add(**kwargs)
+
+        # Delete button clicked
+        if kwargs.pop("deleteWidget_button", None):
+            cid = kwargs.pop("path", kwargs.pop("cid", ""))
+            return handler.delete(cid=cid, **kwargs)
+
+        # Save button clicked
+        if kwargs.pop("updateCriterion_button", None):
+            return handler.edit(**kwargs)
+        #
+        # Position
+        #
+        handler = getMultiAdapter(
+            (self.context, self.request), name="faceted_update_position"
+        )
+
+        # Update position
+        if kwargs.get("updatePosition_button", None):
+            return handler.update(**kwargs)
+
+        # Move up button clicked
+        move_up = [k for k in kwargs if k.startswith("moveUp_button")]
+        if move_up:
+            cid = move_up[0].split("+++")[1]
+            return handler.move_up(cid)
+
+        # Move down button clicked
+        move_down = [k for k in kwargs if k.startswith("moveDown_button")]
+        if move_down:
+            cid = move_down[0].split("+++")[1]
+            return handler.move_down(cid)
+
+        # Return
+        self._redirect("Nothing changed", to=self.redirect)
+
+
+# View
+#
+class FacetedConfigureView(object):
+    """Faceted configure"""
+
+    def __init__(self, context, request):
+        self.context = context
+        self.request = request
+
+    @property
+    def positions(self):
+        """Possible positions"""
+        voc = getUtility(IVocabularyFactory, "eea.faceted.vocabularies.WidgetPositions")
+        return voc(self.context)
+
+    @property
+    def sections(self):
+        """Possible sections"""
+        voc = getUtility(IVocabularyFactory, "eea.faceted.vocabularies.WidgetSections")
+        return voc(self.context)
+
+    def get_widget(self, wid):
+        """Get widget by given widget id"""
+        return ICriteria(self.context).widget(wid)
+
+    def get_widget_types(self):
+        """Widget types"""
+        info = getUtility(IWidgetsInfo)
+        res = [x for x in info.widgets.values()]
+
+        def compare(x):
+            """Compare"""
+            return x.widget_label
+
+        res.sort(key=compare)
+        return res
+
+    def get_schema(self, criterion):
+        """Get edit schema"""
+        schema = getMultiAdapter((self.context, self.request), name="faceted_schema")
+        return schema(criterion=criterion.getId())
+
+    def get_criteria(self):
+        """Get criteria"""
+        return list(ICriteria(self.context).values())

eea/facetednavigation/browser/app/counter.py

@@ -0,0 +1,77 @@
+""" Counter
+"""
+import logging
+import time
+import json
+
+from zope.component import getMultiAdapter
+from eea.facetednavigation.caching import ramcache
+from eea.facetednavigation.caching import cacheCounterKeyFacetedNavigation
+from eea.facetednavigation.interfaces import ICriteria
+
+logger = logging.getLogger("eea.facetednavigation")
+
+
+class FacetedQueryCounter(object):
+    """Count results per query"""
+
+    def __init__(self, context, request):
+        self.context = context
+        self.request = request
+
+    def query(self, cid, **kwargs):
+        """Count catalog items"""
+        # Cleanup query
+        kwargs.pop("sort_on", None)
+        kwargs.pop("sort_order", None)
+        kwargs.pop("sort[]", None)
+        kwargs.pop("sort", None)
+        kwargs.pop("reversed[]", None)
+        oid = "%s-operator" % cid
+        operator = kwargs.pop(oid, kwargs.pop(oid + "[]", None))
+
+        if not operator or operator != "and":
+            kwargs.pop(cid, None)
+            self.request.form.pop(cid, 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.pop(cid + "[]", None)
+            self.request.form.pop(cid + "[]", None)
+
+        criteria = ICriteria(self.context)
+        criterion = criteria.get(cid)
+
+        start = time.time()
+        # Query catalog
+        handler = getMultiAdapter((self.context, self.request), name="faceted_query")
+
+        if criterion.get("index", "") == "Language":
+            kwargs["_language_count_"] = True
+        kwargs["counter_query"] = True
+        brains = handler.query(batch=False, sort=False, **kwargs)
+
+        # Get index
+        widget = criteria.widget(cid=cid)(self.context, self.request, criterion)
+        count = getattr(widget, "count", lambda brains: {})
+        res = count(brains)
+        logger.debug("Benchmark %s: %s", cid, time.time() - start)
+        return res
+
+    @ramcache(cacheCounterKeyFacetedNavigation, dependencies=["eea.facetednavigation"])
+    def __call__(self, *args, **kwargs):
+        # Calling self.index() will set cache headers for varnish
+        self.index()
+
+        if self.request:
+            kwargs.update(self.request.form)
+            self.request.response.setHeader(
+                "Content-Type", "application/json; charset=utf-8"
+            )
+
+        cid = kwargs.pop("cid", None)
+        if not cid:
+            return {}
+
+        res = self.query(cid, **kwargs)
+        return json.dumps(res)

eea/facetednavigation/browser/app/error.py

@@ -0,0 +1,28 @@
+""" Errors
+"""
+import logging
+from pprint import pformat
+from zope.component import queryAdapter
+from eea.facetednavigation.interfaces import ICriteria
+from Products.Five.browser import BrowserView
+
+logger = logging.getLogger("eea.facetednavigation")
+
+
+class FacetedError(BrowserView):
+    """Render an error message when something is wrong with widgets"""
+
+    def __call__(self, **kwargs):
+        error = kwargs.get("error", None)
+        res = {"type": getattr(error, "type", ""), "value": getattr(error, "value", "")}
+        cid = kwargs.get("cid", "")
+        msg = ""
+        if cid:
+            criteria = queryAdapter(self.context, ICriteria)
+            if criteria:
+                data = criteria.get(cid)
+                if data:
+                    msg = pformat(data.__dict__)
+
+        logger.exception("\n%s\n", msg)
+        return self.index(error=res)

eea/facetednavigation/browser/app/exportimport.py

@@ -0,0 +1,85 @@
+""" Export / Import faceted configuration
+"""
+from eea.facetednavigation import _
+from plone.protect.interfaces import IDisableCSRFProtection
+from Products.GenericSetup.context import SnapshotExportContext
+from Products.GenericSetup.context import SnapshotImportContext
+from Products.GenericSetup.interfaces import IBody
+from Products.statusmessages.interfaces import IStatusMessage
+from zope.component import queryMultiAdapter
+from zope.interface import alsoProvides
+
+
+class FacetedExportImport(object):
+    """Faceted view"""
+
+    def __init__(self, context, request):
+        self.context = context
+        self.request = request
+        # XXX Quick fix until we figure out how to enable CSRF Protection
+        alsoProvides(request, IDisableCSRFProtection)
+
+    def _redirect(self, msg="", to="configure_faceted.html"):
+        """Set status message and redirect"""
+        if not to:
+            return msg
+
+        if msg:
+            IStatusMessage(self.request).addStatusMessage(str(msg), type="info")
+        self.request.response.redirect(to)
+
+    def _import_xml(self, **kwargs):
+        """Import"""
+        upload_file = kwargs.get("import_file", None)
+        if getattr(upload_file, "read", None):
+            upload_file = upload_file.read()
+        xml = upload_file or b""
+        if not xml.startswith(b'<?xml version="1.0"'):
+            return _("Please provide a valid xml file")
+
+        environ = SnapshotImportContext(self.context, "utf-8")
+        importer = queryMultiAdapter((self.context, environ), IBody)
+        if not importer:
+            return "No adapter found"
+
+        try:
+            importer.body = xml
+        except Exception as err:
+            return "ERROR: %s" % err
+        else:
+            return _("Configuration imported")
+
+    def import_xml(self, **kwargs):
+        """Import config from xml"""
+        msg = self._import_xml(**kwargs)
+        return self._redirect(msg, kwargs.get("redirect", "configure_faceted.html"))
+
+    def _export_xml(self, **kwargs):
+        """Export"""
+        environ = SnapshotExportContext(self.context, "utf-8")
+        return queryMultiAdapter((self.context, environ), IBody)
+
+    def export_xml(self, **kwargs):
+        """Export config as xml"""
+        exporter = self._export_xml(**kwargs)
+        if not exporter:
+            return self._redirect(
+                "No adapter found", kwargs.get("redirect", "configure_faceted.html")
+            )
+
+        self.request.response.setHeader("content-type", "text/xml; charset=utf-8")
+        self.request.response.addHeader(
+            "content-disposition",
+            "attachment; filename=%s.xml" % (self.context.getId(),),
+        )
+        return exporter.body
+
+    def __call__(self, **kwargs):
+        """Export / Import configuration"""
+        if self.request:
+            kwargs.update(self.request.form)
+        if "import_button" in kwargs.keys():
+            return self.import_xml(**kwargs)
+        if "export_button" in kwargs.keys():
+            return self.export_xml(**kwargs)
+        self._redirect(_("No action provided"), "configure_faceted.html")