2013-06-27 14:20:22 +00:00
|
|
|
import cgi
|
2013-06-27 15:08:07 +00:00
|
|
|
import logging
|
2013-08-08 18:11:38 +00:00
|
|
|
import re
|
2013-06-27 14:20:22 +00:00
|
|
|
import types
|
|
|
|
|
2013-07-01 00:24:24 +00:00
|
|
|
#from openerp.tools.safe_eval import safe_eval as eval
|
2013-06-27 15:08:07 +00:00
|
|
|
|
2013-06-27 14:20:22 +00:00
|
|
|
import xml # FIXME use lxml
|
2013-06-27 15:08:07 +00:00
|
|
|
import xml.dom.minidom
|
2013-08-13 08:45:43 +00:00
|
|
|
import traceback
|
2013-08-14 15:10:18 +00:00
|
|
|
from openerp.osv import osv, orm
|
2013-06-27 15:08:07 +00:00
|
|
|
|
|
|
|
_logger = logging.getLogger(__name__)
|
2013-06-27 09:13:29 +00:00
|
|
|
|
2013-08-13 14:08:09 +00:00
|
|
|
BUILTINS = {
|
|
|
|
'False': False,
|
|
|
|
'None': None,
|
|
|
|
'True': True,
|
|
|
|
'abs': abs,
|
|
|
|
'bool': bool,
|
|
|
|
'dict': dict,
|
|
|
|
'filter': filter,
|
|
|
|
'len': len,
|
|
|
|
'list': list,
|
|
|
|
'map': map,
|
|
|
|
'max': max,
|
|
|
|
'min': min,
|
|
|
|
'reduce': reduce,
|
|
|
|
'repr': repr,
|
|
|
|
'round': round,
|
|
|
|
'set': set,
|
|
|
|
'str': str,
|
|
|
|
'tuple': tuple,
|
|
|
|
}
|
|
|
|
|
2013-08-08 18:11:38 +00:00
|
|
|
class QWebContext(dict):
|
|
|
|
def __init__(self, data, undefined_handler=None):
|
|
|
|
self.undefined_handler = undefined_handler
|
2013-08-13 14:08:09 +00:00
|
|
|
dic = BUILTINS.copy()
|
|
|
|
dic.update(data)
|
|
|
|
dict.__init__(self, dic)
|
2013-08-08 18:11:38 +00:00
|
|
|
self['defined'] = lambda key: key in self
|
|
|
|
|
|
|
|
def __getitem__(self, key):
|
|
|
|
if key in self:
|
|
|
|
return self.get(key)
|
2013-08-08 18:22:18 +00:00
|
|
|
elif not self.undefined_handler:
|
|
|
|
raise NameError("QWeb: name %r is not defined while rendering template %r" % (key, self.get('__template__')))
|
2013-06-27 09:13:29 +00:00
|
|
|
else:
|
2013-08-08 18:22:18 +00:00
|
|
|
return self.get(key, self.undefined_handler(key, self))
|
2013-06-27 09:13:29 +00:00
|
|
|
|
|
|
|
class QWebXml(object):
|
|
|
|
"""QWeb Xml templating engine
|
2013-06-27 15:08:07 +00:00
|
|
|
|
2013-06-27 09:13:29 +00:00
|
|
|
The templating engine use a very simple syntax, "magic" xml attributes, to
|
|
|
|
produce any kind of texutal output (even non-xml).
|
2013-06-27 15:08:07 +00:00
|
|
|
|
2013-06-27 09:13:29 +00:00
|
|
|
QWebXml:
|
|
|
|
the template engine core implements the basic magic attributes:
|
2013-06-27 15:08:07 +00:00
|
|
|
|
2013-06-27 09:13:29 +00:00
|
|
|
t-att t-raw t-esc t-if t-foreach t-set t-call t-trim
|
2013-06-27 15:08:07 +00:00
|
|
|
|
2013-06-27 09:13:29 +00:00
|
|
|
|
|
|
|
- loader: function that return a template
|
|
|
|
|
|
|
|
|
|
|
|
"""
|
2013-08-08 18:22:18 +00:00
|
|
|
def __init__(self, loader=None, undefined_handler=None):
|
2013-06-27 09:13:29 +00:00
|
|
|
self.loader = loader
|
2013-08-08 18:22:18 +00:00
|
|
|
self.undefined_handler = undefined_handler
|
2013-06-27 15:08:07 +00:00
|
|
|
self.node = xml.dom.Node
|
|
|
|
self._t = {}
|
|
|
|
self._render_tag = {}
|
2013-08-08 18:11:38 +00:00
|
|
|
self._format_regex = re.compile('#\{(.*?)\}')
|
2013-08-08 08:07:42 +00:00
|
|
|
self._void_elements = set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'keygen',
|
|
|
|
'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr'])
|
2013-06-27 15:08:07 +00:00
|
|
|
prefix = 'render_tag_'
|
2013-06-27 09:13:29 +00:00
|
|
|
for i in [j for j in dir(self) if j.startswith(prefix)]:
|
2013-06-27 15:08:07 +00:00
|
|
|
name = i[len(prefix):].replace('_', '-')
|
|
|
|
self._render_tag[name] = getattr(self.__class__, i)
|
2013-06-27 09:13:29 +00:00
|
|
|
|
2013-06-27 15:08:07 +00:00
|
|
|
self._render_att = {}
|
|
|
|
prefix = 'render_att_'
|
2013-06-27 09:13:29 +00:00
|
|
|
for i in [j for j in dir(self) if j.startswith(prefix)]:
|
2013-06-27 15:08:07 +00:00
|
|
|
name = i[len(prefix):].replace('_', '-')
|
|
|
|
self._render_att[name] = getattr(self.__class__, i)
|
|
|
|
|
|
|
|
def register_tag(self, tag, func):
|
|
|
|
self._render_tag[tag] = func
|
|
|
|
|
|
|
|
def add_template(self, x):
|
|
|
|
if hasattr(x, 'documentElement'):
|
|
|
|
dom = x
|
2013-06-27 09:13:29 +00:00
|
|
|
elif x.startswith("<?xml"):
|
2013-06-27 15:08:07 +00:00
|
|
|
dom = xml.dom.minidom.parseString(x)
|
2013-06-27 09:13:29 +00:00
|
|
|
else:
|
2013-06-27 15:08:07 +00:00
|
|
|
dom = xml.dom.minidom.parse(x)
|
2013-06-27 09:13:29 +00:00
|
|
|
for n in dom.documentElement.childNodes:
|
2013-08-21 09:45:35 +00:00
|
|
|
if n.nodeType == 1 and n.getAttribute('t-name'):
|
2013-06-27 15:08:07 +00:00
|
|
|
self._t[str(n.getAttribute("t-name"))] = n
|
2013-06-27 14:20:22 +00:00
|
|
|
|
|
|
|
def get_template(self, name):
|
2013-06-27 09:13:29 +00:00
|
|
|
if name in self._t:
|
|
|
|
return self._t[name]
|
2013-08-07 13:39:39 +00:00
|
|
|
elif self.loader:
|
2013-06-27 14:20:22 +00:00
|
|
|
xml = self.loader(name)
|
|
|
|
self.add_template(xml)
|
2013-06-27 09:13:29 +00:00
|
|
|
if name in self._t:
|
|
|
|
return self._t[name]
|
2013-06-27 14:20:22 +00:00
|
|
|
raise KeyError('qweb: template "%s" not found' % name)
|
2013-06-27 09:13:29 +00:00
|
|
|
|
2013-08-08 18:11:38 +00:00
|
|
|
def eval(self, expr, v):
|
|
|
|
try:
|
|
|
|
return eval(expr, None, v)
|
2013-08-14 15:10:18 +00:00
|
|
|
except (osv.except_osv, orm.except_orm), err:
|
|
|
|
raise orm.except_orm("QWeb Error", "Invalid expression %r while rendering template '%s'.\n\n%s" % (expr, v.get('__template__'), err[1]))
|
2013-08-08 18:11:38 +00:00
|
|
|
except Exception:
|
2013-08-13 08:45:43 +00:00
|
|
|
raise SyntaxError("QWeb: invalid expression %r while rendering template '%s'.\n\n%s" % (expr, v.get('__template__'), traceback.format_exc()))
|
2013-08-08 18:11:38 +00:00
|
|
|
|
2013-06-27 15:08:07 +00:00
|
|
|
def eval_object(self, expr, v):
|
2013-08-08 18:11:38 +00:00
|
|
|
return self.eval(expr, v)
|
2013-06-27 15:08:07 +00:00
|
|
|
|
|
|
|
def eval_str(self, expr, v):
|
2013-08-08 18:11:38 +00:00
|
|
|
if expr == "0":
|
|
|
|
return v.get(0, '')
|
|
|
|
val = self.eval(expr, v)
|
|
|
|
if isinstance(val, unicode):
|
|
|
|
return val.encode("utf8")
|
|
|
|
return str(val)
|
2013-06-27 15:08:07 +00:00
|
|
|
|
|
|
|
def eval_format(self, expr, v):
|
2013-08-08 18:11:38 +00:00
|
|
|
use_native = True
|
|
|
|
for m in self._format_regex.finditer(expr):
|
|
|
|
use_native = False
|
2013-08-08 22:39:38 +00:00
|
|
|
expr = expr.replace(m.group(), self.eval_str(m.groups()[0], v))
|
2013-08-08 18:11:38 +00:00
|
|
|
if not use_native:
|
|
|
|
return expr
|
|
|
|
else:
|
|
|
|
try:
|
|
|
|
return str(expr % v)
|
|
|
|
except:
|
|
|
|
raise Exception("QWeb: format error '%s' " % expr)
|
2013-06-27 15:08:07 +00:00
|
|
|
|
|
|
|
def eval_bool(self, expr, v):
|
2013-08-08 18:11:38 +00:00
|
|
|
val = self.eval(expr, v)
|
|
|
|
if val:
|
|
|
|
return 1
|
|
|
|
else:
|
|
|
|
return 0
|
2013-06-27 09:13:29 +00:00
|
|
|
|
2013-06-30 21:35:15 +00:00
|
|
|
def render(self, tname, v=None, out=None):
|
|
|
|
if v is None:
|
|
|
|
v = {}
|
2013-08-08 18:11:38 +00:00
|
|
|
v['__template__'] = tname
|
2013-08-12 10:52:11 +00:00
|
|
|
stack = v.get('__stack__', [])
|
|
|
|
if stack:
|
|
|
|
v['__caller__'] = stack[-1]
|
|
|
|
stack.append(tname)
|
|
|
|
v['__stack__'] = stack
|
2013-08-08 18:22:18 +00:00
|
|
|
v = QWebContext(v, self.undefined_handler)
|
2013-06-27 15:08:07 +00:00
|
|
|
return self.render_node(self.get_template(tname), v)
|
|
|
|
|
|
|
|
def render_node(self, e, v):
|
|
|
|
r = ""
|
|
|
|
if e.nodeType == self.node.TEXT_NODE or e.nodeType == self.node.CDATA_SECTION_NODE:
|
|
|
|
r = e.data.encode("utf8")
|
|
|
|
elif e.nodeType == self.node.ELEMENT_NODE:
|
|
|
|
g_att = ""
|
|
|
|
t_render = None
|
|
|
|
t_att = {}
|
|
|
|
for (an, av) in e.attributes.items():
|
|
|
|
an = str(an)
|
|
|
|
if isinstance(av, types.UnicodeType):
|
|
|
|
av = av.encode("utf8")
|
2013-06-27 09:13:29 +00:00
|
|
|
else:
|
2013-06-27 15:08:07 +00:00
|
|
|
av = av.nodeValue.encode("utf8")
|
2013-06-27 09:13:29 +00:00
|
|
|
if an.startswith("t-"):
|
|
|
|
for i in self._render_att:
|
|
|
|
if an[2:].startswith(i):
|
2013-06-27 15:08:07 +00:00
|
|
|
g_att += self._render_att[i](self, e, an, av, v)
|
2013-06-27 09:13:29 +00:00
|
|
|
break
|
|
|
|
else:
|
2013-06-27 15:08:07 +00:00
|
|
|
if an[2:] in self._render_tag:
|
|
|
|
t_render = an[2:]
|
|
|
|
t_att[an[2:]] = av
|
2013-06-27 09:13:29 +00:00
|
|
|
else:
|
2013-06-27 15:08:07 +00:00
|
|
|
g_att += ' %s="%s"' % (an, cgi.escape(av, 1))
|
2013-08-21 14:09:10 +00:00
|
|
|
|
|
|
|
if 'debug' in t_att:
|
|
|
|
debugger = t_att.get('debug', 'pdb')
|
|
|
|
__import__(debugger).set_trace() # pdb, ipdb, pudb, ...
|
2013-06-27 09:13:29 +00:00
|
|
|
if t_render:
|
2013-06-27 15:08:07 +00:00
|
|
|
if t_render in self._render_tag:
|
|
|
|
r = self._render_tag[t_render](self, e, t_att, g_att, v)
|
2013-06-27 09:13:29 +00:00
|
|
|
else:
|
2013-06-30 21:35:15 +00:00
|
|
|
r = self.render_element(e, t_att, g_att, v)
|
2013-06-27 09:13:29 +00:00
|
|
|
return r
|
2013-06-27 15:08:07 +00:00
|
|
|
|
2013-06-30 21:35:15 +00:00
|
|
|
def render_element(self, e, t_att, g_att, v, inner=None):
|
|
|
|
# e: element
|
|
|
|
# t_att: t-* attributes
|
|
|
|
# g_att: generated attributes
|
|
|
|
# v: values
|
|
|
|
# inner: optional innerXml
|
|
|
|
if inner:
|
|
|
|
g_inner = inner
|
|
|
|
else:
|
|
|
|
g_inner = []
|
|
|
|
for n in e.childNodes:
|
|
|
|
g_inner.append(self.render_node(n, v))
|
2013-06-27 15:08:07 +00:00
|
|
|
name = str(e.nodeName)
|
|
|
|
inner = "".join(g_inner)
|
2013-06-30 21:35:15 +00:00
|
|
|
trim = t_att.get("trim", 0)
|
2013-06-27 15:08:07 +00:00
|
|
|
if trim == 0:
|
2013-06-27 09:13:29 +00:00
|
|
|
pass
|
2013-06-27 15:08:07 +00:00
|
|
|
elif trim == 'left':
|
|
|
|
inner = inner.lstrip()
|
|
|
|
elif trim == 'right':
|
|
|
|
inner = inner.rstrip()
|
|
|
|
elif trim == 'both':
|
|
|
|
inner = inner.strip()
|
|
|
|
if name == "t":
|
2013-06-27 09:13:29 +00:00
|
|
|
return inner
|
2013-08-05 13:06:05 +00:00
|
|
|
elif len(inner) or name not in self._void_elements:
|
2013-06-30 21:35:15 +00:00
|
|
|
return "<%s%s>%s</%s>" % (name, g_att, inner, name)
|
2013-06-27 09:13:29 +00:00
|
|
|
else:
|
2013-06-27 15:08:07 +00:00
|
|
|
return "<%s%s/>" % (name, g_att)
|
2013-06-27 09:13:29 +00:00
|
|
|
|
|
|
|
# Attributes
|
2013-06-27 15:08:07 +00:00
|
|
|
def render_att_att(self, e, an, av, v):
|
2013-06-27 09:13:29 +00:00
|
|
|
if an.startswith("t-attf-"):
|
2013-06-27 15:08:07 +00:00
|
|
|
att, val = an[7:], self.eval_format(av, v)
|
2013-06-27 09:13:29 +00:00
|
|
|
elif an.startswith("t-att-"):
|
2013-06-27 15:08:07 +00:00
|
|
|
att, val = an[6:], self.eval_str(av, v)
|
2013-06-27 09:13:29 +00:00
|
|
|
else:
|
2013-06-27 15:08:07 +00:00
|
|
|
att, val = self.eval_object(av, v)
|
|
|
|
return ' %s="%s"' % (att, cgi.escape(val, 1))
|
2013-06-27 09:13:29 +00:00
|
|
|
|
|
|
|
# Tags
|
2013-06-27 15:08:07 +00:00
|
|
|
def render_tag_raw(self, e, t_att, g_att, v):
|
2013-06-30 21:35:15 +00:00
|
|
|
inner = self.eval_str(t_att["raw"], v)
|
2013-08-08 08:07:42 +00:00
|
|
|
return self.render_element(e, t_att, g_att, v, inner)
|
2013-06-27 15:08:07 +00:00
|
|
|
|
|
|
|
def render_tag_rawf(self, e, t_att, g_att, v):
|
2013-06-30 21:35:15 +00:00
|
|
|
inner = self.eval_format(t_att["rawf"], v)
|
2013-08-08 08:07:42 +00:00
|
|
|
return self.render_element(e, t_att, g_att, v, inner)
|
2013-06-27 15:08:07 +00:00
|
|
|
|
|
|
|
def render_tag_esc(self, e, t_att, g_att, v):
|
2013-06-30 21:35:15 +00:00
|
|
|
inner = cgi.escape(self.eval_str(t_att["esc"], v))
|
2013-08-08 08:07:42 +00:00
|
|
|
return self.render_element(e, t_att, g_att, v, inner)
|
2013-06-27 15:08:07 +00:00
|
|
|
|
|
|
|
def render_tag_escf(self, e, t_att, g_att, v):
|
2013-06-30 21:35:15 +00:00
|
|
|
inner = cgi.escape(self.eval_format(t_att["escf"], v))
|
2013-08-08 08:07:42 +00:00
|
|
|
return self.render_element(e, t_att, g_att, v, inner)
|
2013-06-27 15:08:07 +00:00
|
|
|
|
|
|
|
def render_tag_foreach(self, e, t_att, g_att, v):
|
|
|
|
expr = t_att["foreach"]
|
|
|
|
enum = self.eval_object(expr, v)
|
|
|
|
if enum is not None:
|
|
|
|
var = t_att.get('as', expr).replace('.', '_')
|
2013-08-08 18:22:18 +00:00
|
|
|
d = QWebContext(v.copy(), self.undefined_handler)
|
2013-06-27 15:08:07 +00:00
|
|
|
size = -1
|
2013-08-21 14:09:10 +00:00
|
|
|
if isinstance(enum, (types.ListType, types.TupleType)):
|
2013-06-27 15:08:07 +00:00
|
|
|
size = len(enum)
|
|
|
|
elif hasattr(enum, 'count'):
|
|
|
|
size = enum.count()
|
|
|
|
d["%s_size" % var] = size
|
|
|
|
d["%s_all" % var] = enum
|
|
|
|
index = 0
|
|
|
|
ru = []
|
2013-06-27 09:13:29 +00:00
|
|
|
for i in enum:
|
2013-06-27 15:08:07 +00:00
|
|
|
d["%s_value" % var] = i
|
|
|
|
d["%s_index" % var] = index
|
|
|
|
d["%s_first" % var] = index == 0
|
|
|
|
d["%s_even" % var] = index % 2
|
|
|
|
d["%s_odd" % var] = (index + 1) % 2
|
|
|
|
d["%s_last" % var] = index + 1 == size
|
|
|
|
if index % 2:
|
|
|
|
d["%s_parity" % var] = 'odd'
|
2013-06-27 09:13:29 +00:00
|
|
|
else:
|
2013-06-27 15:08:07 +00:00
|
|
|
d["%s_parity" % var] = 'even'
|
2013-08-21 14:09:10 +00:00
|
|
|
if 'as' in t_att:
|
2013-06-27 15:08:07 +00:00
|
|
|
d[var] = i
|
2013-08-21 14:09:10 +00:00
|
|
|
elif isinstance(i, types.DictType):
|
|
|
|
d.update(i)
|
2013-06-30 21:35:15 +00:00
|
|
|
ru.append(self.render_element(e, t_att, g_att, d))
|
2013-06-27 15:08:07 +00:00
|
|
|
index += 1
|
2013-06-27 09:13:29 +00:00
|
|
|
return "".join(ru)
|
|
|
|
else:
|
2013-08-21 14:09:10 +00:00
|
|
|
raise NameError("QWeb: foreach enumerator %r is not defined while rendering template %r" % (expr, v.get('__template__')))
|
2013-06-27 15:08:07 +00:00
|
|
|
|
|
|
|
def render_tag_if(self, e, t_att, g_att, v):
|
|
|
|
if self.eval_bool(t_att["if"], v):
|
2013-06-30 21:35:15 +00:00
|
|
|
return self.render_element(e, t_att, g_att, v)
|
2013-06-27 09:13:29 +00:00
|
|
|
else:
|
|
|
|
return ""
|
2013-06-27 15:08:07 +00:00
|
|
|
|
|
|
|
def render_tag_call(self, e, t_att, g_att, v):
|
|
|
|
if "import" in t_att:
|
|
|
|
d = v
|
2013-06-27 09:13:29 +00:00
|
|
|
else:
|
2013-08-08 18:22:18 +00:00
|
|
|
d = QWebContext(v.copy(), self.undefined_handler)
|
2013-06-30 21:35:15 +00:00
|
|
|
d[0] = self.render_element(e, t_att, g_att, d)
|
2013-06-27 15:08:07 +00:00
|
|
|
return self.render(t_att["call"], d)
|
|
|
|
|
|
|
|
def render_tag_set(self, e, t_att, g_att, v):
|
2013-07-02 12:00:18 +00:00
|
|
|
if "value" in t_att:
|
|
|
|
v[t_att["set"]] = self.eval_object(t_att["value"], v)
|
2013-08-08 22:39:38 +00:00
|
|
|
elif "valuef" in t_att:
|
|
|
|
v[t_att["set"]] = self.eval_format(t_att["valuef"], v)
|
2013-06-27 09:13:29 +00:00
|
|
|
else:
|
2013-06-30 21:35:15 +00:00
|
|
|
v[t_att["set"]] = self.render_element(e, t_att, g_att, v)
|
2013-06-27 09:13:29 +00:00
|
|
|
return ""
|
2013-06-30 21:35:15 +00:00
|
|
|
|
2013-07-01 15:55:41 +00:00
|
|
|
def render_tag_field(self, e, t_att, g_att, v):
|
|
|
|
""" eg: <span t-record="browse_record(res.partner, 1)" t-field="phone">+1 555 555 8069</span>"""
|
2013-08-04 20:23:31 +00:00
|
|
|
|
|
|
|
record, field = t_att["field"].rsplit('.', 1)
|
2013-08-04 20:27:20 +00:00
|
|
|
record = self.eval_object(record, v)
|
2013-07-01 15:55:41 +00:00
|
|
|
|
2013-07-02 16:48:05 +00:00
|
|
|
inner = ""
|
2013-07-26 13:35:05 +00:00
|
|
|
field_type = record._model._all_columns.get(field).column._type
|
2013-07-02 16:48:05 +00:00
|
|
|
try:
|
2013-07-26 13:35:05 +00:00
|
|
|
if field_type == 'many2one':
|
2013-08-06 09:15:54 +00:00
|
|
|
field_data = record.read([field])[0].get(field)
|
|
|
|
inner = field_data and field_data[1] or ""
|
2013-07-02 16:48:05 +00:00
|
|
|
else:
|
2013-07-31 10:21:40 +00:00
|
|
|
inner = getattr(record, field) or ""
|
2013-08-02 04:02:22 +00:00
|
|
|
if isinstance(inner, types.UnicodeType):
|
|
|
|
inner = inner.encode("utf8")
|
2013-07-31 10:21:40 +00:00
|
|
|
if field_type != 'html':
|
|
|
|
cgi.escape(str(inner))
|
2013-07-02 16:48:05 +00:00
|
|
|
if e.tagName != 't':
|
2013-07-26 13:35:05 +00:00
|
|
|
g_att += ''.join(
|
2013-07-30 15:09:05 +00:00
|
|
|
' %s="%s"' % (name, cgi.escape(str(value), True))
|
2013-07-26 13:35:05 +00:00
|
|
|
for name, value in [
|
|
|
|
('data-oe-model', record._model._name),
|
|
|
|
('data-oe-id', str(record.id)),
|
|
|
|
('data-oe-field', field),
|
|
|
|
('data-oe-type', field_type),
|
|
|
|
]
|
|
|
|
)
|
2013-07-02 16:48:05 +00:00
|
|
|
except AttributeError:
|
2013-07-26 13:35:05 +00:00
|
|
|
_logger.warning("t-field no field %s for model %s", field, record._model._name)
|
2013-07-01 15:55:41 +00:00
|
|
|
|
2013-08-08 08:07:42 +00:00
|
|
|
return self.render_element(e, t_att, g_att, v, str(inner))
|
2013-07-01 15:55:41 +00:00
|
|
|
|
2013-06-30 21:35:15 +00:00
|
|
|
# leave this, al.
|