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_many(self, keys):
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])
keys = keys[100:]
return things
data = dict(keys=simplejson.dumps(keys))
result = self._request('/get_many', data=data)
things = []
import copy
for key in keys:
#@@ what if key is not there?
if key in result:
data = result[key]
data = web.storage(common.parse_query(data))
self._cache[key, None] = data
things.append(create_thing(self, key, self._process_dict(copy.deepcopy(data))))
return things
def process(self, key, data):
if 'key' not in data:
data['key'] = key
assert data['key'] == key
data = common.parse_query(data)
self.validate_properties(data)
if not web.ctx.get('disable_permission_check', False) and not has_permission(self.store, 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")
type = self.process_value(type, self.get_property(None, 'type'))
type = get_thing(self.store, type)
thing = get_thing(self.store, key)
prev_data = thing and thing._get_data()
# 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 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 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 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 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_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 _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 _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 _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, e:
if e.status.startswith('404'):
raise NotFound, key
else:
raise
self._cache[key, revision] = web.storage(common.parse_query(result))
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, e:
if e.status.startswith('404'):
raise NotFound, key
else:
raise
self._cache[key, revision] = web.storage(common.parse_query(result))
def main(wf):
import common
common.log = log
log.debug('-' * 40)
common.set_locale()
lc, encoding = locale.getlocale()
log.debug('args : {}'.format(wf.args))
log.debug('locale : {} encoding : {}'.format(lc, encoding))
if len(wf.args):
query = wf.args[0]
else:
query = None
log.debug('query : {}'.format(query))
if not query or query in ('0', 'now', 'today'):
dt = date.today()
else:
dt = common.parse_query(query)
if not dt: # Didn't understand query
wf.add_item("Couldn't understand '{}'".format(query),
"Use 'datehelp' for help on formatting",
valid=False, icon=ICON_ERROR)
wf.send_feedback()
return 0
log.debug('date : {0.year}-{0.month}-{0.day}'.format(dt))
# get date formats
for i, fmt in enumerate(common.get_formats()):
value = unicode(common.date_with_format(dt, fmt), encoding)
wf.add_item(value,
'Copy to clipboard',
arg=value,
valid=True,
uid='date-{:02d}'.format(i),
icon='icon.png')
wf.send_feedback()
log.debug('finished.')
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 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 get_many(self, keys):
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])
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]
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 from_dict(store, key, data):
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 new(self, key, data=None):
"""Creates a new thing in memory.
"""
data = common.parse_query(data)
data = self._process_dict(data or {})
return create_thing(self, key, data)
def from_dict(store, key, data):
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 new(self, key, data=None):
"""Creates a new thing in memory.
"""
data = common.parse_query(data)
data = self._process_dict(data or {})
return create_thing(self, key, data)
