def get_o2m_defaults(self, o2m_values, model, o2m_model, name, view_type, view_id,
o2m_view_type, o2m_view_id, editable, limit, offset, o2m_context, o2m_domain):
view_id = view_id or False
o2m_view_id = ast.literal_eval(o2m_view_id) or False
o2m_view_type = o2m_view_type or 'form'
context = dict(ast.literal_eval(o2m_context), **rpc.get_session().context)
o2m_values = simplejson.loads(o2m_values)
for o2m in o2m_values:
o2m['id'] = 0
if o2m_view_id:
view = cache.fields_view_get(o2m_model, o2m_view_id, o2m_view_type, context)
else:
view = cache.fields_view_get(model, view_id, view_type, rpc.get_session().context)
view = view['fields'][name]['views'][o2m_view_type]
list_view = listgrid.List(name, model, view, ids=None, domain=o2m_domain, context=context, default_data=copy.deepcopy(o2m_values), limit=20, editable= editable,o2m=1)
view=ustr(list_view.render())
formated_o2m_values = []
for o2m in o2m_values:
o2m.pop('id', None)
formated_o2m_values.append((0, 0, o2m))
return dict(view=view, formated_o2m_values=ustr(formated_o2m_values))
def create(self, params):
view_id = (params.view_ids or False) and params.view_ids[0]
domain = params.domain
context = params.context
ctx = dict(context, **rpc.session.context)
res_id = params.ids or 0
model = params.model
if view_id:
view_base = rpc.session.execute('object', 'execute', 'ir.ui.view',
'read', [view_id],
['model', 'type'], context)[0]
model = view_base['model']
view = cache.fields_view_get(model, view_id, view_base['type'],
context)
else:
view = cache.fields_view_get(model, False, 'tree', context)
fields = cache.fields_get(view['model'], False, context)
tree = tree_view.ViewTree(view,
model,
res_id,
domain=domain,
context=context,
action="/tree/action",
fields=fields)
if tree.toolbar:
proxy = rpc.RPCProxy(model)
for tool in tree.toolbar:
if tool.get('icon'):
tool['icon'] = icons.get_icon(tool['icon'])
else:
tool['icon'] = False
id = tool['id']
ids = proxy.read([id], [tree.field_parent],
ctx)[0][tree.field_parent]
tool['ids'] = ids
can_shortcut = self.can_shortcut_create()
shortcut_ids = []
for sc in cherrypy.session.get('terp_shortcuts') or []:
if isinstance(sc['res_id'], tuple):
shortcut_ids.append(sc['res_id'][0])
else:
shortcut_ids.append(sc['res_id'])
return {
'tree': tree,
'model': model,
'can_shortcut': can_shortcut,
'shortcut_ids': shortcut_ids
}
def multiple_groupby(self, model, name, grp_domain, group_by, view_id, view_type, parent_group, group_level, groups, no_leaf, **kw):
grp_domain = ast.literal_eval(grp_domain)
view = cache.fields_view_get(model, view_id, view_type, rpc.session.context.copy())
group_by = ast.literal_eval(group_by)
domain = grp_domain
params = TinyDict(**kw)
editable = params.editable
selectable = params.selectable or 2
context = params.context or {}
context.update({'group_by_no_leaf': int(no_leaf), 'group_by': group_by, '__domain': domain})
group_level = ast.literal_eval(group_level)
groups = ast.literal_eval(groups)
offset = params.offset or 0
limit = params.limit or 20
args = {'editable': editable,
'view_mode': ['tree', 'form', 'calendar', 'graph'],
'nolinks': 1, 'group_by_ctx': group_by,
'selectable': selectable,
'multiple_group_by': True,
'offset': offset, 'limit': limit,
'sort_key': kw.get('sort_key'),
'sort_order': kw.get('sort_order')}
listgrp = listgroup.MultipleGroup(name, model, view, ids=None, domain= domain, parent_group=parent_group, group_level=group_level, groups=groups, context=context, **args)
return listgrp.render()
def reload_graph(self, **kw):
params, data = TinyDict.split(kw)
view = cache.fields_view_get(params.model, params.view_id, 'graph',params.context)
if params.group_by_ctx:
if isinstance(params.group_by_ctx, str):
params.group_by_ctx = params.group_by_ctx.split('group_')[-1]
else:
params.group_by_ctx = map(lambda x: x.split('group_')[-1], params.group_by_ctx)
if params.domain is None:
params.domain = []
if params.search_domain:
params.domain.extend(params.search_domain)
if not params.group_by_ctx:
params.ids = None
from view_graph.widgets import _graph
wid = _graph.Graph(model=params.model,
view=view,
view_id=params.view_id,
ids=params.ids, domain=params.domain,
view_mode = params.view_mode,
context=params.context,
group_by = params.group_by_ctx)
view=ustr(wid.render())
return dict(view = view)
def multiple_groupby(self, model, name, grp_domain, group_by, view_id, view_type, parent_group, group_level, groups, no_leaf, **kw):
grp_domain = ast.literal_eval(grp_domain)
view = cache.fields_view_get(model, view_id, view_type, rpc.session.context.copy())
group_by = ast.literal_eval(group_by)
domain = grp_domain
group_level = ast.literal_eval(group_level)
groups = ast.literal_eval(groups)
# build a new TinyDict to correctly handle _terp_* params
params = TinyDict(**kw)
editable = params.editable
selectable = params.selectable or 2
context = params.context or {}
context.update({'group_by_no_leaf': int(no_leaf), 'group_by': group_by, '__domain': domain})
# we force offset to 0, as in group_by mode only 'limit' have an effect
# (offset pagination in only for base grouping - which is handled by ListGroup)
offset = 0
limit = params.limit or 20
args = {'editable': editable,
'view_mode': ['tree', 'form', 'calendar', 'graph'],
'nolinks': 1, 'group_by_ctx': group_by,
'selectable': selectable,
'multiple_group_by': True,
'sort_key': kw.get('sort_key'),
'offset': offset, 'limit': limit,
'sort_order': kw.get('sort_order')}
listgrp = listgroup.MultipleGroup(name, model, view, ids=None, domain= domain, parent_group=parent_group, group_level=group_level, groups=groups, context=context, **args)
return listgrp.render()
def reload_graph(self, **kw):
params, data = TinyDict.split(kw)
view = cache.fields_view_get(params.model, params.view_id, 'graph',
params.context)
if params.group_by_ctx:
if isinstance(params.group_by_ctx, str):
params.group_by_ctx = params.group_by_ctx.split('group_')[-1]
else:
params.group_by_ctx = map(lambda x: x.split('group_')[-1],
params.group_by_ctx)
if params.domain is None:
params.domain = []
if params.search_domain:
params.domain.extend(params.search_domain)
if not params.group_by_ctx:
params.ids = None
from view_graph.widgets import _graph
wid = _graph.Graph(model=params.model,
view=view,
view_id=params.view_id,
ids=params.ids,
domain=params.domain,
view_mode=params.view_mode,
context=params.context,
group_by=params.group_by_ctx)
view = ustr(wid.render())
return dict(view=view)
def __init__(self, model, view=False, view_id=False, ids=[], domain=[], context={},view_mode=[], group_by=[], width=360, height=300):
name = 'graph_%s' % (random.randint(0,10000))
super(Graph, self).__init__(name=name, model=model, width=width, height=height)
ctx = rpc.get_session().context.copy()
ctx.update(context or {})
view = view or cache.fields_view_get(model, view_id, 'graph', ctx)
dom = xml.dom.minidom.parseString(view['arch'].encode('utf-8'))
root = dom.childNodes[0]
attrs = node_attributes(root)
self.string = attrs.get('string')
self.group_by = group_by
chart_type = attrs.get('type', 'pie')
self.ids = ids
if chart_type == "bar":
self.data = BarChart(model, view, view_id, ids, domain, view_mode, context, group_by)
else:
self.data = PieChart(model, view, view_id, ids, domain, view_mode, context, group_by)
self.data = simplejson.dumps(self.data.get_data())
def menu(self, active=None, next=None):
from openerp.widgets import tree_view
try:
id = int(active)
except:
id = False
form.Form().reset_notebooks()
ctx = rpc.session.context.copy()
menus = rpc.RPCProxy("ir.ui.menu")
domain = [('parent_id', '=', False)]
user_menu_action_id = rpc.RPCProxy("res.users").read([rpc.session.uid], ['menu_id'], ctx)[0]['menu_id']
if user_menu_action_id:
act = rpc.RPCProxy('ir.actions.act_window').read([user_menu_action_id[0]], ['res_model', 'domain'], ctx)[0]
if act['res_model'] == 'ir.ui.menu' and act['domain']:
domain = literal_eval(act['domain'])
ids = menus.search(domain, 0, 0, 0, ctx)
parents = menus.read(ids, ['name', 'action', 'web_icon_data', 'web_icon_hover_data'], ctx)
for parent in parents:
if parent['id'] == id:
parent['active'] = 'active'
if parent.get('action') and not next:
next = url('/openerp/custom_action', action=id)
# If only the hover image exists, use it as regular image as well
if parent['web_icon_hover_data'] and not parent['web_icon_data']:
parent['web_icon_data'] = parent['web_icon_hover_data']
if next or active:
if not id and ids:
id = ids[0]
ids = menus.search([('parent_id', '=', id)], 0, 0, 0, ctx)
tools = menus.read(ids, ['name', 'action'], ctx)
#searching id for the hierarchycal tree view of ir.ui.menu
view_id = rpc.RPCProxy('ir.ui.view').search([('model','=','ir.ui.menu'),('type','=','tree')],0,0,'id')[0]
view = cache.fields_view_get('ir.ui.menu', view_id, 'tree', {})
fields = cache.fields_get(view['model'], False, ctx)
for tool in tools:
tid = tool['id']
tool['tree'] = tree = tree_view.ViewTree(view, 'ir.ui.menu', tid,
domain=[('parent_id', '=', tid)],
context=ctx, action="/openerp/tree/action", fields=fields)
tree._name = "tree_%s" %(tid)
tree.tree.onselection = None
tree.tree.onheaderclick = None
tree.tree.showheaders = 0
else:
# display home action
tools = None
return dict(parents=parents, tools=tools, load_content=(next and next or ''),
welcome_messages=rpc.RPCProxy('publisher_warranty.contract').get_last_user_messages(_MAXIMUM_NUMBER_WELCOME_MESSAGES),
show_close_btn=rpc.session.uid == 1,
widgets=openobject.pooler.get_pool()\
.get_controller('/openerp/widgets')\
.user_home_widgets(ctx))
def get_m2m(self, name, model, view_id, view_type, ids):
view_id = ast.literal_eval(view_id) or False
ids = ast.literal_eval(ids) or []
view = cache.fields_view_get(model, view_id, view_type, rpc.get_session().context)
m2m_view = listgrid.List(name, model, view, ids,limit=20, editable=True, m2m=1)
m2m_view = ustr(m2m_view.render())
return dict(m2m_view = m2m_view)
def create(self, params):
view_id = (params.view_ids or False) and params.view_ids[0]
domain = params.domain
context = params.context
ctx = dict(context,
**rpc.session.context)
res_id = params.ids or 0
model = params.model
if view_id:
view_base = rpc.session.execute(
'object', 'execute', 'ir.ui.view', 'read', [view_id],
['model', 'type'], context)[0]
model = view_base['model']
view = cache.fields_view_get(model, view_id, view_base['type'], context)
else:
view = cache.fields_view_get(model, False, 'tree', context)
fields = cache.fields_get(view['model'], False, context)
tree = tree_view.ViewTree(view, model, res_id, domain=domain, context=context, action="/tree/action", fields=fields)
if tree.toolbar:
proxy = rpc.RPCProxy(model)
for tool in tree.toolbar:
if tool.get('icon'):
tool['icon'] = icons.get_icon(tool['icon'])
else:
tool['icon'] = False
id = tool['id']
ids = proxy.read([id], [tree.field_parent], ctx)[0][tree.field_parent]
tool['ids'] = ids
can_shortcut = self.can_shortcut_create()
shortcut_ids = []
for sc in cherrypy.session.get('terp_shortcuts') or []:
if isinstance(sc['res_id'], tuple):
shortcut_ids.append(sc['res_id'][0])
else:
shortcut_ids.append(sc['res_id'])
return {'tree': tree, 'model': model, 'can_shortcut': can_shortcut, 'shortcut_ids': shortcut_ids}
def get_o2m_defaults(self, o2m_values, model, o2m_model, name, view_type,
view_id, o2m_view_type, o2m_view_id, editable, limit,
offset, o2m_context, o2m_domain):
view_id = view_id or False
o2m_view_id = ast.literal_eval(o2m_view_id) or False
o2m_view_type = o2m_view_type or 'form'
context = dict(ast.literal_eval(o2m_context), **rpc.session.context)
o2m_values = simplejson.loads(o2m_values)
for o2m in o2m_values:
o2m['id'] = 0
if o2m_view_id:
view = cache.fields_view_get(o2m_model, o2m_view_id, o2m_view_type,
context)
else:
view = cache.fields_view_get(model, view_id, view_type,
rpc.session.context)
view = view['fields'][name]['views'][o2m_view_type]
list_view = listgrid.List(name,
model,
view,
ids=None,
domain=o2m_domain,
context=context,
default_data=copy.deepcopy(o2m_values),
limit=20,
editable=editable,
o2m=1)
view = ustr(list_view.render())
formated_o2m_values = []
for o2m in o2m_values:
o2m.pop('id', None)
formated_o2m_values.append((0, 0, o2m))
return dict(view=view, formated_o2m_values=ustr(formated_o2m_values))
def get_m2m(self, name, model, view_id, view_type, ids):
view_id = ast.literal_eval(view_id) or False
ids = ast.literal_eval(ids) or []
view = cache.fields_view_get(model, view_id, view_type,
rpc.session.context)
m2m_view = listgrid.List(name,
model,
view,
ids,
limit=20,
editable=True,
m2m=1)
m2m_view = ustr(m2m_view.render())
return dict(m2m_view=m2m_view)
def add_view_id(self, view_id, view_type):
self.view_id = view_id
if view_type in self.views_preloaded:
view = self.views_preloaded[view_type]
else:
ctx = rpc.get_session().context.copy()
ctx.update(self.context)
if ctx.get('view_id'):
view_id = ctx['view_id']
if 'view_id' in cherrypy.request.terp_params['_terp_context']:
cherrypy.request.terp_params['_terp_context'].pop('view_id')
view = cache.fields_view_get(self.model, view_id or False, view_type, ctx, self.hastoolbar, self.hassubmenu)
self.add_view(view, view_type)
def multiple_groupby(self, model, name, grp_domain, group_by, view_id,
view_type, parent_group, group_level, groups, no_leaf,
**kw):
grp_domain = ast.literal_eval(grp_domain)
view = cache.fields_view_get(model, view_id, view_type,
rpc.session.context.copy())
group_by = ast.literal_eval(group_by)
domain = grp_domain
group_level = ast.literal_eval(group_level)
groups = ast.literal_eval(groups)
# build a new TinyDict to correctly handle _terp_* params
params = TinyDict(**kw)
editable = params.editable
selectable = params.selectable or 2
context = params.context or {}
context.update({
'group_by_no_leaf': int(no_leaf),
'group_by': group_by,
'__domain': domain
})
# we force offset to 0, as in group_by mode only 'limit' have an effect
# (offset pagination in only for base grouping - which is handled by ListGroup)
offset = 0
limit = params.limit or 20
args = {
'editable': editable,
'view_mode': ['tree', 'form', 'calendar', 'graph'],
'nolinks': 1,
'group_by_ctx': group_by,
'selectable': selectable,
'multiple_group_by': True,
'sort_key': kw.get('sort_key'),
'offset': offset,
'limit': limit,
'sort_order': kw.get('sort_order')
}
listgrp = listgroup.MultipleGroup(name,
model,
view,
ids=None,
domain=domain,
parent_group=parent_group,
group_level=group_level,
groups=groups,
context=context,
**args)
return listgrp.render()
def add_view_id(self, view_id, view_type):
self.view_id = view_id
if view_type in self.views_preloaded:
view = self.views_preloaded[view_type]
else:
ctx = rpc.session.context.copy()
ctx.update(self.context)
if ctx.get("view_id"):
view_id = ctx["view_id"]
self.view_ids = [ctx["view_id"]]
if "view_id" in cherrypy.request.terp_params["_terp_context"]:
cherrypy.request.terp_params["_terp_context"].pop("view_id")
view = cache.fields_view_get(self.model, view_id or False, view_type, ctx, self.hastoolbar, self.hassubmenu)
self.add_view(view, view_type)
def multiple_groupby(self, model, name, grp_domain, group_by, view_id, view_type, parent_group, group_level, groups, no_leaf, **kw):
grp_domain = ast.literal_eval(grp_domain)
view = cache.fields_view_get(model, view_id, view_type, rpc.get_session().context.copy())
group_by = ast.literal_eval(group_by)
domain = grp_domain
group_level = ast.literal_eval(group_level)
groups = ast.literal_eval(groups)
context = {'group_by_no_leaf': int(no_leaf), 'group_by': group_by, '__domain': domain}
args = {'editable': True,
'view_mode': ['tree', 'form', 'calendar', 'graph'],
'nolinks': 1, 'group_by_ctx': group_by,
'selectable': 2,
'multiple_group_by': True,
'sort_key': kw.get('sort_key'),
'sort_order': kw.get('sort_order')}
listgrp = listgroup.MultipleGroup(name, model, view, ids=None, domain= domain, parent_group=parent_group, group_level=group_level, groups=groups, context=context, **args)
return listgrp.render()
def multiple_groupby(self, model, name, grp_domain, group_by, view_id,
view_type, parent_group, group_level, groups, no_leaf,
**kw):
grp_domain = ast.literal_eval(grp_domain)
view = cache.fields_view_get(model, view_id, view_type,
rpc.session.context.copy())
group_by = ast.literal_eval(group_by)
domain = grp_domain
group_level = ast.literal_eval(group_level)
groups = ast.literal_eval(groups)
context = {
'group_by_no_leaf': int(no_leaf),
'group_by': group_by,
'__domain': domain
}
args = {
'editable': True,
'view_mode': ['tree', 'form', 'calendar', 'graph'],
'nolinks': 1,
'group_by_ctx': group_by,
'selectable': 2,
'multiple_group_by': True,
'sort_key': kw.get('sort_key'),
'sort_order': kw.get('sort_order')
}
listgrp = listgroup.MultipleGroup(name,
model,
view,
ids=None,
domain=domain,
parent_group=parent_group,
group_level=group_level,
groups=groups,
context=context,
**args)
return listgrp.render()
def index(self, translate='fields', **kw):
params, data = TinyDict.split(kw)
ctx = dict((params.context or {}), **rpc.session.context)
params['context'] = ustr(ctx)
proxy = rpc.RPCProxy('res.lang')
lang_ids = proxy.search([('translatable', '=', '1')])
langs = proxy.read(lang_ids, ['code', 'name'])
proxy = rpc.RPCProxy(params.model)
data = []
view = []
view_view = cache.fields_view_get(params.model, False, 'form', ctx,
True)
view_fields = view_view['fields']
view_relates = view_view.get('toolbar')
names = view_fields.keys()
names.sort(lambda x, y: cmp(view_fields[x].get('string', ''),
view_fields[y].get('string', '')))
if translate == 'fields' and params.id:
for name in names:
attrs = view_fields[name]
if attrs.get('translate'):
type = attrs.get('type')
value = {}
for lang in langs:
context = copy.copy(ctx)
context['lang'] = adapt_context(lang['code'])
val = proxy.read([params.id], [name], context)
val = val[0] if isinstance(
val, list) and len(val) > 0 else None
if val[name] is False:
val[name] = ""
value[lang['code']] = val[name] if isinstance(val,dict) \
and name in val else None
data += [(name, value, None, attrs.get('string'), type)]
if translate == 'labels':
for name in names:
attrs = view_fields[name]
if attrs.get('string'):
value = {}
for lang in langs:
code = lang['code']
val = proxy.read_string(False, [code], [name])
if name in val[code]:
value[code] = val[code][name] or None
if value: data += [(name, value, None, None, None)]
if translate == 'relates' and view_relates:
for bar, tools in view_relates.items():
for tool in tools:
value = {}
for lang in langs:
code = lang['code']
val = rpc.session.execute('object', 'execute',
tool['type'], 'read',
[tool['id']], ['name'],
{'lang': code})
value[code] = val[0]['name'] or None
data += [(tool['id'], value, tool['type'], None, None)]
if translate == 'view':
for lang in langs:
code = lang['code']
view_item_ids = rpc.session.execute(
'object', 'execute', 'ir.translation', 'search',
[('name', '=', params.model), ('type', '=', 'view'),
('lang', '=', code)])
view_items = rpc.session.execute('object', 'execute',
'ir.translation', 'read',
view_item_ids,
['src', 'value'])
values = []
for val in view_items:
values += [val]
if values:
view += [(code, values)]
return dict(translate=translate,
langs=langs,
data=data,
view=view,
model=params.model,
id=params.id,
ctx=params.context)
def __init__(self, source, model, domain=None, context=None, values={}, filter_domain=None, search_view=None, group_by_ctx=[], **kw):
super(Search, self).__init__(model=model)
self.domain = copy.deepcopy(domain) or []
self.listof_domain = domain or []
self.filter_domain = filter_domain or []
self.custom_filter_domain = []
self.context = context or {}
self.search_view = search_view or "{}"
self.model = model
self.groupby = []
self.source = source
if kw.get('clear'):
self.source = None
if group_by_ctx and isinstance(group_by_ctx, basestring):
self.groupby += group_by_ctx.split(',')
else:
self.groupby = group_by_ctx
if values == "undefined":
values = {}
ctx = dict(rpc.session.context, **self.context)
if not self.groupby and (values and values.get('group_by_ctx')):
self.groupby = values['group_by_ctx']
if isinstance (self.search_view, basestring):
self.search_view = eval(self.search_view)
if not self.search_view:
view_id = kw.get('search_view_id')\
or ctx.get('search_view')
self.search_view = cache.fields_view_get(
self.model, view_id or False, 'search', ctx, True)
fields = self.search_view['fields']
self.domain = convert_date_format_in_domain(domain, fields, self.context)
self.listof_domain = self.domain
try:
dom = xml.dom.minidom.parseString(self.search_view['arch'])
except:
dom = xml.dom.minidom.parseString(self.search_view['arch'].encode('utf-8'))
self.view_type = dom.firstChild.localName
self.string = dom.documentElement.getAttribute('string')
self.fields_type = {}
all_fields = cache.fields_get(model, [], rpc.session.context)
self.fields = dict(all_fields, **fields)
self.fields_list = [
(field_name, ustr(field['string']), field['type'])
for field_name, field in self.fields.iteritems()
if field['type'] != 'binary'
if field.get('selectable')
]
if self.fields_list:
self.fields_list.sort(lambda x, y: cmp(x[1], y[1]))
self.frame = self.parse(model, dom, self.fields, values)
if self.frame:
self.frame = self.frame[0]
my_acts = rpc.session.execute('object', 'execute', 'ir.filters', 'get_filters', model)
sorted_filters = []
for act in my_acts:
action = [act['domain'], act['name']]
act_ctx = eval(act['context'])
if act_ctx and act_ctx.get('group_by'):
action.append(ustr(act_ctx['group_by']))
else:
action.append("[]")
action.append(act['id'])
sorted_filters.append(action)
sorted_filters.sort(lambda x, y: cmp(x[1], y[1]))
self.filters_list = sorted_filters
self.operators_map = [
('ilike', _('contains')), ('not ilike', _('doesn\'t contain')),
('=', _('is equal to')), ('<>', _('is not equal to')),
('>', _('greater than')), ('<', _('less than')),
('in', _('in')), ('not in', _('not in'))]
self.flt_domain = str(self.filter_domain).replace("(", "[").replace(')', ']')
self.custom_filter_domain = self.filter_domain
def index(self, translate='fields', **kw):
params, data = TinyDict.split(kw)
ctx = dict((params.context or {}), **rpc.session.context)
params['context'] = ustr(ctx)
proxy = rpc.RPCProxy('res.lang')
lang_ids = proxy.search([('translatable', '=', '1')])
langs = proxy.read(lang_ids, ['code', 'name'])
proxy = rpc.RPCProxy(params.model)
data = []
view = []
view_view = cache.fields_view_get(params.model, False, 'form', ctx, True)
view_fields = view_view['fields']
view_relates = view_view.get('toolbar')
names = view_fields.keys()
names.sort(lambda x,y: cmp(view_fields[x].get('string', ''), view_fields[y].get('string', '')))
if translate == 'fields' and params.id:
for name in names:
attrs = view_fields[name]
if attrs.get('translate'):
type = attrs.get('type')
value = {}
for lang in langs:
context = copy.copy(ctx)
context['lang'] = adapt_context(lang['code'])
val = proxy.read([params.id], [name], context)
val = val[0] if isinstance(val,list) and len(val) > 0 else None
if val[name] is False:
val[name] = ""
value[lang['code']] = val[name] if isinstance(val,dict) \
and name in val else None
data += [(name, value, None, attrs.get('string'), type)]
if translate == 'labels':
for name in names:
attrs = view_fields[name]
if attrs.get('string'):
value = {}
for lang in langs:
code=lang['code']
val = proxy.read_string(False, [code], [name])
if name in val[code]:
value[code] = val[code][name] or None
if value: data += [(name, value, None, None, None)]
if translate == 'relates' and view_relates:
for bar, tools in view_relates.items():
for tool in tools:
value = {}
for lang in langs:
code = lang['code']
val = rpc.session.execute('object', 'execute', tool['type'], 'read', [tool['id']], ['name'], {'lang': code})
value[code] = val[0]['name'] or None
data += [(tool['id'], value, tool['type'], None, None)]
if translate == 'view':
for lang in langs:
code=lang['code']
view_item_ids = rpc.session.execute('object', 'execute', 'ir.translation', 'search', [('name', '=', params.model), ('type', '=', 'view'), ('lang', '=', code)])
view_items = rpc.session.execute('object', 'execute', 'ir.translation', 'read', view_item_ids, ['src', 'value'])
values = []
for val in view_items:
values += [val]
if values:
view += [(code, values)]
return dict(translate=translate, langs=langs, data=data, view=view, model=params.model, id=params.id, ctx=params.context)
def __init__(self, model, view=False, view_id=False, ids=[], domain=[], view_mode=[], context={}, group_by=[]):
ctx = {}
ctx = rpc.get_session().context.copy()
ctx.update(context)
view = view or cache.fields_view_get(model, view_id, 'graph', ctx)
fields = view['fields']
dom = xml.dom.minidom.parseString(view['arch'].encode('utf-8'))
root = dom.childNodes[0]
attrs = node_attributes(root)
self.view_mode = view_mode
self.model = model
self.string = attrs.get('string', 'Unknown')
self.kind = attrs.get('type', '')
self.orientation = attrs.get('orientation', 'vertical')
self.values = []
self.group_by = group_by
add_grp_field = ''
if self.group_by and not fields.has_key(self.group_by[0]):
add_grp_field = cache.fields_get(self.model, [self.group_by[0]], rpc.get_session().context)
fields.update(add_grp_field)
axis, axis_data, axis_group = self.parse(root, fields)
if self.group_by:
axis[0] = self.group_by[0]
axis_data.update(add_grp_field)
proxy = rpc.RPCProxy(model)
ctx = rpc.get_session().context.copy()
ctx.update(context)
if ids is None:
ids = proxy.search(domain, 0, 0, 0, ctx)
rec_ids = []
values = proxy.read(ids, fields.keys(), ctx)
for value in values:
res = {}
rec_ids.append(value.get('id'))
res['temp_id'] = value.get('id')
for x in axis_data.keys():
if fields[x]['type'] in ('many2one', 'char','time','text'):
res[x] = value[x]
if isinstance(res[x], (list, tuple)):
res[x] = res[x][-1]
res[x] = ustr(res[x])
elif fields[x]['type'] in 'selection':
selection_mapping = dict(fields[x]['selection'])
res[x] = selection_mapping.get(value[x], False)
elif fields[x]['type'] == 'date':
if value[x]:
date = time.strptime(value[x], DT_SERVER_FORMATS['date'])
date = tz_convert(date, 'parse')
res[x] = time.strftime(locale.nl_langinfo(locale.D_FMT).replace('%y', '%Y'), date)
else:
res[x] = ''
elif fields[x]['type'] == 'datetime':
if value[x]:
date = time.strptime(value[x], DT_SERVER_FORMATS['datetime'])
date = tz_convert(date, 'parse')
res[x] = time.strftime(locale.nl_langinfo(locale.D_FMT).replace('%y', '%Y')+' %H:%M:%S', date)
else:
res[x] = ''
else:
res[x] = value[x] and float(value[x]) or 0.0
if axis and isinstance(value[axis[0]], (tuple, list)):
res['id'] = value[axis[0]][0]
elif axis:
res['id'] = value[axis[0]]
else:
res['id'] = False
res['rec_id'] = rec_ids
self.values.append(res)
self.axis = axis
self.axis_data = axis_data
self.axis_group_field = axis_group
def __init__(self,
source,
model,
domain=None,
context=None,
values={},
filter_domain=None,
search_view=None,
group_by_ctx=[],
**kw):
super(Search, self).__init__(model=model)
self.domain = copy.deepcopy(domain) or []
self.listof_domain = domain or []
self.filter_domain = filter_domain or []
self.filter_status = {}
self.custom_filter_domain = []
self.context = context or {}
self.search_view = search_view or "{}"
self.model = model
self.groupby = []
self.source = source
if kw.get('clear'):
self.source = None
if group_by_ctx and isinstance(group_by_ctx, basestring):
self.groupby += group_by_ctx.split(',')
else:
self.groupby = group_by_ctx
if values == "undefined":
values = {}
ctx = dict(rpc.session.context, **self.context)
if not self.groupby and (values and values.get('group_by_ctx')):
self.groupby = values['group_by_ctx']
if not self.filter_status and (values and values.get('filter_status')):
self.filter_status = values['filter_status']
if isinstance(self.search_view, basestring):
self.search_view = eval(self.search_view)
if not self.search_view:
view_id = kw.get('search_view_id')\
or ctx.get('search_view')
self.search_view = cache.fields_view_get(self.model, view_id
or False, 'search', ctx,
True)
fields = self.search_view['fields']
self.domain = convert_date_format_in_domain(domain, fields,
self.context)
self.listof_domain = self.domain
try:
dom = xml.dom.minidom.parseString(self.search_view['arch'])
except:
dom = xml.dom.minidom.parseString(
self.search_view['arch'].encode('utf-8'))
self.view_type = dom.firstChild.localName
self.string = dom.documentElement.getAttribute('string')
self.fields_type = {}
all_fields = cache.fields_get(model, [], rpc.session.context)
self.fields = dict(all_fields, **fields)
self.fields_list = [(field_name, ustr(field['string']), field['type'])
for field_name, field in self.fields.iteritems()
if field['type'] != 'binary'
if field.get('selectable')]
if self.fields_list:
self.fields_list.sort(lambda x, y: cmp(x[1], y[1]))
self.frame = self.parse(model, dom, self.fields, values)
if self.frame:
self.frame = self.frame[0]
my_acts = rpc.session.execute('object', 'execute', 'ir.filters',
'get_filters', model)
sorted_filters = []
for act in my_acts:
action = [act['domain'], act['name']]
act_ctx = eval(act['context'])
if act_ctx and act_ctx.get('group_by'):
action.append(ustr(act_ctx['group_by']))
else:
action.append("[]")
action.append(act['id'])
sorted_filters.append(action)
sorted_filters.sort(lambda x, y: cmp(x[1], y[1]))
self.filters_list = sorted_filters
self.operators_map = [('ilike', _('contains')),
('not ilike', _('doesn\'t contain')),
('=', _('is equal to')),
('<>', _('is not equal to')),
('>', _('greater than')), ('<', _('less than')),
('in', _('in')), ('not in', _('not in'))]
self.flt_domain = str(self.filter_domain).replace("(", "[").replace(
')', ']')
self.custom_filter_domain = self.filter_domain
