def get_many(self, keys, raw=False):
"""When raw=True, the raw data is returned instead of objects.
"""
if not keys:
return []
# simple hack to avoid crossing URL length limit.
if len(keys) > 100:
things = []
while keys:
things += self.get_many(keys[:100], raw=raw)
keys = keys[100:]
return things
data = dict(keys=simplejson.dumps(keys))
result = self._request('/get_many', data=data)
things = []
for key in keys:
#@@ what if key is not there?
if key in result:
data = result[key]
if raw:
things.append(data)
else:
data = web.storage(common.parse_query(data))
self._cache[key, None] = data
things.append(
create_thing(self, key, self._process_dict(data)))
return things
def get_doc(key):
doc = docs[key]
del doc['_id']
del doc['_rev']
if not _raw:
data = self._site._process_dict(common.parse_query(doc))
doc = client.create_thing(self._site, doc['key'], data)
return doc
def get_doc(key):
doc = docs[key]
del doc['_id']
del doc['_rev']
if not _raw:
data = self._site._process_dict(common.parse_query(doc))
doc = client.create_thing(self._site, doc['key'], data)
return doc
def make_query(store, query, prefix=""):
"""Creates a query object from query dict.
>>> store = common.create_test_store()
>>> make_query(store, {'type': '/type/page'})
<query: ['type = ref:/type/page']>
>>> make_query(store, {'type': '/type/page', 'title~': 'foo', 'life': 42})
<query: ['life = int:42', 'type = ref:/type/page', 'title ~ str:foo']>
>>> make_query(store, {'type': '/type/page', 'title~': 'foo', 'a:life<': 42, "b:life>": 420})
<query: ['life < int:42', 'type = ref:/type/page', 'title ~ str:foo', 'life > int:420']>
"""
query = common.parse_query(query)
q = Query()
q.prefix = prefix
q.offset = common.safeint(query.pop('offset', None), 0)
q.limit = common.safeint(query.pop('limit', 20), 20)
if q.limit > 1000:
q.limit = 1000
sort = query.pop('sort', None)
nested = (prefix != "")
for k, v in query.items():
# key foo can also be written as label:foo
k = k.split(':')[-1]
if v is None:
q.requested[k] = v
elif isinstance(v, dict):
# make sure op is ==
v = dict((k + '.' + key, value) for key, value in v.items())
q2 = make_query(store, v, prefix=prefix + k + ".")
#@@ Anand: Quick-fix
# dbstore.things looks for key to find whether type is required or not.
q2.key = k
if q2.conditions:
q.conditions.append(q2)
else:
q.requested[k] = q2
else:
k, op = parse_key(k)
q.add_condition(k, op, None, v)
if not nested:
q.assert_type_required()
type = get_thing(store, q.get_type())
#assert type is not None, 'Not found: ' + q.get_type()
for c in q.conditions:
if not isinstance(c, Query):
c.datatype = find_datatype(type, c.key, c.value)
if sort:
parse_key(sort) # to validate key
q.sort = web.storage(key=sort,
datatype=find_datatype(type, sort, None))
else:
q.sort = None
return q
def _process(self, key, data, prev_data=None):
self.key = key # hack to make key available when raising exceptions.
if 'key' not in data:
data['key'] = key
if web.ctx.get('infobase_bootstrap', False):
return data
assert data['key'] == key
data = common.parse_query(data)
self.validate_properties(data)
prev_data = prev_data and common.parse_query(prev_data)
if not web.ctx.get(
'disable_permission_check', False
) and not self.has_permission(self.author, key):
raise common.PermissionDenied(
message='Permission denied to modify %s' % repr(key)
)
type = data.get('type')
if type is None:
raise common.BadData(message="missing type", at=dict(key=key))
type = self.process_value(type, self.get_property(None, 'type'))
type = self.get_thing(type)
# when type is changed, consider as all object is modified and don't compare with prev data.
if prev_data and prev_data.get('type') != type.key:
prev_data = None
data = self.process_data(data, type, prev_data)
for k in common.READ_ONLY_PROPERTIES:
data.pop(k, None)
prev_data and prev_data.pop(k, None)
if data == prev_data:
return None
else:
return data
def add(self, doc):
#@@ UGLY!
doc = common.parse_query(doc)
doc = client.Site(None, None)._process_dict(doc)
key = doc['key']
self.docs[key] = client.create_thing(self, key, doc)
olid = key.split("/")[-1]
if web.re_compile(r'OL\d+[A-Z]').match(olid):
self.olids[olid] = key
def add(self, doc):
#@@ UGLY!
doc = common.parse_query(doc)
doc = client.Site(None, None)._process_dict(doc)
key = doc['key']
self.docs[key] = client.create_thing(self, key, doc)
olid = key.split("/")[-1]
if web.re_compile(r'OL\d+[A-Z]').match(olid):
self.olids[olid] = key
def get_user(self):
# avoid hitting infobase when there is no cookie.
if web.cookies().get(config.login_cookie_name) is None:
return None
try:
data = self._request('/account/get_user')
except ClientException:
return None
user = data and create_thing(
self, data['key'], self._process_dict(common.parse_query(data)))
return user
def _get(self, key, revision=None):
"""Returns properties of the thing with the specified key."""
revision = revision and int(revision)
if (key, revision) not in self._cache:
data = dict(key=key, revision=revision)
try:
result = self._request('/get', data=data)
except ClientException as e:
if e.status.startswith('404'):
raise NotFound(key)
else:
raise
self._cache[key,
revision] = web.storage(common.parse_query(result))
return self._cache[key, revision]
def process(self, query):
p = SaveProcessor(self.store, self.author)
for q in serialize(query):
q = common.parse_query(q)
if not isinstance(q, dict) or q.get('key') is None:
continue
key = q['key']
thing = get_thing(self.store, key)
create = q.pop('create', None)
if thing is None:
if create:
q = self.remove_connects(q)
else:
raise common.NotFound(key=key)
else:
q = self.connect_all(thing._data, q)
yield p.process(key, q)
def make_doc(self, rawdata):
data = web.ctx.site._process_dict(common.parse_query(rawdata))
doc = client.create_thing(web.ctx.site, data['key'], data)
return doc
def new(self, key, data=None):
"""Creates a new thing in memory.
"""
data = common.parse_query(data)
data = self._process_dict(data or {})
return client.create_thing(self, key, data)
def _load(self, key, revision=None):
doc = self.get(key, revision=revision)
data = doc.dict()
data = web.storage(common.parse_query(data))
return self._process_dict(data)
def get(self, key, revision=None):
data = self.docs.get(key)
data = data and web.storage(common.parse_query(data))
return data and client.create_thing(self, key, self._process_dict(data))
def make_doc(self, rawdata):
data = web.ctx.site._process_dict(common.parse_query(rawdata))
doc = client.create_thing(web.ctx.site, data['key'], data)
return doc
def from_dict(store, key, data):
from infogami.infobase import common
data = common.parse_query(data)
return Thing(store, key, data)
def update(self, data):
data = common.parse_query(data)
data = self._site._process_dict(data)
self._getdata().update(data)
def get(self, key):
doc = self.docs[key]
# black magic
data = self._process_dict(common.parse_query(doc))
return client.create_thing(self, key, data)
def get(self, key):
doc = self.docs[key]
# black magic
data = self._process_dict(common.parse_query(doc))
return client.create_thing(self, key, data)
