def test_frozendict_hash(self):
""" Ensure that a frozendict is hashable. """
# dict with simple values
hash(frozendict({'name': 'Joe', 'age': 42}))
# dict with tuples, lists, and embedded dicts
hash(frozendict({
'user_id': (42, 'Joe'),
'line_ids': [(0, 0, {'values': [42]})],
}))
def test_frozendict_hash(self):
""" Ensure that a frozendict is hashable. """
# dict with simple values
hash(frozendict({'name': 'Joe', 'age': 42}))
# dict with tuples, lists, and embedded dicts
hash(
frozendict({
'user_id': (42, 'Joe'),
'line_ids': [(0, 0, {
'values': [42]
})],
}))
def test_frozendict_immutable(self):
""" Ensure that a frozendict is immutable. """
vals = {'name': 'Joe', 'age': 42}
frozen_vals = frozendict(vals)
# check __setitem__, __delitem__
with self.assertRaises(Exception):
frozen_vals['surname'] = 'Jack'
with self.assertRaises(Exception):
frozen_vals['name'] = 'Jack'
with self.assertRaises(Exception):
del frozen_vals['name']
# check update, setdefault, pop, popitem, clear
with self.assertRaises(Exception):
frozen_vals.update({'surname': 'Jack'})
with self.assertRaises(Exception):
frozen_vals.update({'name': 'Jack'})
with self.assertRaises(Exception):
frozen_vals.setdefault('surname', 'Jack')
with self.assertRaises(Exception):
frozen_vals.pop('surname', 'Jack')
with self.assertRaises(Exception):
frozen_vals.pop('name', 'Jack')
with self.assertRaises(Exception):
frozen_vals.popitem()
with self.assertRaises(Exception):
frozen_vals.clear()
def __new__(cls, cr, uid, context):
assert context is not None
args = (cr, uid, context)
# if env already exists, return it
if hasattr(cls._local, 'environments'):
env, envs = None, cls._local.environments
else:
env, envs = None, Environments()
for env in envs:
if env.args == args:
return env
# otherwise create environment, and add it in the set
self = object.__new__(cls)
self.cr, self.uid, self.context = self.args = (cr, uid,
frozendict(context))
self.registry = RegistryManager.get(cr.dbname)
self.cache = defaultdict(dict) # {field: {id: value, ...}, ...}
self.prefetch = defaultdict(set) # {model_name: set(id), ...}
self.computed = defaultdict(set) # {field: set(id), ...}
self.dirty = defaultdict(set) # {record: set(field_name), ...}
self.all = envs
envs.add(self)
return self
def __new__(cls, cr, uid, context):
assert context is not None
args = (cr, uid, context)
# if env already exists, return it
env, envs = None, cls.envs
for env in envs:
if env.args == args:
return env
# otherwise create environment, and add it in the set
self = object.__new__(cls)
self.cr, self.uid, self.context = self.args = (cr, uid, frozendict(context))
try:
dbname = context.get('dbname')
except Exception as e:
# TODO split `dbname` from `cr.connection.dsn`
print e.message
raise
self.registry = RegistryManager.get(dbname)
self.cache = defaultdict(dict) # {field: {id: value, ...}, ...}
self.prefetch = defaultdict(set) # {model_name: set(id), ...}
self.computed = defaultdict(set) # {field: set(id), ...}
self.dirty = defaultdict(set) # {record: set(field_name), ...}
self.all = envs
envs.add(self)
return self
def test_frozendict_immutable(self):
""" Ensure that a frozendict is immutable. """
vals = {'name': 'Joe', 'age': 42}
frozen_vals = frozendict(vals)
# check __setitem__, __delitem__
with self.assertRaises(Exception):
frozen_vals['surname'] = 'Jack'
with self.assertRaises(Exception):
frozen_vals['name'] = 'Jack'
with self.assertRaises(Exception):
del frozen_vals['name']
# check update, setdefault, pop, popitem, clear
with self.assertRaises(Exception):
frozen_vals.update({'surname': 'Jack'})
with self.assertRaises(Exception):
frozen_vals.update({'name': 'Jack'})
with self.assertRaises(Exception):
frozen_vals.setdefault('surname', 'Jack')
with self.assertRaises(Exception):
frozen_vals.pop('surname', 'Jack')
with self.assertRaises(Exception):
frozen_vals.pop('name', 'Jack')
with self.assertRaises(Exception):
frozen_vals.popitem()
with self.assertRaises(Exception):
frozen_vals.clear()
def inter_call(self, data):
cr, uid, context = self.env.args
context = dict(context)
context.update({'depends': {}})
self.env.args = cr, uid, frozendict(context)
res = base_module_save._create_module(self,
self._cr,
self.env.user.id,
data,
context=context)
mod_obj = self.env['ir.model.data']
model_data_ids = mod_obj.search([('model', '=', 'ir.ui.view'),
('name', '=',
'module_create_form_view')])
resource_id = model_data_ids.read(fields=['res_id'])[0]['res_id']
context.update(res)
return {
'name': _('Module Recording'),
'context': {
'default_module_filename': ustr(res['module_filename']),
'default_module_file': ustr(res['module_file']),
},
'view_type': 'form',
'view_mode': 'form',
'res_model': 'base.module.record.objects',
'views': [(resource_id, 'form')],
'type': 'ir.actions.act_window',
'target': 'new',
}
def recompute(self):
""" Recompute stored function fields. The fields and records to
recompute have been determined by method :meth:`modified`.
"""
while self.env.has_todo():
field, recs = self.env.get_todo()
# determine the fields to recompute
fs = self.env[field.model_name]._field_computed[field]
ns = [f.name for f in fs if f.store]
# evaluate fields, and group record ids by update
updates = defaultdict(set)
for rec in recs.exists():
# Inicio HACK
to_write = {}
for n in ns:
try:
to_write[n] = rec[n]
except Exception, e:
print 'HACK "project_edt_idu/models/hack.py->project.recompute_hack" aplicado', rec._name, rec.id, n
pass
vals = rec._convert_to_write(to_write)
# Fin HACK
# Original: vals = rec._convert_to_write({n: rec[n] for n in ns})
updates[frozendict(vals)].add(rec.id)
# update records in batch when possible
with recs.env.norecompute():
for vals, ids in updates.iteritems():
recs.browse(ids)._write(dict(vals))
# mark computed fields as done
map(recs._recompute_done, fs)
def inter_call(self, data):
cr, uid, context = self.env.args
context = dict(context)
context.update({'depends': {}})
self.env.args = cr, uid, frozendict(context)
res = base_module_save._create_module(self, self._cr,
self.env.user.id, data,
context=context)
mod_obj = self.env['ir.model.data']
model_data_ids = mod_obj.search([('model', '=', 'ir.ui.view'),
('name', '=',
'module_create_form_view')])
resource_id = model_data_ids.read(fields=['res_id'])[0]['res_id']
context.update(res)
return {
'name': _('Module Recording'),
'context': {
'default_module_filename': ustr(res['module_filename']),
'default_module_file': ustr(res['module_file']),
},
'view_type': 'form',
'view_mode': 'form',
'res_model': 'base.module.record.objects',
'views': [(resource_id, 'form')],
'type': 'ir.actions.act_window',
'target': 'new',
}
def recompute(self):
""" Recompute stored function fields. The fields and records to
recompute have been determined by method :meth:`modified`.
"""
while self.env.has_todo():
field, recs = self.env.get_todo()
# determine the fields to recompute
fs = self.env[field.model_name]._field_computed[field]
ns = [f.name for f in fs if f.store]
# evaluate fields, and group record ids by update
updates = defaultdict(set)
for rec in recs.exists():
# Inicio HACK
to_write = {}
for n in ns:
try:
to_write[n] = rec[n]
except Exception, e:
print 'HACK "project_edt_idu/models/hack.py->project.recompute_hack" aplicado', rec._name, rec.id, n
pass
vals = rec._convert_to_write(to_write)
# Fin HACK
# Original: vals = rec._convert_to_write({n: rec[n] for n in ns})
updates[frozendict(vals)].add(rec.id)
# update records in batch when possible
with recs.env.norecompute():
for vals, ids in updates.iteritems():
recs.browse(ids)._write(dict(vals))
# mark computed fields as done
map(recs._recompute_done, fs)
def _get_id(self, model, id):
if type(id) == type(()):
id = id[0]
if (model, id) in self.blank_dict:
res_id = self.blank_dict[(model, id)]
return res_id, False
dt = self.env['ir.model.data']
obj = dt.search([('model', '=', model), ('res_id', '=', id)])
if not obj:
return False, None
obj = obj[0]
cr, uid, context = self.env.args
context = dict(context)
self.env.args = cr, uid, frozendict(context)
depends = context.get('depends')
depends[obj.module] = True
return obj.module + '.' + obj.name, obj.noupdate
def _get_id(self, model, id):
if type(id) == type(()):
id = id[0]
if (model, id) in self.blank_dict:
res_id = self.blank_dict[(model, id)]
return res_id, False
dt = self.env['ir.model.data']
obj = dt.search([('model', '=', model), ('res_id', '=', id)])
if not obj:
return False, None
obj = obj[0]
cr, uid, context = self.env.args
context = dict(context)
self.env.args = cr, uid, frozendict(context)
depends = context.get('depends')
depends[obj.module] = True
return obj.module + '.' + obj.name, obj.noupdate
def __new__(cls, cr, uid, context):
assert context is not None
args = (cr, uid, context)
# if env already exists, return it
env, envs = None, cls.envs
for env in envs:
if env.args == args:
return env
# otherwise create environment, and add it in the set
self = object.__new__(cls)
self.cr, self.uid, self.context = self.args = (cr, uid, frozendict(context))
self.registry = RegistryManager.get(cr.dbname)
self.cache = defaultdict(dict) # {field: {id: value, ...}, ...}
self._protected = defaultdict(frozenset) # {field: ids, ...}
self.dirty = defaultdict(set) # {record: set(field_name), ...}
self.all = envs
envs.add(self)
return self
def _get_id(self, model, id):
if isinstance(id, tuple):
id = id[0]
if (model, id) in self.blank_dict:
res_id = self.blank_dict[(model, id)]
return res_id, False
dt = self.env['ir.model.data']
obj = dt.search([('model', '=', model), ('res_id', '=', id)])
if not obj:
return False, None
obj = obj[0]
# obj = dt.browse(dtids[0])
cr, uid, context = self.env.args
context = dict(context)
# context.update({'depends': {}})
# self.depends[obj.module] = True
self.env.args = cr, uid, frozendict(context)
depends = context.get('depends')
depends[obj.module] = True
return obj.module + '.' + obj.name, obj.noupdate
def __new__(cls, cr, uid, context):
assert context is not None
args = (cr, uid, context)
# if env already exists, return it
env, envs = None, cls.envs
for env in envs:
if env.args == args:
return env
# otherwise create environment, and add it in the set
self = object.__new__(cls)
self.cr, self.uid, self.context = self.args = (cr, uid, frozendict(context))
self.registry = RegistryManager.get(cr.dbname)
self.cache = defaultdict(dict) # {field: {id: value, ...}, ...}
self.computed = defaultdict(set) # {field: set(id), ...}
self.dirty = defaultdict(set) # {record: set(field_name), ...}
self.all = envs
envs.add(self)
return self
def _get_id(self, model, id):
if isinstance(id, tuple):
id = id[0]
if (model, id) in self.blank_dict:
res_id = self.blank_dict[(model, id)]
return res_id, False
dt = self.env['ir.model.data']
obj = dt.search([('model', '=', model), ('res_id', '=', id)])
if not obj:
return False, None
obj = obj[0]
# obj = dt.browse(dtids[0])
cr, uid, context = self.env.args
context = dict(context)
# context.update({'depends': {}})
# self.depends[obj.module] = True
self.env.args = cr, uid, frozendict(context)
depends = context.get('depends')
depends[obj.module] = True
return obj.module + '.' + obj.name, obj.noupdate
def record_objects(self):
data = self.read([])[0]
check_date = data['check_date']
filter_cond = data['filter_cond']
# user = (self.env['res.users'].browse(self.env.user.id)).login
# mod = self.env['ir.module.record']
mod_obj = self.env['ir.model']
# mod.recording_data = []
cr, uid, context = self.env.args
context = dict(context)
context.update({'recording_data': []})
recording_data = context.get('recording_data')
self.env.args = cr, uid, frozendict(context)
for id in data['objects']:
obj_name = (mod_obj.browse(id)).model
obj_pool = self.env[obj_name]
if filter_cond == 'created':
search_condition = [('create_date', '>', check_date)]
elif filter_cond == 'modified':
search_condition = [('write_date', '>', check_date)]
elif filter_cond == 'created_modified':
search_condition = ['|', ('create_date', '>', check_date),
('write_date', '>', check_date)]
if '_log_access' in dir(obj_pool):
if not (obj_pool._log_access):
search_condition = []
if '_auto' in dir(obj_pool):
if not obj_pool._auto:
continue
search_ids = obj_pool.search(search_condition)
for s_id in search_ids:
dbname = self.env.cr.dbname
args = (dbname, self.env.user.id, obj_name,
'copy', s_id.id, {})
recording_data.append(('query', args, {}, s_id.id))
mod_obj = self.env['ir.model.data']
if len(recording_data):
if data['info_yaml']:
res = self._create_yaml(data)
else:
res = self._create_xml(data)
model_data_ids = mod_obj.search([('model', '=', 'ir.ui.view'),
('name', '=',
'module_create_xml_view')])
resource_id = model_data_ids.read(['res_id'])[0]['res_id']
return {
'name': _('Data Recording'),
'context': {'default_res_text': ustr(res['res_text'])},
'view_type': 'form',
'view_mode': 'form',
'res_model': 'base.module.record.data',
'views': [(resource_id, 'form')],
'type': 'ir.actions.act_window',
'target': 'new',
}
model_data_ids = mod_obj.search([('model', '=', 'ir.ui.view'),
('name', '=',
'module_recording_message_view')])
resource_id = model_data_ids.read(['res_id'])[0]['res_id']
return {
'name': _('Module Recording'),
'context': {},
'view_type': 'form',
'view_mode': 'form',
'res_model': 'base.module.record.objects',
'views': [(resource_id, 'form')],
'type': 'ir.actions.act_window',
'target': 'new',
}
def _create_yaml_record(self, model, data, record_id):
record = {'model': model, 'id': str(record_id)}
model_pool = self.env[model]
data_pool = self.env['ir.model.data']
lids = data_pool.search([('model', '=', model)])
res = lids[:1].read(['module'])
attrs = {}
cr, uid, context = self.env.args
context = dict(context)
context.update({'depends': {}})
depends = context.get('depends')
self.env.args = cr, uid, frozendict(context)
if res:
depends[res[0]['module']] = True
# if depends is None:
# depends = {}
# self.depends[res[0]['module']]=True
fields = model_pool.fields_get()
defaults = {}
try:
defaults[model] = model_pool.default_get(data)
except:
defaults[model] = {}
for key, val in data.items():
relation = fields.get(key, {}).get('relation')
if ((key in defaults[model]) and (val == defaults[model][key]))\
and not(fields[key].get('required', False)):
continue
if fields[key]['type'] in ('integer', 'float'):
if not val:
val = 0.0
attrs[key] = val
elif not (val or (fields[key]['type'] == 'function')):
continue
elif fields[key]['type'] in ('boolean',):
if not val:
continue
attrs[key] = val
elif fields[key]['type'] in ('many2one',):
if type(val) in (type(''), type(u'')):
id = val
else:
id, update = self._get_id(relation, val)
attrs[key] = str(id)
elif fields[key]['type'] in ('one2many',):
items = [[]]
for valitem in (val or []):
if valitem[0] in (0, 1):
if key in model_pool._columns:
fname = model_pool._columns[key]._fields_id
else:
fname =\
model_pool._inherit_fields[key][2]._fields_id
# delete parent_field from child's fields list
del valitem[2][fname]
childrecord = self._create_yaml_record(relation,
valitem[2],
None)
items[0].append(childrecord['attrs'])
attrs[key] = items
elif fields[key]['type'] in ('many2many',):
if (key in defaults[model]) and\
(val[0][2] == defaults[model][key]):
continue
res = []
for valitem in (val or []):
if valitem[0] == 6:
for id2 in valitem[2]:
id, update = self._get_id(relation, id2)
self.blank_dict[(relation, id2)] = id
res.append(str(id))
m2m = [res]
if m2m[0]:
attrs[key] = m2m
else:
try:
attrs[key] = str(val)
except:
attrs[key] = ustr(val)
attrs[key] = attrs[key].replace('"', '\'')
record['attrs'] = attrs
return record
def _create_yaml_record(self, model, data, record_id):
record = {'model': model, 'id': str(record_id)}
model_pool = self.env[model]
data_pool = self.env['ir.model.data']
lids = data_pool.search([('model', '=', model)])
res = lids[:1].read(['module'])
attrs = {}
cr, uid, context = self.env.args
context = dict(context)
context.update({'depends': {}})
depends = context.get('depends')
self.env.args = cr, uid, frozendict(context)
if res:
depends[res[0]['module']] = True
fields = model_pool.fields_get()
defaults = {}
try:
defaults[model] = model_pool.default_get(data)
except:
defaults[model] = {}
for key, val in data.items():
if ((key in defaults[model]) and
(val == defaults[model][key])) and not (fields[key].get(
'required', False)):
continue
if fields[key]['type'] in ('integer', 'float'):
if not val:
val = 0.0
attrs[key] = val
elif not (val or (fields[key]['type'] == 'function')):
continue
elif fields[key]['type'] in ('boolean', ):
if not val:
continue
attrs[key] = val
elif fields[key]['type'] in ('many2one', ):
if type(val) in (type(''), type(u'')):
id = val
else:
id, update = self._get_id(fields[key]['relation'], val)
attrs[key] = str(id)
elif fields[key]['type'] in ('one2many', ):
items = [[]]
for valitem in (val or []):
if valitem[0] in (0, 1):
if key in model_pool._fields:
fname = model_pool._fields[key].inverse_name
else:
fname = model_pool._inherit_fields[key][
2].inverse_name
del valitem[2][
fname] # delete parent_field from child's fields list
childrecord = self._create_yaml_record(
fields[key]['relation'], valitem[2], None)
items[0].append(childrecord['attrs'])
attrs[key] = items
elif fields[key]['type'] in ('many2many', ):
if (key in defaults[model]) and (val[0][2]
== defaults[model][key]):
continue
res = []
for valitem in (val or []):
if valitem[0] == 6:
for id2 in valitem[2]:
id, update = self._get_id(fields[key]['relation'],
id2)
self.blank_dict[(fields[key]['relation'],
id2)] = id
res.append(str(id))
m2m = [res]
if m2m[0]:
attrs[key] = m2m
else:
try:
attrs[key] = str(val)
except:
attrs[key] = ustr(val)
attrs[key] = attrs[key].replace('"', '\'')
record['attrs'] = attrs
return record
import xmlrpclib
from operator import itemgetter
from psycopg2 import Binary
import openerp
import openerp.tools as tools
from openerp.sql_db import LazyCursor
from openerp.tools.translate import _
from openerp.tools import float_repr, float_round, frozendict, html_sanitize
import json
from openerp import SUPERUSER_ID
# deprecated; kept for backward compatibility only
_get_cursor = LazyCursor
EMPTY_DICT = frozendict()
_logger = logging.getLogger(__name__)
def _symbol_set(symb):
if symb is None or symb == False:
return None
elif isinstance(symb, unicode):
return symb.encode('utf-8')
return str(symb)
class _column(object):
""" Base of all fields, a database column
def _create_record(self, doc, model, data, record_id, noupdate=False):
data_pool = self.env['ir.model.data']
model_pool = self.env[model]
record = doc.createElement('record')
record.setAttribute("id", record_id)
record.setAttribute("model", model)
record_list = [record]
lids = data_pool.search([('model', '=', model)])
lids = lids[:1]
res = lids.read(['module'])
cr, uid, context = self.env.args
context = dict(context)
context.update({'depends': {}})
depends = context.get('depends')
self.env.args = cr, uid, frozendict(context)
if res:
depends[res[0]['module']] = True
fields = model_pool.fields_get()
for key, val in data.items():
# functional fields check
if key in model_pool._fields.keys(
) and not model_pool._fields[key].store:
continue
if not (val or (fields[key]['type'] == 'boolean')):
continue
if (fields[key]['type'] in ('integer', 'float')
or fields[key]['type'] == 'selection'
and isinstance(val, int)):
field = doc.createElement('field')
field.setAttribute("name", key)
field.setAttribute("eval", val and str(val) or 'False')
record.appendChild(field)
elif fields[key]['type'] in ('boolean', ):
field = doc.createElement('field')
field.setAttribute("name", key)
field.setAttribute("eval", val and '1' or '0')
record.appendChild(field)
elif fields[key]['type'] in ('many2one', ):
field = doc.createElement('field')
field.setAttribute("name", key)
if type(val) in (type(''), type(u'')):
id = val
else:
id, update = self._get_id(fields[key]['relation'], val)
noupdate = noupdate or update
if not id:
relation_pool = self.env[fields[key]['relation']]
field.setAttribute("model", fields[key]['relation'])
fld_nm = relation_pool._rec_name
val = relation_pool.browse(val)
name = val.read([fld_nm])[0][fld_nm] or False
field.setAttribute("search",
str([(str(fld_nm), '=', name)]))
else:
field.setAttribute("ref", id)
record.appendChild(field)
elif fields[key]['type'] in ('one2many', ):
for valitem in (val or []):
if valitem[0] in (0, 1):
if key in model_pool._fields:
model_pool._fields[key].inverse_name
else:
model_pool._inherit_fields[key][2].inverse_name
if valitem[0] == 0:
newid = self._create_id(fields[key]['relation'],
valitem[2])
valitem[1] = newid
else:
newid, update = self._get_id(
fields[key]['relation'], valitem[1])
if not newid:
newid = self._create_id(
fields[key]['relation'], valitem[2])
valitem[1] = newid
self.blank_dict[(fields[key]['relation'],
valitem[1])] = newid
childrecord, update = self._create_record(
doc, fields[key]['relation'], valitem[2], newid)
noupdate = noupdate or update
record_list += childrecord
else:
pass
elif fields[key]['type'] in ('many2many', ):
res = []
for valitem in (val or []):
if valitem[0] == 6:
for id2 in valitem[2]:
id, update = self._get_id(fields[key]['relation'],
id2)
self.blank_dict[(fields[key]['relation'],
id2)] = id
noupdate = noupdate or update
res.append(id)
field = doc.createElement('field')
field.setAttribute("name", key)
field.setAttribute(
"eval", "[(6,0,[" +
','.join(map(lambda x: "ref('%s')" %
(x, ), res)) + '])]')
record.appendChild(field)
else:
field = doc_createXElement(doc, 'field')
field.setAttribute("name", key)
field.appendChild(doc.createTextNode(ustr(val)))
record.appendChild(field)
return record_list, noupdate
def record_objects(self):
data = self.read([])[0]
check_date = data['check_date']
filter_cond = data['filter_cond']
# user = (self.env['res.users'].browse(self.env.user.id)).login
# mod = self.env['ir.module.record']
mod_obj = self.env['ir.model']
# mod.recording_data = []
cr, uid, context = self.env.args
context = dict(context)
context.update({'recording_data': []})
recording_data = context.get('recording_data')
self.env.args = cr, uid, frozendict(context)
for obj_id in data['objects']:
obj_name = (mod_obj.browse(obj_id)).model
obj_pool = self.env[obj_name]
if filter_cond == 'created':
search_condition = [('create_date', '>', check_date)]
elif filter_cond == 'modified':
search_condition = [('write_date', '>', check_date)]
elif filter_cond == 'created_modified':
search_condition = [
'|', ('create_date', '>', check_date),
('write_date', '>', check_date)
]
if '_log_access' in dir(obj_pool):
if not (obj_pool._log_access):
search_condition = []
if '_auto' in dir(obj_pool):
if not obj_pool._auto:
continue
search_ids = obj_pool.search(search_condition)
for s_id in search_ids:
dbname = self.env.cr.dbname
args = (dbname, self.env.user.id, obj_name, 'copy', s_id.id,
{})
recording_data.append(('query', args, {}, s_id.id))
mod_obj = self.env['ir.model.data']
if len(recording_data):
if data['info_yaml']:
res = base_module_save._create_yaml(self, data)
model_data_ids = mod_obj.search([('model', '=', 'ir.ui.view'),
('name', '=',
'yml_save_form_view')])
resource_id = model_data_ids.read(['res_id'])[0]['res_id']
return {
'name': _('Module Recording'),
'context': {
'default_yaml_file': ustr(res['yaml_file']),
'default_module_filename': 'demo_yaml.yml',
},
'view_type': 'form',
'view_mode': 'form',
'res_model': 'base.module.record.objects',
'views': [(resource_id, 'form')],
'type': 'ir.actions.act_window',
'target': 'new',
}
else:
model_data_ids = mod_obj.search([('model', '=', 'ir.ui.view'),
('name', '=',
'info_start_form_view')])
resource_id = model_data_ids.read(['res_id'])[0]['res_id']
return {
'name': _('Module Recording'),
'context': context,
'view_type': 'form',
'view_mode': 'form',
'res_model': 'base.module.record.objects',
'views': [(resource_id, 'form')],
'type': 'ir.actions.act_window',
'target': 'new',
}
model_data_ids = mod_obj.search([('model', '=', 'ir.ui.view'),
('name', '=',
'module_recording_message_view')])
resource_id = model_data_ids.read(['res_id'])[0]['res_id']
return {
'name': _('Module Recording'),
'context': self.env.context,
'view_type': 'form',
'view_mode': 'form',
'res_model': 'base.module.record.objects',
'views': [(resource_id, 'form')],
'type': 'ir.actions.act_window',
'target': 'new',
}
def _create_record(self, doc, model, data, record_id, noupdate=False):
data_pool = self.env['ir.model.data']
model_pool = self.env[model]
# cr, uid, context = self.env.args
# context = dict(context)
record = doc.createElement('record')
record.setAttribute("id", record_id)
record.setAttribute("model", model)
record_list = [record]
lids = data_pool.search([('model', '=', model)])
lids = lids[:1]
res = lids.read(['module'])
cr, uid, context = self.env.args
context = dict(context)
context.update({'depends': {}})
depends = context.get('depends')
self.env.args = cr, uid, frozendict(context)
if res:
depends[res[0]['module']] = True
fields = model_pool.fields_get()
for key, val in data.items():
relation = fields.get(key, {}).get('relation')
if key in model_pool._columns.keys()\
and isinstance(model_pool._columns[key], function_field)\
and not model_pool._columns[key].store:
continue
if not (val or (fields[key]['type'] == 'boolean')):
continue
if (fields[key]['type'] in ('integer', 'float') or
fields[key]['type'] == 'selection' and
isinstance(val, int)):
field = doc.createElement('field')
field.setAttribute("name", key)
field.setAttribute("eval", val and str(val) or 'False')
record.appendChild(field)
elif fields[key]['type'] in ('boolean',):
field = doc.createElement('field')
field.setAttribute("name", key)
field.setAttribute("eval", val and '1' or '0')
record.appendChild(field)
elif fields[key]['type'] in ('many2one',):
field = doc.createElement('field')
field.setAttribute("name", key)
if type(val) in (type(''), type(u'')):
id = val
else:
id, update = self._get_id(relation, val)
noupdate = noupdate or update
if not id:
relation_pool = self.env[relation]
field.setAttribute("model", relation)
fld_nm = relation_pool._rec_name
val = relation_pool.browse(val)
name = val.read([fld_nm])[0][fld_nm] or False
field.setAttribute("search",
str([(str(fld_nm), '=', name)]))
else:
field.setAttribute("ref", id)
record.appendChild(field)
elif fields[key]['type'] in ('one2many',):
for valitem in (val or []):
if valitem[0] in (0, 1):
# if key in model_pool._columns:
# model_pool._columns[key]._fields_id
# else:
# model_pool._inherit_fields[key][2]._fields_id
if valitem[0] == 0:
newid = self._create_id(relation, valitem[2])
valitem[1] = newid
else:
newid, update = self._get_id(relation, valitem[1])
if not newid:
newid = self._create_id(relation, valitem[2])
valitem[1] = newid
self.blank_dict[(relation, valitem[1])] = newid
childrecord, update = self._create_record(doc,
relation,
valitem[2],
newid)
noupdate = noupdate or update
record_list += childrecord
else:
pass
elif fields[key]['type'] in ('many2many',):
res = []
for valitem in (val or []):
if valitem[0] == 6:
for id2 in valitem[2]:
id, update = self._get_id(relation, id2)
self.blank_dict[(relation, id2)] = id
noupdate = noupdate or update
res.append(id)
field = doc.createElement('field')
field.setAttribute("name", key)
field.setAttribute("eval", "[(6,0,[" +
','.join(map(lambda x: "ref('%s')"
% (x,), res)) + '])]')
record.appendChild(field)
else:
field = doc_createXElement(doc, 'field')
field.setAttribute("name", key)
field.appendChild(doc.createTextNode(val))
record.appendChild(field)
return record_list, noupdate
