The facets system
-----------------
XXX feed me more (below is the extracted of adim blog)


Recently, for internal purposes, we've made a little cubicweb application to
help us
organizing visits to find new office locations. Here's an *excerpt* of the
schema:

.. sourcecode:: python

  class Office(WorkflowableEntityType):
      price = Int(description='euros / m2 / HC / HT')
      surface = Int(description='m2')
      description = RichString(fulltextindexed=True)
      has_address = SubjectRelation('PostalAddress', cardinality='1?', composite='subject')
      proposed_by = SubjectRelation('Agency')
      comments = ObjectRelation('Comment', cardinality='1*', composite='object')
      screenshots = SubjectRelation(('File', 'Image'), cardinality='*1',
                                    composite='subject')

The two other entity types defined in the schema are `Visit` and `Agency` but we
can also guess from the above that this application uses the two cubes
`comment`_ and
`addressbook`_ (remember, cubicweb is only a game where you assemble cubes !).

While we know that just defining the schema in enough to have a full, usable,
(testable !) application, we also know that every application needs to be
customized to fulfill the needs it was built for. So in this case, what we
needed most was some custom filters that would let us restrict searches
according
to surfaces, prices or zipcodes. Fortunately for us, Cubicweb provides the
**facets** (image_) mechanism and a few base classes that make the task quite
easy:

.. sourcecode:: python

  class PostalCodeFacet(RelationFacet):
      __regid__ = 'postalcode-facet'             # every registered class must have an id
      __select__ = implements('Office')   # this facet should only be selected when
                                          # visualizing offices
      rtype = 'has_address'               # this facet is a filter on the entity linked to
                                          # the office thrhough the relation
                                          # has_address
      target_attr = 'postalcode'          # the filter's key is the attribute "postal_code"
                                          # of the target PostalAddress entity

This is a typical `RelationFacet`: we want to be able to filter offices
according
to the attribute `postalcode` of their associated `PostalAdress`. Each line in
the class is explained by the comment on its right.

Now, here is the code to define a filter based on the `surface` attribute of the
`Office`:

.. sourcecode:: python

  class SurfaceFacet(AttributeFacet):
      __regid__ = 'surface-facet'              # every registered class must have an id
      __select__ = implements('Office') # this facet should only be selected when
                                        # visualizing offices
      rtype = 'surface'                 # the filter's key is the attribute "surface"
      comparator = '>='                 # override the default value of operator since
                                        # we want to filter according to a
                                        # minimal
                                        # value, not an exact one

      def rset_vocabulary(self, ___):
          """override the default vocabulary method since we want to hard-code
          our threshold values.
          Not overriding would generate a filter box with all existing surfaces
          defined in the database.
          """
          return [('> 200', '200'), ('> 250', '250'),
                  ('> 275', '275'), ('> 300', '300')]


And that's it: we have two filter boxes automatically displayed on each page
presenting more than one office. The `price` facet is basically the same as the
`surface` one but with a different vocabulary and with ``rtype = 'price'``.

(The cube also benefits from the builtin google map views defined by
cubicweb but that's for another blog).

.. _image: http://www.cubicweb.org/image/197646?vid=download
.. _comment: http://www.cubicweb.org/project/cubicweb-comment
.. _addressbook: http://www.cubicweb.org/project/cubicweb-addressbook

CubicWeb has this really nice builtin `facet`_ system to
define restrictions `filters`_ really as easily as possible.

We've just added two new kind of facets in CubicWeb :

- The **RangeFacet** which displays a slider using `jquery`_
  to choose a lower bound and an upper bound. The **RangeWidget**
  works with either numerical values or date values

- The **HasRelationFacet** which displays a simple checkbox and
  lets you refine your selection in order to get only entities
  that actually use this relation.

.. image :: http://www.cubicweb.org/Image/343498?vid=download


Here's an example of code that defines a facet to filter
musical works according to their composition date:

.. sourcecode:: python

    class CompositionDateFacet(DateRangeFacet):
        # 1. make sure this facet is displayed only on Track selection
        __select__ = DateRangeFacet.__select__ & implements('Track')
        # 2. give the facet an id required by CubicWeb)
        __regid__ = 'compdate-facet'
        # 3. specify the attribute name that actually stores the date in the DB
        rtype = 'composition_date'

And that's it, on each page displaying tracks, you'll be able to filter them
according to their composition date with a jquery slider.

All this, brought by CubicWeb (in the next 3.3 version)

.. _facet: http://en.wikipedia.org/wiki/Faceted_browser
.. _filters: http://www.cubicweb.org/blogentry/154152
.. _jquery: http://www.jqueryui.com/

To use **HasRelationFacet** on a reverse relation add ``role = 'object'`` in
it's definitions.