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 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 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 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)