261 lines
9.4 KiB
Python
261 lines
9.4 KiB
Python
# -*- coding: utf-8 -*-
|
|
""" Manages the storage and lifecycle of non-literal domains and contexts
|
|
(and potentially other structures) which have to be evaluated with client data,
|
|
but still need to be safely round-tripped to and from the browser (and thus
|
|
can't be sent there themselves).
|
|
"""
|
|
import binascii
|
|
import hashlib
|
|
import simplejson.encoder
|
|
|
|
__all__ = ['Domain', 'Context', 'NonLiteralEncoder, non_literal_decoder', 'CompoundDomain', 'CompoundContext']
|
|
|
|
#: 48 bits should be sufficient to have almost no chance of collision
|
|
#: with a million hashes, according to hg@67081329d49a
|
|
SHORT_HASH_BYTES_SIZE = 6
|
|
|
|
class NonLiteralEncoder(simplejson.encoder.JSONEncoder):
|
|
def default(self, object):
|
|
if not isinstance(object, (BaseDomain, BaseContext)):
|
|
return super(NonLiteralEncoder, self).default(object)
|
|
if isinstance(object, Domain):
|
|
return {
|
|
'__ref': 'domain',
|
|
'__id': object.key
|
|
}
|
|
elif isinstance(object, Context):
|
|
return {
|
|
'__ref': 'context',
|
|
'__id': object.key
|
|
}
|
|
elif isinstance(object, CompoundDomain):
|
|
return {
|
|
'__ref': 'compound_domain',
|
|
'__domains': object.domains,
|
|
'__eval_context': object.get_eval_context()
|
|
}
|
|
elif isinstance(object, CompoundContext):
|
|
return {
|
|
'__ref': 'compound_context',
|
|
'__contexts': object.contexts,
|
|
'__eval_context': object.get_eval_context()
|
|
}
|
|
raise TypeError('Could not encode unknown non-literal %s' % object)
|
|
|
|
def non_literal_decoder(dct):
|
|
""" Decodes JSON dicts into :class:`Domain` and :class:`Context` based on
|
|
magic attribute tags.
|
|
|
|
Also handles private context section for the domain or section via the
|
|
``own_values`` dict key.
|
|
"""
|
|
if '__ref' in dct:
|
|
if dct['__ref'] == 'domain':
|
|
domain = Domain(None, key=dct['__id'])
|
|
if 'own_values' in dct:
|
|
domain.own = dct['own_values']
|
|
return domain
|
|
elif dct['__ref'] == 'context':
|
|
context = Context(None, key=dct['__id'])
|
|
if 'own_values' in dct:
|
|
context.own = dct['own_values']
|
|
return context
|
|
elif dct["__ref"] == "compound_domain":
|
|
cdomain = CompoundDomain()
|
|
for el in dct["__domains"]:
|
|
cdomain.domains.append(el)
|
|
cdomain.set_eval_context(dct.get("__eval_context"))
|
|
return cdomain
|
|
elif dct["__ref"] == "compound_context":
|
|
ccontext = CompoundContext()
|
|
for el in dct["__contexts"]:
|
|
ccontext.contexts.append(el)
|
|
ccontext.set_eval_context(dct.get("__eval_context"))
|
|
return ccontext
|
|
return dct
|
|
|
|
# TODO: use abstract base classes if 2.6+?
|
|
class BaseDomain(object):
|
|
def evaluate(self, context=None):
|
|
raise NotImplementedError('Non literals must implement evaluate()')
|
|
|
|
class BaseContext(object):
|
|
def evaluate(self, context=None):
|
|
raise NotImplementedError('Non literals must implement evaluate()')
|
|
|
|
class Domain(BaseDomain):
|
|
def __init__(self, session, domain_string=None, key=None):
|
|
""" Uses session information to store the domain string and map it to a
|
|
domain key, which can be safely round-tripped to the client.
|
|
|
|
If initialized with a domain string, will generate a key for that
|
|
string and store the domain string out of the way. When initialized
|
|
with a key, considers this key is a reference to an existing domain
|
|
string.
|
|
|
|
:param session: the OpenERP Session to use when evaluating the domain
|
|
:type session: openerpweb.openerpweb.OpenERPSession
|
|
:param str domain_string: a non-literal domain in string form
|
|
:param str key: key used to retrieve the domain string
|
|
"""
|
|
if domain_string and key:
|
|
raise ValueError("A nonliteral domain can not take both a key "
|
|
"and a domain string")
|
|
|
|
self.session = session
|
|
self.own = {}
|
|
if domain_string:
|
|
self.key = binascii.hexlify(
|
|
hashlib.sha256(domain_string).digest()[:SHORT_HASH_BYTES_SIZE])
|
|
self.session.domains_store[self.key] = domain_string
|
|
elif key:
|
|
self.key = key
|
|
|
|
def get_domain_string(self):
|
|
""" Retrieves the domain string linked to this non-literal domain in
|
|
the provided session.
|
|
"""
|
|
return self.session.domains_store[self.key]
|
|
|
|
def evaluate(self, context=None):
|
|
""" Forces the evaluation of the linked domain, using the provided
|
|
context (as well as the session's base context), and returns the
|
|
evaluated result.
|
|
"""
|
|
ctx = self.session.evaluation_context(context)
|
|
if self.own:
|
|
ctx.update(self.own)
|
|
return eval(self.get_domain_string(), SuperDict(ctx))
|
|
|
|
class Context(BaseContext):
|
|
def __init__(self, session, context_string=None, key=None):
|
|
""" Uses session information to store the context string and map it to
|
|
a key (stored in a secret location under a secret mountain), which can
|
|
be safely round-tripped to the client.
|
|
|
|
If initialized with a context string, will generate a key for that
|
|
string and store the context string out of the way. When initialized
|
|
with a key, considers this key is a reference to an existing context
|
|
string.
|
|
|
|
:param session: the OpenERP Session to use when evaluating the context
|
|
:type session: openerpweb.openerpweb.OpenERPSession
|
|
:param str context_string: a non-literal context in string form
|
|
:param str key: key used to retrieve the context string
|
|
"""
|
|
if context_string and key:
|
|
raise ValueError("A nonliteral domain can not take both a key "
|
|
"and a domain string")
|
|
|
|
self.session = session
|
|
self.own = {}
|
|
if context_string:
|
|
self.key = binascii.hexlify(
|
|
hashlib.sha256(context_string).digest()[:SHORT_HASH_BYTES_SIZE])
|
|
self.session.contexts_store[self.key] = context_string
|
|
elif key:
|
|
self.key = key
|
|
|
|
def get_context_string(self):
|
|
""" Retrieves the context string linked to this non-literal context in
|
|
the provided session.
|
|
"""
|
|
return self.session.contexts_store[self.key]
|
|
|
|
def evaluate(self, context=None):
|
|
""" Forces the evaluation of the linked context, using the provided
|
|
context (as well as the session's base context), and returns the
|
|
evaluated result.
|
|
"""
|
|
ctx = self.session.evaluation_context(context)
|
|
if self.own:
|
|
ctx.update(self.own)
|
|
return eval(self.get_context_string(), SuperDict(ctx))
|
|
|
|
class SuperDict(dict):
|
|
def __getattr__(self, name):
|
|
try:
|
|
return self[name]
|
|
except KeyError:
|
|
raise AttributeError(name)
|
|
def __getitem__(self, key):
|
|
tmp = super(SuperDict, self).__getitem__(key)
|
|
if isinstance(tmp, dict):
|
|
return SuperDict(tmp)
|
|
return tmp
|
|
|
|
class CompoundDomain(BaseDomain):
|
|
def __init__(self, *domains):
|
|
self.domains = []
|
|
self.session = None
|
|
self.eval_context = None
|
|
for domain in domains:
|
|
self.add(domain)
|
|
|
|
def evaluate(self, context=None):
|
|
final_domain = []
|
|
for domain in self.domains:
|
|
if not isinstance(domain, (list, BaseDomain)):
|
|
raise TypeError(
|
|
"Domain %r is not a list or a nonliteral Domain" % domain)
|
|
|
|
if isinstance(domain, list):
|
|
final_domain.extend(domain)
|
|
continue
|
|
|
|
ctx = dict(context or {})
|
|
ctx.update(self.get_eval_context() or {})
|
|
|
|
domain.session = self.session
|
|
final_domain.extend(domain.evaluate(ctx))
|
|
return final_domain
|
|
|
|
def add(self, domain):
|
|
self.domains.append(domain)
|
|
return self
|
|
|
|
def set_eval_context(self, eval_context):
|
|
self.eval_context = eval_context
|
|
return self
|
|
|
|
def get_eval_context(self):
|
|
return self.eval_context
|
|
|
|
class CompoundContext(BaseContext):
|
|
def __init__(self, *contexts):
|
|
self.contexts = []
|
|
self.eval_context = None
|
|
self.session = None
|
|
for context in contexts:
|
|
self.add(context)
|
|
|
|
def evaluate(self, context=None):
|
|
ctx = dict(context or {})
|
|
ctx.update(self.get_eval_context() or {})
|
|
final_context = {}
|
|
for context_to_eval in self.contexts:
|
|
if not isinstance(context_to_eval, (dict, BaseContext)):
|
|
raise TypeError(
|
|
"Context %r is not a dict or a nonliteral Context" % context_to_eval)
|
|
|
|
if isinstance(context_to_eval, dict):
|
|
final_context.update(context_to_eval)
|
|
continue
|
|
|
|
ctx.update(final_context)
|
|
|
|
context_to_eval.session = self.session
|
|
final_context.update(context_to_eval.evaluate(ctx))
|
|
return final_context
|
|
|
|
def add(self, context):
|
|
self.contexts.append(context)
|
|
return self
|
|
|
|
def set_eval_context(self, eval_context):
|
|
self.eval_context = eval_context
|
|
return self
|
|
|
|
def get_eval_context(self):
|
|
return self.eval_context
|