cubicweb: comparison web/facet.py

equal deleted inserted replaced

-:9cbf4c86f57a
+:75d208ab8444
 from logilab.mtconverter import xml_escape
 from logilab.common.graph import has_path
 from logilab.common.decorators import cached
 from logilab.common.date import datetime2ticks, ustrftime, ticks2datetime
 from logilab.common.compat import all
+from logilab.common.deprecation import deprecated
 from rql import parse, nodes, utils
 from cubicweb import Unauthorized, typed_eid
 from cubicweb.schema import display_name
 if len(ptypes) == 1:
 return display_name(facet._cw, facet.rtype, form=facet.role,
 context=iter(ptypes).next())
 return display_name(facet._cw, facet.rtype, form=facet.role)
+def filtered_variable(rqlst):
+vref = rqlst.selection[0].iget_nodes(nodes.VariableRef).next()
+return vref.variable
+def get_facet(req, facetid, rqlst, mainvar):
+return req.vreg['facets'].object_by_id(facetid, req, rqlst=rqlst,
+filtered_variable=mainvar)
+@deprecated('[3.13] filter_hiddens moved to cubicweb.web.views.facets with '
+'slightly modified prototype')
+def filter_hiddens(w, **kwargs):
+from cubicweb.web.views.facets import filter_hiddens
+return filter_hiddens(w, wdgs=kwargs.pop('facets'))
 ## rqlst manipulation functions used by facets ################################
 def prepare_facets_rqlst(rqlst, args=None):
 """prepare a syntax tree to generate facet filters
 * cleanup selection (remove everything)
 * undefine unnecessary variables
 * set DISTINCT
 * unset LIMIT/OFFSET
 """
-if len(rqlst.children) > 1:
+assert len(rqlst.children) == 1, 'FIXME: union not yet supported'
-raise NotImplementedError('FIXME: union not yet supported')
 select = rqlst.children[0]
 mainvar = filtered_variable(select)
 select.set_limit(None)
 select.set_offset(None)
 baserql = select.as_string(kwargs=args)
 select.undefine_variable(dvar)
 # global tree config: DISTINCT, LIMIT, OFFSET
 select.set_distinct(True)
 return mainvar, baserql
-def filtered_variable(rqlst):
-vref = rqlst.selection[0].iget_nodes(nodes.VariableRef).next()
+def prepare_vocabulary_rqlst(rqlst, mainvar, rtype, role,
-return vref.variable
-def get_facet(req, facetid, rqlst, mainvar):
-return req.vreg['facets'].object_by_id(facetid, req, rqlst=rqlst,
-filtered_variable=mainvar)
-def filter_hiddens(w, **kwargs):
-for key, val in kwargs.items():
-w(u'<input type="hidden" name="%s" value="%s" />' % (
-key, xml_escape(val)))
-def _may_be_removed(rel, schema, mainvar):
-"""if the given relation may be removed from the tree, return the variable
-on the other side of `mainvar`, else return None
-Conditions:
-* the relation is an attribute selection of the main variable
-* the relation is optional relation linked to the main variable
-* the relation is a mandatory relation linked to the main variable
-without any restriction on the other variable
-"""
-lhs, rhs = rel.get_variable_parts()
-rschema = schema.rschema(rel.r_type)
-if lhs.variable is mainvar:
-try:
-ovar = rhs.variable
-except AttributeError:
-# constant restriction
-# XXX: X title LOWER(T) if it makes sense?
-return None
-if rschema.final:
-if len(ovar.stinfo['relations']) == 1:
-# attribute selection
-return ovar
-return None
-opt = 'right'
-cardidx = 0
-elif getattr(rhs, 'variable', None) is mainvar:
-ovar = lhs.variable
-opt = 'left'
-cardidx = 1
-else:
-# not directly linked to the main variable
-return None
-if rel.optional in (opt, 'both'):
-# optional relation
-return ovar
-if all(rdef.cardinality[cardidx] in '1+'
-for rdef in rschema.rdefs.values()):
-# mandatory relation without any restriction on the other variable
-for orel in ovar.stinfo['relations']:
-if rel is orel:
-continue
-if _may_be_removed(orel, schema, ovar) is None:
-return None
-return ovar
-return None
-def _make_relation(rqlst, mainvar, rtype, role):
-newvar = rqlst.make_variable()
-if role == 'object':
-rel = nodes.make_relation(newvar, rtype, (mainvar,), nodes.VariableRef)
-else:
-rel = nodes.make_relation(mainvar, rtype, (newvar,), nodes.VariableRef)
-return newvar, rel
-def _add_rtype_relation(rqlst, mainvar, rtype, role):
-"""add a relation relying `mainvar` to entities linked by the `rtype`
-relation (where `mainvar` has `role`)
-return the inserted variable for linked entities.
-"""
-newvar, newrel = _make_relation(rqlst, mainvar, rtype, role)
-rqlst.add_restriction(newrel)
-return newvar, newrel
-def _add_eid_restr(rel, restrvar, value):
-rrel = nodes.make_constant_restriction(restrvar, 'eid', value, 'Int')
-rel.parent.replace(rel, nodes.And(rel, rrel))
-def _prepare_vocabulary_rqlst(rqlst, mainvar, rtype, role,
 select_target_entity=True):
 """prepare a syntax tree to generate a filter vocabulary rql using the given
 relation:
 * create a variable to filter on this relation
 * add the relation
 if mainvar.stinfo['typerel'] is None:
 etypes = frozenset(sol[mainvar.name] for sol in rqlst.solutions)
 rqlst.add_type_restriction(mainvar, etypes)
 return newvar
-def _remove_relation(rqlst, rel, var):
-"""remove a constraint relation from the syntax tree"""
-# remove the relation
-rqlst.remove_node(rel)
-# remove relations where the filtered variable appears on the
-# lhs and rhs is a constant restriction
-extra = []
-for vrel in var.stinfo['relations']:
-if vrel is rel:
-continue
-if vrel.children[0].variable is var:
-if not vrel.children[1].get_nodes(nodes.Constant):
-extra.append(vrel)
-rqlst.remove_node(vrel)
-return extra
-def _set_orderby(rqlst, newvar, sortasc, sortfuncname):
-if sortfuncname is None:
-rqlst.add_sort_var(newvar, sortasc)
-else:
-vref = nodes.variable_ref(newvar)
-vref.register_reference()
-sortfunc = nodes.Function(sortfuncname)
-sortfunc.append(vref)
-term = nodes.SortTerm(sortfunc, sortasc)
-rqlst.add_sort_term(term)
 def insert_attr_select_relation(rqlst, mainvar, rtype, role, attrname,
 sortfuncname=None, sortasc=True,
 select_target_entity=True):
 """modify a syntax tree to :
 Sorting:
 * on `attrname` ascendant (`sortasc`=True) or descendant (`sortasc`=False)
 * on `sortfuncname`(`attrname`) if `sortfuncname` is specified
 * no sort if `sortasc` is None
 """
-_cleanup_rqlst(rqlst, mainvar)
+cleanup_rqlst(rqlst, mainvar)
-var = _prepare_vocabulary_rqlst(rqlst, mainvar, rtype, role,
+var = prepare_vocabulary_rqlst(rqlst, mainvar, rtype, role,
 select_target_entity)
 attrvar = rqlst.make_variable()
 rqlst.add_relation(var, attrname, attrvar)
 # if query is grouped, we have to add the attribute variable
 if rqlst.groupby:
 if not attrvar in rqlst.groupby:
 _set_orderby(rqlst, attrvar, sortasc, sortfuncname)
 # add attribute variable to selection
 rqlst.add_selected(attrvar)
 return var
-def _cleanup_rqlst(rqlst, mainvar):
-"""cleanup tree from unnecessary restriction:
+def cleanup_rqlst(rqlst, mainvar):
+"""cleanup tree from unnecessary restrictions:
 * attribute selection
 * optional relations linked to the main variable
 * mandatory relations linked to the main variable
 """
 if rqlst.where is None:
 continue
 if not has_path(vargraph, ovarname, mainvar.name):
 toremove.add(rqlst.defined_vars[ovarname])
+def _may_be_removed(rel, schema, mainvar):
+"""if the given relation may be removed from the tree, return the variable
+on the other side of `mainvar`, else return None
+Conditions:
+* the relation is an attribute selection of the main variable
+* the relation is optional relation linked to the main variable
+* the relation is a mandatory relation linked to the main variable
+without any restriction on the other variable
+"""
+lhs, rhs = rel.get_variable_parts()
+rschema = schema.rschema(rel.r_type)
+if lhs.variable is mainvar:
+try:
+ovar = rhs.variable
+except AttributeError:
+# constant restriction
+# XXX: X title LOWER(T) if it makes sense?
+return None
+if rschema.final:
+if len(ovar.stinfo['relations']) == 1:
+# attribute selection
+return ovar
+return None
+opt = 'right'
+cardidx = 0
+elif getattr(rhs, 'variable', None) is mainvar:
+ovar = lhs.variable
+opt = 'left'
+cardidx = 1
+else:
+# not directly linked to the main variable
+return None
+if rel.optional in (opt, 'both'):
+# optional relation
+return ovar
+if all(rdef.cardinality[cardidx] in '1+'
+for rdef in rschema.rdefs.values()):
+# mandatory relation without any restriction on the other variable
+for orel in ovar.stinfo['relations']:
+if rel is orel:
+continue
+if _may_be_removed(orel, schema, ovar) is None:
+return None
+return ovar
+return None
+def _make_relation(rqlst, mainvar, rtype, role):
+newvar = rqlst.make_variable()
+if role == 'object':
+rel = nodes.make_relation(newvar, rtype, (mainvar,), nodes.VariableRef)
+else:
+rel = nodes.make_relation(mainvar, rtype, (newvar,), nodes.VariableRef)
+return newvar, rel
+def _add_rtype_relation(rqlst, mainvar, rtype, role):
+"""add a relation relying `mainvar` to entities linked by the `rtype`
+relation (where `mainvar` has `role`)
+return the inserted variable for linked entities.
+"""
+newvar, newrel = _make_relation(rqlst, mainvar, rtype, role)
+rqlst.add_restriction(newrel)
+return newvar, newrel
+def _add_eid_restr(rel, restrvar, value):
+rrel = nodes.make_constant_restriction(restrvar, 'eid', value, 'Int')
+rel.parent.replace(rel, nodes.And(rel, rrel))
+def _remove_relation(rqlst, rel, var):
+"""remove a constraint relation from the syntax tree"""
+# remove the relation
+rqlst.remove_node(rel)
+# remove relations where the filtered variable appears on the
+# lhs and rhs is a constant restriction
+extra = []
+for vrel in var.stinfo['relations']:
+if vrel is rel:
+continue
+if vrel.children[0].variable is var:
+if not vrel.children[1].get_nodes(nodes.Constant):
+extra.append(vrel)
+rqlst.remove_node(vrel)
+return extra
+def _set_orderby(rqlst, newvar, sortasc, sortfuncname):
+if sortfuncname is None:
+rqlst.add_sort_var(newvar, sortasc)
+else:
+vref = nodes.variable_ref(newvar)
+vref.register_reference()
+sortfunc = nodes.Function(sortfuncname)
+sortfunc.append(vref)
+term = nodes.SortTerm(sortfunc, sortasc)
+rqlst.add_sort_term(term)
+_prepare_vocabulary_rqlst = deprecated('[3.13] renamed prepare_vocabulary_rqlst ')(
+prepare_vocabulary_rqlst)
+_cleanup_rqlst = deprecated('[3.13] renamed to cleanup_rqlst')(cleanup_rqlst)
 ## base facet classes ##########################################################
 class AbstractFacet(AppObject):
 """Abstract base class for all facets. Facets are stored in their own
 'facets' registry. They are similar to contextual components since the use
 compare to a form value in javascript) for this facet
 """
 rqlst = self.rqlst
 rqlst.save_state()
 try:
-_cleanup_rqlst(rqlst, self.filtered_variable)
+cleanup_rqlst(rqlst, self.filtered_variable)
 if self._select_target_entity:
-_prepare_vocabulary_rqlst(rqlst, self.filtered_variable, self.rtype,
+prepare_vocabulary_rqlst(rqlst, self.filtered_variable, self.rtype,
 self.role, select_target_entity=True)
 else:
 insert_attr_select_relation(
 rqlst, self.filtered_variable, self.rtype, self.role, self.target_attr,
 select_target_entity=False)
 values = [unicode(x) for x, in self.rqlexec(rqlst.as_string())]
 """
 rqlst = self.rqlst
 rqlst.save_state()
 try:
 mainvar = self.filtered_variable
-_cleanup_rqlst(rqlst, mainvar)
+cleanup_rqlst(rqlst, mainvar)
-newvar = _prepare_vocabulary_rqlst(rqlst, mainvar, self.rtype, self.role)
+newvar = prepare_vocabulary_rqlst(rqlst, mainvar, self.rtype, self.role)
 _set_orderby(rqlst, newvar, self.sortasc, self.sortfunc)
 try:
 rset = self.rqlexec(rqlst.as_string(), self.cw_rset.args)
 except:
 self.exception('error while getting vocabulary for %s, rql: %s',

changeset 7600	75d208ab8444
parent 7414	de802bcb6348
child 7604	1eb6090311ff