cubicweb: comparison goa/db.py

equal deleted inserted replaced

-:672acc730ce5
+:d628defebc17
 following differences:
 * all methods returning `google.appengine.ext.db.Model` instance(s) will return
 `cubicweb.goa.db.Model` instance instead (though you should see almost no
 difference since those instances have the same api)
 * class methods returning model instance take a `req` as first argument, unless
 they are called through an instance, representing the current request
 (accessible through `self.req` on almost all objects)
 * XXX no instance.<modelname>_set attributes, use instance.reverse_<attr name>
 instead
 * XXX reference property always return a list of objects, not the instance
 * XXX name/collection_name argument of properties constructor are ignored
 * XXX ListProperty
 from google.appengine.api.datastore import NormalizeAndTypeCheck, RunInTransaction
 from google.appengine.api.datastore_types import Text, Blob
 from google.appengine.api.datastore_errors import BadKeyError
 # XXX remove this dependancy
 from google.appengine.ext import db
 def rset_from_objs(req, objs, attrs=('eid',), rql=None, args=None):
 """return a ResultSet instance for list of objects"""
 if objs is None:
 value = str(value)
 else:
 value = obj[attr]
 descr = str(eschema.destination(attr))
 line.append(value)
 linedescr.append(descr)
 rows.append(line)
 description.append(linedescr)
 for j, attr in enumerate(attrs):
 if attr == 'eid':
 entity = vreg.etype_class(eschema.type)(req, rset, i, j)
 rset._get_entity_cache_ = {(i, j): entity}
 rset.rowcount = len(rows)
 req.decorate_rset(rset)
 return rset
 def needrequest(wrapped):
 def wrapper(cls, *args, **kwargs):
 raise Exception('either call this method on an instance or '
 'specify the req argument')
 return wrapped(cls, req, *args, **kwargs)
 return iclassmethod(wrapper)
 class gaedbmetaentity(metaentity):
 """metaclass for goa.db.Model classes: filter entity / db model part,
 put aside the db model part for later creation of db model class.
 """
 def __new__(mcs, name, bases, classdict):
 class Model(entities.AnyEntity):
 id = 'Any'
 __metaclass__ = gaedbmetaentity
 row = col = 0
 @classmethod
 def __initialize__(cls):
 super(Model, cls).__initialize__()
 cls._attributes = frozenset(rschema for rschema in cls.e_schema.subject_relations()
 if rschema.is_final())
 def __init__(self, *args, **kwargs):
 # db.Model prototype:
 #   __init__(self, parent=None, key_name=None, **kw)
 #
 # Entity prototype:
 val = [isinstance(x, Model) and x._dbmodel or x for x in val]
 elif isinstance(val, Model):
 val = val._dbmodel
 kwargs[key] = val.key()
 self._gaeinitargs = (args, kwargs)
 def __repr__(self):
 return '<ModelEntity %s %s %s at %s>' % (
 self.e_schema, self.eid, self.keys(), id(self))
 def _cubicweb_to_datastore(self, attr, value):
 attr = attr[2:] # remove 's_' / 'o_' prefix
 if attr in self._attributes:
 tschema = self.e_schema.destination(attr)
 if tschema == 'String':
 if len(value) > 500:
 value = Text(value)
 elif tschema == 'Password':
 # if value is a Binary instance, this mean we got it
 # from a query result and so it is already encrypted
 if isinstance(value, Binary):
 value = value.getvalue()
 attr = 's_' + attr
 if value is not None and convert:
 value = self._cubicweb_to_datastore(attr, value)
 gaedict[attr] = value
 return gaedict
 def to_gae_model(self):
 dbmodel = self._dbmodel
 dbmodel.update(self._to_gae_dict())
 return dbmodel
 @property
 @cached
 def _dbmodel(self):
 if self.has_eid():
 assert self._gaeinitargs is None
 try:
 return self.req.datastore_get(self.eid)
 except AttributeError: # self.req is not a server session
 assert key_name is None
 key_name = kwargs.pop('key_name')
 if '_app' in kwargs:
 assert _app is None
 _app = kwargs.pop('_app')
 for key, value in kwargs.iteritems():
 if key in self._attributes:
 values['s_'+key] = value
 else:
 kwargs = None
 Note that if this function return something else than None, the returned
 value will be prefixed by 'key_' to build the actual key name.
 """
 return None
 def metainformation(self):
 return {'type': self.id, 'source': {'uri': 'system'}, 'extid': None}
 def view(self, vid, __registry='views', **kwargs):
 """shortcut to apply a view on this entity"""
 return self.vreg.render(__registry, vid, self.req, rset=self.rset,
 row=self.row, col=self.col, **kwargs)
 def _rest_attr_info(cls):
 mainattr, needcheck = super(Model, cls)._rest_attr_info()
 if needcheck:
 return 'eid', False
 return mainattr, needcheck
 def get_value(self, name):
 try:
 value = self[name]
 except KeyError:
 if not self.has_eid():
 try:
 Key(self.eid)
 return True
 except BadKeyError:
 return False
 def complete(self, skip_bytes=True):
 pass
 def unrelated(self, rtype, targettype, role='subject', limit=None,
 ordermethod=None):
 objs = Query(str(targettype)).Get(limit)
 else:
 objs = Query(str(targettype)).Run()
 return rset_from_objs(self.req, objs, ('eid',),
 'Any X WHERE X is %s' % targettype)
 def key(self):
 return Key(self.eid)
 def put(self, req=None):
 if req is not None and self.req is None:
 if self.req is not None and self.rset is None:
 self.rset = rset_from_objs(self.req, dbmodel, ('eid',),
 'Any X WHERE X eid %(x)s', {'x': self.eid})
 self.row = self.col = 0
 return dbmodel
 @needrequest
 def get(cls, req, keys):
 # if check if this is a dict.key call
 if isinstance(cls, Model) and keys in cls._attributes:
 return super(Model, cls).get(keys)
 def properties(cls):
 raise NotImplementedError('use eschema')
 def dynamic_properties(self):
 raise NotImplementedError('use eschema')
 def is_saved(self):
 return self.has_eid()
 def parent(self):
 parent = self._dbmodel.parent()
 TextProperty = db.TextProperty
 BlobProperty = db.BlobProperty
 IntegerProperty = db.IntegerProperty
 FloatProperty = db.FloatProperty
 ListProperty = db.ListProperty
 SelfReferenceProperty = db.SelfReferenceProperty
 UserProperty = db.UserProperty
 class ReferencePropertyStub(object):
 def __init__(self, cls, args, kwargs):

branch	tls-sprint
changeset 1802	d628defebc17
parent 1131	544609e83317
child 1977	606923dff11b