cubicweb: comparison appobject.py

equal deleted inserted replaced

-:a721966779be
+:cba9f175da2d
 """
 __docformat__ = "restructuredtext en"
 from datetime import datetime, timedelta
-from simplejson import dumps
 from logilab.common.decorators import classproperty
 from logilab.common.deprecation import obsolete
 from rql.nodes import VariableRef, SubQuery
 from rql.stmts import Union, Select
 from cubicweb.selectors import yes
 from cubicweb.utils import UStringIO, ustrftime
 ONESECOND = timedelta(0, 1, 0)
 class Cache(dict):
 def __init__(self):
 super(Cache, self).__init__()
 self.cache_creation_date = None
 self.latest_cache_lookup = datetime.now()
 CACHE_REGISTRY = {}
 class AppRsetObject(VObject):
 """This is the base class for CubicWeb application objects
 which are selected according to a request and result set.
 Classes are kept in the vregistry and instantiation is done at selection
 time.
 At registration time, the following attributes are set on the class:
 :vreg:
 the application's registry
 :schema:
 the application's schema
 cls.vreg = vreg
 cls.schema = vreg.schema
 cls.config = vreg.config
 cls.register_properties()
 return cls
 @classmethod
 def vreg_initialization_completed(cls):
 pass
 @classmethod
 def selected(cls, *args, **kwargs):
 """by default web app objects are usually instantiated on
 selection according to a request, a result set, and optional
 row and col
 #        possible types are those used by `logilab.common.configuration`
 #
 # notice that when it exists multiple objects with the same id (adaptation,
 # overriding) only the first encountered definition is considered, so those
 # objects can't try to have different default values for instance.
 property_defs = {}
 @classmethod
 def register_properties(cls):
 for propid, pdef in cls.property_defs.items():
 pdef = pdef.copy() # may be shared
 pdef['default'] = getattr(cls, propid, pdef['default'])
 pdef['sitewide'] = getattr(cls, 'site_wide', pdef.get('sitewide'))
 cls.vreg.register_property(cls.propkey(propid), **pdef)
 @classmethod
 def propkey(cls, propid):
 return '%s.%s.%s' % (cls.__registry__, cls.id, propid)
 @classproperty
 if isinstance(selector, AndSelector):
 return tuple(selector.selectors)
 if not isinstance(selector, tuple):
 selector = (selector,)
 return selector
 def __init__(self, req=None, rset=None, row=None, col=None, **extra):
 super(AppRsetObject, self).__init__()
 self.req = req
 self.rset = rset
 self.row = row
 self.col = col
 self.extra_kwargs = extra
 def get_cache(self, cachename):
 """
 NOTE: cachename should be dotted names as in :
 - cubicweb.mycache
 - cubes.blog.mycache
 - etc.
 """
 if cachename in CACHE_REGISTRY:
 cache = CACHE_REGISTRY[cachename]
 else:
 cache = Cache()
 CACHE_REGISTRY[cachename] = cache
 _now = datetime.now()
 if _now > cache.latest_cache_lookup + ONESECOND:
 ecache = self.req.execute('Any C,T WHERE C is CWCache, C name %(name)s, C timestamp T',
 {'name':cachename}).get_entity(0,0)
 cache.latest_cache_lookup = _now
 if not ecache.valid(cache.cache_creation_date):
 cache.clear()
 cache.cache_creation_date = _now
 return cache
 def propval(self, propid):
 assert self.req
 return self.req.property_value(self.propkey(propid))
 def limited_rql(self):
 """return a printable rql for the result set associated to the object,
 with limit/offset correctly set according to maximum page size and
 currently displayed page when necessary
 """
 # navigation component doesn't apply and rset has not been limited, no
 # need to limit query
 else:
 rql = self.rset.printable_rql()
 return rql
 def _limit_offset_rql(self, limit, offset):
 rqlst = self.rset.syntax_tree()
 if len(rqlst.children) == 1:
 select = rqlst.children[0]
 olimit, ooffset = select.limit, select.offset
 newunion = Union()
 newunion.append(newselect)
 rql = rqlst.as_string(kwargs=self.rset.args)
 rqlst.parent = None
 return rql
 def view(self, __vid, rset=None, __fallback_vid=None, **kwargs):
 """shortcut to self.vreg.render method avoiding to pass self.req"""
 try:
 view = self.vreg.select_view(__vid, self.req, rset, **kwargs)
 except NoSelectableObject:
 if __fallback_vid is None:
 raise
 view = self.vreg.select_view(__fallback_vid, self.req, rset, **kwargs)
 return view.dispatch(**kwargs)
 # url generation methods ##################################################
 controller = 'view'
 def build_url(self, method=None, **kwargs):
 """return an absolute URL using params dictionary key/values as URL
 parameters. Values are automatically URL quoted, and the
 publishing method to use may be specified or will be guessed.
 """
 not '_restpath' in kwargs:
 method = self.req.relative_path(includeparams=False) or 'view'
 return self.req.build_url(method, **kwargs)
 # various resources accessors #############################################
 def entity(self, row, col=0):
 """short cut to get an entity instance for a particular row/column
 (col default to 0)
 """
 return self.rset.get_entity(row, col)
 def complete_entity(self, row, col=0, skip_bytes=True):
 """short cut to get an completed entity instance for a particular
 row (all instance's attributes have been fetched)
 """
 entity = self.entity(row, col)
 to call it ready to be inserted in html
 """
 def rqlexec(req, rql, args=None, key=None):
 req.execute(rql, args, key)
 return self.user_callback(rqlexec, args, msg)
 def user_callback(self, cb, args, msg=None, nonify=False):
 """register the given user callback and return an url to call it ready to be
 inserted in html
 """
+from simplejson import dumps
 self.req.add_js('cubicweb.ajax.js')
 cbname = self.req.register_onetime_callback(cb, *args)
 msg = dumps(msg or '')
 return "javascript:userCallbackThenReloadPage('%s', %s)" % (
 cbname, msg)
 # formating methods #######################################################
 def tal_render(self, template, variables):
 """render a precompiled page template with variables in the given
 dictionary as context
 """
-from cubicweb.common.tal import CubicWebContext
+from cubicweb.ext.tal import CubicWebContext
 context = CubicWebContext()
 context.update({'self': self, 'rset': self.rset, '_' : self.req._,
 'req': self.req, 'user': self.req.user})
 context.update(variables)
 output = UStringIO()
 configuration
 """
 if num:
 return self.req.property_value('ui.float-format') % num
 return u''
 # security related methods ################################################
 def ensure_ro_rql(self, rql):
 """raise an exception if the given rql is not a select query"""
 first = rql.split(' ', 1)[0].lower()
 if first in ('insert', 'set', 'delete'):
 raise Unauthorized(self.req._('only select queries are authorized'))
 class AppObject(AppRsetObject):
 """base class for application objects which are not selected
 according to a result set, only by their identifier.
 Those objects may not have req, rset and cursor set.
 """
 @classmethod
 def selected(cls, *args, **kwargs):
 """by default web app objects are usually instantiated on
 selection
 """

branch	tls-sprint
changeset 1715	cba9f175da2d
parent 1637	f5f6f25c2602
child 1723	30c3a713ab61