entity.py
changeset 3378 2f25f701301d
parent 3376 f5c69485381f
child 3382 435286b8fe10
--- a/entity.py	Wed Sep 23 09:29:39 2009 +0200
+++ b/entity.py	Wed Sep 23 09:33:02 2009 +0200
@@ -166,7 +166,7 @@
                 # later information here, systematically add it.
                 restrictions[-1] += '?'
                 # XXX user.req.vreg iiiirk
-                destcls = user.req.vreg['etypes'].etype_class(desttype)
+                destcls = user._cw.vreg['etypes'].etype_class(desttype)
                 destcls._fetch_restrictions(var, varmaker, destcls.fetch_attrs,
                                             selection, orderby, restrictions,
                                             user, ordermethod, visited=visited)
@@ -247,24 +247,24 @@
 
     @cached
     def metainformation(self):
-        res = dict(zip(('type', 'source', 'extid'), self.req.describe(self.eid)))
-        res['source'] = self.req.source_defs()[res['source']]
+        res = dict(zip(('type', 'source', 'extid'), self._cw.describe(self.eid)))
+        res['source'] = self._cw.source_defs()[res['source']]
         return res
 
     def clear_local_perm_cache(self, action):
         for rqlexpr in self.e_schema.get_rqlexprs(action):
-            self.req.local_perm_cache.pop((rqlexpr.eid, (('x', self.eid),)), None)
+            self._cw.local_perm_cache.pop((rqlexpr.eid, (('x', self.eid),)), None)
 
     def check_perm(self, action):
-        self.e_schema.check_perm(self.req, action, self.eid)
+        self.e_schema.check_perm(self._cw, action, self.eid)
 
     def has_perm(self, action):
-        return self.e_schema.has_perm(self.req, action, self.eid)
+        return self.e_schema.has_perm(self._cw, action, self.eid)
 
     def view(self, vid, __registry='views', **kwargs):
         """shortcut to apply a view on this entity"""
-        return self.vreg[__registry].render(vid, self.req, rset=self.rset,
-                                            row=self.row, col=self.col, **kwargs)
+        return self._cw.vreg[__registry].render(
+            vid, self._cw, rset=self.rset, row=self.row, col=self.col, **kwargs)
 
     def absolute_url(self, *args, **kwargs):
         """return an absolute url to view this entity"""
@@ -278,7 +278,7 @@
         # in linksearch mode, we don't want external urls else selecting
         # the object for use in the relation is tricky
         # XXX search_state is web specific
-        if getattr(self.req, 'search_state', ('normal',))[0] == 'normal':
+        if getattr(self._cw, 'search_state', ('normal',))[0] == 'normal':
             kwargs['base_url'] = self.metainformation()['source'].get('base-url')
         if method in (None, 'view'):
             try:
@@ -289,7 +289,7 @@
                 kwargs['_restpath'] = self.rest_path()
         else:
             kwargs['rql'] = 'Any X WHERE X eid %s' % self.eid
-        return self.req.build_url(method, **kwargs)
+        return self._cw.build_url(method, **kwargs)
 
     def rest_path(self, use_ext_eid=False):
         """returns a REST-like (relative) path for this entity"""
@@ -305,7 +305,7 @@
                 # make sure url is not ambiguous
                 rql = 'Any COUNT(X) WHERE X is %s, X %s %%(value)s' % (
                     etype, mainattr)
-                nbresults = self.req.execute(rql, {'value' : value})[0][0]
+                nbresults = self._cw.execute(rql, {'value' : value})[0][0]
                 if nbresults != 1: # ambiguity?
                     mainattr = 'eid'
                     path += '/eid'
@@ -314,13 +314,13 @@
                 value = self.metainformation()['extid']
             else:
                 value = self.eid
-        return '%s/%s' % (path, self.req.url_quote(value))
+        return '%s/%s' % (path, self._cw.url_quote(value))
 
     def attr_metadata(self, attr, metadata):
         """return a metadata for an attribute (None if unspecified)"""
         value = getattr(self, '%s_%s' % (attr, metadata), None)
         if value is None and metadata == 'encoding':
-            value = self.vreg.property_value('ui.encoding')
+            value = self._cw.vreg.property_value('ui.encoding')
         return value
 
     def printable_value(self, attr, value=_marker, attrtype=None,
@@ -342,11 +342,11 @@
             # internalinalized *and* formatted string such as schema
             # description...
             if props.get('internationalizable'):
-                value = self.req._(value)
+                value = self._cw._(value)
             attrformat = self.attr_metadata(attr, 'format')
             if attrformat:
                 return self.mtc_transform(value, attrformat, format,
-                                          self.req.encoding)
+                                          self._cw.encoding)
         elif attrtype == 'Bytes':
             attrformat = self.attr_metadata(attr, 'format')
             if attrformat:
@@ -354,7 +354,7 @@
                 return self.mtc_transform(value.getvalue(), attrformat, format,
                                           encoding)
             return u''
-        value = printable_value(self.req, attrtype, value, props,
+        value = printable_value(self._cw, attrtype, value, props,
                                 displaytime=displaytime)
         if format == 'text/html':
             value = xml_escape(value)
@@ -365,7 +365,7 @@
         trdata = TransformData(data, format, encoding, appobject=self)
         data = _engine.convert(trdata, target_format).decode()
         if format == 'text/html':
-            data = soup2xhtml(data, self.req.encoding)
+            data = soup2xhtml(data, self._cw.encoding)
         return data
 
     # entity cloning ##########################################################
@@ -377,7 +377,7 @@
         Overrides this if you want another behaviour
         """
         assert self.has_eid()
-        execute = self.req.execute
+        execute = self._cw.execute
         for rschema in self.e_schema.subject_relations():
             if rschema.is_final() or rschema.meta:
                 continue
@@ -422,7 +422,7 @@
         """returns a resultset containing `self` information"""
         rset = ResultSet([(self.eid,)], 'Any X WHERE X eid %(x)s',
                          {'x': self.eid}, [(self.__regid__,)])
-        return self.req.decorate_rset(rset)
+        return self._cw.decorate_rset(rset)
 
     def to_complete_relations(self):
         """by default complete final relations to when calling .complete()"""
@@ -434,7 +434,7 @@
                 # outer join correctly in this case
                 continue
             if rschema.inlined:
-                matching_groups = self.req.user.matching_groups
+                matching_groups = self._cw.user.matching_groups
                 if matching_groups(rschema.get_groups('read')) and \
                    all(matching_groups(es.get_groups('read'))
                        for es in rschema.objects(self.e_schema)):
@@ -449,7 +449,7 @@
             if attr == 'eid':
                 continue
             # password retreival is blocked at the repository server level
-            if not self.req.user.matching_groups(rschema.get_groups('read')) \
+            if not self._cw.user.matching_groups(rschema.get_groups('read')) \
                    or attrschema.type == 'Password':
                 self[attr] = None
                 continue
@@ -509,7 +509,7 @@
             # if some outer join are included to fetch inlined relations
             rql = 'Any %s,%s %s' % (V, ','.join(var for attr, var in selected),
                                     ','.join(rql))
-            execute = getattr(self.req, 'unsafe_execute', self.req.execute)
+            execute = getattr(self._cw, 'unsafe_execute', self._cw.execute)
             rset = execute(rql, {'x': self.eid}, 'x', build_descr=False)[0]
             # handle attributes
             for i in xrange(1, lastattr):
@@ -520,9 +520,9 @@
                 value = rset[i]
                 if value is None:
                     rrset = ResultSet([], rql, {'x': self.eid})
-                    self.req.decorate_rset(rrset)
+                    self._cw.decorate_rset(rrset)
                 else:
-                    rrset = self.req.eid_rset(value)
+                    rrset = self._cw.eid_rset(value)
                 self.set_related_cache(rtype, role, rrset)
 
     def get_value(self, name):
@@ -540,7 +540,7 @@
             rql = "Any A WHERE X eid %%(x)s, X %s A" % name
             # XXX should we really use unsafe_execute here? I think so (syt),
             # see #344874
-            execute = getattr(self.req, 'unsafe_execute', self.req.execute)
+            execute = getattr(self._cw, 'unsafe_execute', self._cw.execute)
             try:
                 rset = execute(rql, {'x': self.eid}, 'x')
             except Unauthorized:
@@ -555,7 +555,7 @@
                                   name, self.eid)
                     if self.e_schema.destination(name) == 'String':
                         # XXX (syt) imo emtpy string is better
-                        self[name] = value = self.req._('unaccessible')
+                        self[name] = value = self._cw._('unaccessible')
                     else:
                         self[name] = value = None
         return value
@@ -575,13 +575,13 @@
         rql = self.related_rql(rtype, role)
         # XXX should we really use unsafe_execute here? I think so (syt),
         # see #344874
-        execute = getattr(self.req, 'unsafe_execute', self.req.execute)
+        execute = getattr(self._cw, 'unsafe_execute', self._cw.execute)
         rset = execute(rql, {'x': self.eid}, 'x')
         self.set_related_cache(rtype, role, rset)
         return self.related(rtype, role, limit, entities)
 
     def related_rql(self, rtype, role='subject', targettypes=None):
-        rschema = self.req.vreg.schema[rtype]
+        rschema = self._cw.vreg.schema[rtype]
         if role == 'subject':
             if targettypes is None:
                 targettypes = rschema.objects(self.e_schema)
@@ -595,14 +595,14 @@
         if len(targettypes) > 1:
             fetchattrs_list = []
             for ttype in targettypes:
-                etypecls = self.vreg['etypes'].etype_class(ttype)
+                etypecls = self._cw.vreg['etypes'].etype_class(ttype)
                 fetchattrs_list.append(set(etypecls.fetch_attrs))
             fetchattrs = reduce(set.intersection, fetchattrs_list)
-            rql = etypecls.fetch_rql(self.req.user, [restriction], fetchattrs,
+            rql = etypecls.fetch_rql(self._cw.user, [restriction], fetchattrs,
                                      settype=False)
         else:
-            etypecls = self.vreg['etypes'].etype_class(targettypes[0])
-            rql = etypecls.fetch_rql(self.req.user, [restriction], settype=False)
+            etypecls = self._cw.vreg['etypes'].etype_class(targettypes[0])
+            rql = etypecls.fetch_rql(self._cw.user, [restriction], settype=False)
         # optimisation: remove ORDERBY if cardinality is 1 or ? (though
         # greater_card return 1 for those both cases)
         if card == '1':
@@ -626,7 +626,7 @@
         """
         ordermethod = ordermethod or 'fetch_unrelated_order'
         if isinstance(rtype, basestring):
-            rtype = self.req.vreg.schema.rschema(rtype)
+            rtype = self._cw.vreg.schema.rschema(rtype)
         if role == 'subject':
             evar, searchedvar = 'S', 'O'
             subjtype, objtype = self.e_schema, targettype
@@ -645,7 +645,7 @@
             args = {}
             securitycheck_args = {}
         insertsecurity = (rtype.has_local_role('add') and not
-                          rtype.has_perm(self.req, 'add', **securitycheck_args))
+                          rtype.has_perm(self._cw, 'add', **securitycheck_args))
         constraints = rtype.rproperty(subjtype, objtype, 'constraints')
         if vocabconstraints:
             # RQLConstraint is a subclass for RQLVocabularyConstraint, so they
@@ -655,8 +655,8 @@
         else:
             restriction += [cstr.restriction for cstr in constraints
                             if isinstance(cstr, RQLConstraint)]
-        etypecls = self.vreg['etypes'].etype_class(targettype)
-        rql = etypecls.fetch_rql(self.req.user, restriction,
+        etypecls = self._cw.vreg['etypes'].etype_class(targettype)
+        rql = etypecls.fetch_rql(self._cw.user, restriction,
                                  mainvar=searchedvar, ordermethod=ordermethod)
         # ensure we have an order defined
         if not ' ORDERBY ' in rql:
@@ -664,8 +664,8 @@
             rql = '%s ORDERBY %s WHERE %s' % (before, searchedvar, after)
         if insertsecurity:
             rqlexprs = rtype.get_rqlexprs('add')
-            rewriter = RQLRewriter(self.req)
-            rqlst = self.req.vreg.parse(self.req, rql, args)
+            rewriter = RQLRewriter(self._cw)
+            rqlst = self._cw.vreg.parse(self._cw, rql, args)
             for select in rqlst.children:
                 rewriter.rewrite(select, [((searchedvar, searchedvar), rqlexprs)],
                                  select.solutions, args)
@@ -680,11 +680,11 @@
         try:
             rql, args = self.unrelated_rql(rtype, targettype, role, ordermethod)
         except Unauthorized:
-            return self.req.empty_rset()
+            return self._cw.empty_rset()
         if limit is not None:
             before, after = rql.split(' WHERE ', 1)
             rql = '%s LIMIT %s WHERE %s' % (before, limit, after)
-        return self.req.execute(rql, args, tuple(args))
+        return self._cw.execute(rql, args, tuple(args))
 
     # relations cache handling ################################################
 
@@ -709,7 +709,7 @@
         """set cached values for the given relation"""
         if rset:
             related = list(rset.entities(col))
-            rschema = self.req.vreg.schema.rschema(rtype)
+            rschema = self._cw.vreg.schema.rschema(rtype)
             if role == 'subject':
                 rcard = rschema.rproperty(self.e_schema, related[0].e_schema,
                                           'cardinality')[1]
@@ -752,15 +752,15 @@
         # and now update the database
         kwargs['x'] = self.eid
         if _cw_unsafe:
-            self.req.unsafe_execute(
+            self._cw.unsafe_execute(
                 'SET %s WHERE X eid %%(x)s' % ','.join(relations), kwargs, 'x')
         else:
-            self.req.execute('SET %s WHERE X eid %%(x)s' % ','.join(relations),
+            self._cw.execute('SET %s WHERE X eid %%(x)s' % ','.join(relations),
                              kwargs, 'x')
 
     def delete(self):
         assert self.has_eid(), self.eid
-        self.req.execute('DELETE %s X WHERE X eid %%(x)s' % self.e_schema,
+        self._cw.execute('DELETE %s X WHERE X eid %%(x)s' % self.e_schema,
                          {'x': self.eid})
 
     # server side utilities ###################################################
@@ -779,10 +779,10 @@
         """
         # necessary since eid is handled specifically and yams require it to be
         # in the dictionary
-        if self.req is None:
+        if self._cw is None:
             _ = unicode
         else:
-            _ = self.req._
+            _ = self._cw._
         self.e_schema.check(self, creation=creation, _=_)
 
     def fti_containers(self, _done=None):