1439 lines
58 KiB
Python
1439 lines
58 KiB
Python
#This file is part of Tryton. The COPYRIGHT file at the top level of
|
|
#this repository contains the full copyright notices and license terms.
|
|
|
|
import datetime
|
|
import time
|
|
import logging
|
|
import contextlib
|
|
import traceback
|
|
import sys
|
|
import csv
|
|
import warnings
|
|
try:
|
|
import cStringIO as StringIO
|
|
except ImportError:
|
|
import StringIO
|
|
|
|
from decimal import Decimal
|
|
from itertools import islice, ifilter, chain, izip
|
|
from functools import reduce
|
|
|
|
from trytond.model import Model
|
|
from trytond.model import fields
|
|
from trytond.tools import safe_eval, reduce_domain
|
|
from trytond.pyson import PYSONEncoder, PYSONDecoder, PYSON
|
|
from trytond.const import OPERATORS, RECORD_CACHE_SIZE, BROWSE_FIELD_TRESHOLD
|
|
from trytond.transaction import Transaction
|
|
from trytond.pool import Pool
|
|
from trytond.cache import LRUDict
|
|
from trytond.config import CONFIG
|
|
from trytond.rpc import RPC
|
|
from .modelview import ModelView
|
|
|
|
__all__ = ['ModelStorage']
|
|
|
|
|
|
class ModelStorage(Model):
|
|
"""
|
|
Define a model with storage capability in Tryton.
|
|
"""
|
|
|
|
create_uid = fields.Many2One('res.user', 'Create User', readonly=True)
|
|
create_date = fields.Timestamp('Create Date', readonly=True)
|
|
write_uid = fields.Many2One('res.user', 'Write User', readonly=True)
|
|
write_date = fields.Timestamp('Write Date', readonly=True)
|
|
rec_name = fields.Function(fields.Char('Name'), 'get_rec_name',
|
|
searcher='search_rec_name')
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super(ModelStorage, cls).__setup__()
|
|
if issubclass(cls, ModelView):
|
|
cls.__rpc__.update({
|
|
'create': RPC(readonly=False,
|
|
result=lambda r: map(int, r)),
|
|
'read': RPC(),
|
|
'write': RPC(readonly=False, instantiate=0),
|
|
'delete': RPC(readonly=False, instantiate=0),
|
|
'copy': RPC(readonly=False, instantiate=0,
|
|
result=lambda r: map(int, r)),
|
|
'search': RPC(result=lambda r: map(int, r)),
|
|
'search_count': RPC(),
|
|
'search_read': RPC(),
|
|
'export_data': RPC(instantiate=0),
|
|
'import_data': RPC(readonly=False),
|
|
})
|
|
cls._constraints = []
|
|
|
|
@staticmethod
|
|
def default_create_uid():
|
|
"Default value for uid field."
|
|
return int(Transaction().user)
|
|
|
|
@staticmethod
|
|
def default_create_date():
|
|
"Default value for create_date field."
|
|
return datetime.datetime.today()
|
|
|
|
@classmethod
|
|
def create(cls, vlist):
|
|
'''
|
|
Returns the list of created records.
|
|
'''
|
|
pool = Pool()
|
|
ModelAccess = pool.get('ir.model.access')
|
|
ModelFieldAccess = pool.get('ir.model.field.access')
|
|
|
|
ModelAccess.check(cls.__name__, 'create')
|
|
|
|
all_fields = list(set(chain(*(v.iterkeys() for v in vlist))))
|
|
ModelFieldAccess.check(cls.__name__, all_fields, 'write')
|
|
|
|
# Increase transaction counter
|
|
Transaction().counter += 1
|
|
|
|
@classmethod
|
|
def trigger_create(cls, records):
|
|
'''
|
|
Trigger create actions
|
|
'''
|
|
Trigger = Pool().get('ir.trigger')
|
|
triggers = Trigger.get_triggers(cls.__name__, 'create')
|
|
if not triggers:
|
|
return
|
|
for trigger in triggers:
|
|
triggers = []
|
|
for record in records:
|
|
if Trigger.eval(trigger, record):
|
|
triggers.append(record)
|
|
if triggers:
|
|
Trigger.trigger_action(triggers, trigger)
|
|
|
|
@classmethod
|
|
def read(cls, ids, fields_names=None):
|
|
'''
|
|
Read fields_names of record ids.
|
|
If fields_names is None, it read all fields.
|
|
The order is not guaranteed.
|
|
'''
|
|
pool = Pool()
|
|
ModelAccess = pool.get('ir.model.access')
|
|
ModelFieldAccess = pool.get('ir.model.field.access')
|
|
|
|
ModelAccess.check(cls.__name__, 'read')
|
|
ModelFieldAccess.check(cls.__name__,
|
|
fields_names or cls._fields.keys(), 'read')
|
|
return []
|
|
|
|
@classmethod
|
|
def write(cls, records, values):
|
|
'''
|
|
Write values on records.
|
|
'''
|
|
pool = Pool()
|
|
ModelAccess = pool.get('ir.model.access')
|
|
ModelFieldAccess = pool.get('ir.model.field.access')
|
|
|
|
ModelAccess.check(cls.__name__, 'write')
|
|
ModelFieldAccess.check(cls.__name__,
|
|
[x for x in values if x in cls._fields], 'write')
|
|
if not cls.check_xml_record(records, values):
|
|
cls.raise_user_error('write_xml_record',
|
|
error_description='xml_record_desc')
|
|
|
|
# Increase transaction counter
|
|
Transaction().counter += 1
|
|
|
|
# Clean local cache
|
|
for record in records:
|
|
local_cache = record._local_cache.get(record.id)
|
|
if local_cache:
|
|
local_cache.clear()
|
|
|
|
# Clean cursor cache
|
|
for cache in Transaction().cursor.cache.itervalues():
|
|
if cls.__name__ in cache:
|
|
for record in records:
|
|
if record.id in cache[cls.__name__]:
|
|
cache[cls.__name__][record.id].clear()
|
|
|
|
@classmethod
|
|
def trigger_write_get_eligibles(cls, records):
|
|
'''
|
|
Return eligible records for write actions by triggers
|
|
'''
|
|
Trigger = Pool().get('ir.trigger')
|
|
triggers = Trigger.get_triggers(cls.__name__, 'write')
|
|
if not triggers:
|
|
return {}
|
|
eligibles = {}
|
|
for trigger in triggers:
|
|
eligibles[trigger] = []
|
|
for record in records:
|
|
if not Trigger.eval(trigger, record):
|
|
eligibles[trigger].append(record)
|
|
return eligibles
|
|
|
|
@classmethod
|
|
def trigger_write(cls, eligibles):
|
|
'''
|
|
Trigger write actions.
|
|
eligibles is a dictionary of the lists of eligible records by triggers
|
|
'''
|
|
Trigger = Pool().get('ir.trigger')
|
|
for trigger, records in eligibles.iteritems():
|
|
triggered = []
|
|
for record in records:
|
|
if Trigger.eval(trigger, record):
|
|
triggered.append(record)
|
|
if triggered:
|
|
Trigger.trigger_action(triggered, trigger)
|
|
|
|
@classmethod
|
|
def delete(cls, records):
|
|
'''
|
|
Delete records.
|
|
'''
|
|
ModelAccess = Pool().get('ir.model.access')
|
|
|
|
ModelAccess.check(cls.__name__, 'delete')
|
|
if not cls.check_xml_record(records, None):
|
|
cls.raise_user_error('delete_xml_record',
|
|
error_description='xml_record_desc')
|
|
|
|
# Increase transaction counter
|
|
Transaction().counter += 1
|
|
|
|
# Clean cursor cache
|
|
for cache in Transaction().cursor.cache.values():
|
|
for cache in (cache, cache.get('_language_cache', {}).values()):
|
|
if cls.__name__ in cache:
|
|
for record in records:
|
|
if record.id in cache[cls.__name__]:
|
|
del cache[cls.__name__][record.id]
|
|
|
|
@classmethod
|
|
def trigger_delete(cls, records):
|
|
'''
|
|
Trigger delete actions
|
|
'''
|
|
Trigger = Pool().get('ir.trigger')
|
|
triggers = Trigger.get_triggers(cls.__name__, 'delete')
|
|
if not triggers:
|
|
return
|
|
for trigger in triggers:
|
|
triggered = []
|
|
for record in records:
|
|
if Trigger.eval(trigger, record):
|
|
triggered.append(record)
|
|
if triggered:
|
|
Trigger.trigger_action(triggered, trigger)
|
|
|
|
@classmethod
|
|
def copy(cls, records, default=None):
|
|
'''
|
|
Duplicate the records and return a list of new records.
|
|
'''
|
|
pool = Pool()
|
|
Lang = pool.get('ir.lang')
|
|
if default is None:
|
|
default = {}
|
|
|
|
if 'state' not in default:
|
|
if 'state' in cls._defaults:
|
|
default['state'] = cls._defaults['state']()
|
|
|
|
def convert_data(field_defs, data):
|
|
data = data.copy()
|
|
data_o2m = {}
|
|
for field_name in field_defs:
|
|
ftype = field_defs[field_name]['type']
|
|
|
|
if field_name in (
|
|
'create_date',
|
|
'create_uid',
|
|
'write_date',
|
|
'write_uid',
|
|
):
|
|
del data[field_name]
|
|
|
|
if field_name in default:
|
|
data[field_name] = default[field_name]
|
|
elif (isinstance(cls._fields[field_name], fields.Function)
|
|
and not isinstance(cls._fields[field_name],
|
|
fields.Property)):
|
|
del data[field_name]
|
|
elif ftype in ('many2one', 'one2one'):
|
|
try:
|
|
data[field_name] = data[field_name] and \
|
|
data[field_name][0]
|
|
except Exception:
|
|
pass
|
|
elif ftype in ('one2many',):
|
|
if data[field_name]:
|
|
data_o2m[field_name] = data[field_name]
|
|
data[field_name] = None
|
|
elif ftype == 'many2many':
|
|
if data[field_name]:
|
|
data[field_name] = [('set', data[field_name])]
|
|
if 'id' in data:
|
|
del data['id']
|
|
return data, data_o2m
|
|
|
|
new_ids = {}
|
|
fields_names = [n for n, f in cls._fields.iteritems()
|
|
if (not isinstance(f, fields.Function)
|
|
or isinstance(f, fields.Property))]
|
|
ids = map(int, records)
|
|
datas = cls.read(ids, fields_names=fields_names)
|
|
field_defs = cls.fields_get(fields_names=fields_names)
|
|
data_ids = []
|
|
to_create = []
|
|
o2m_to_create = []
|
|
for data in datas:
|
|
data_ids.append(data['id'])
|
|
data, data_o2m = convert_data(field_defs, data)
|
|
to_create.append(data)
|
|
o2m_to_create.append(data_o2m)
|
|
new_records = cls.create(to_create)
|
|
for data_id, new_record, data_o2m in izip(data_ids, new_records,
|
|
o2m_to_create):
|
|
new_ids[data_id] = new_record.id
|
|
for field_name in data_o2m:
|
|
Relation = pool.get(
|
|
field_defs[field_name]['relation'])
|
|
relation_field = field_defs[field_name]['relation_field']
|
|
if relation_field:
|
|
field = Relation._fields[relation_field]
|
|
if field._type == 'reference':
|
|
value = str(new_record)
|
|
else:
|
|
value = new_record.id
|
|
Relation.copy(Relation.browse(data_o2m[field_name]),
|
|
default={relation_field: value})
|
|
|
|
fields_translate = {}
|
|
for field_name, field in field_defs.iteritems():
|
|
if field_name in cls._fields and \
|
|
getattr(cls._fields[field_name], 'translate', False):
|
|
fields_translate[field_name] = field
|
|
|
|
if fields_translate:
|
|
langs = Lang.search([
|
|
('translatable', '=', True),
|
|
])
|
|
if langs:
|
|
for lang in langs:
|
|
# Prevent fuzzing translations when copying as the terms
|
|
# should be the same.
|
|
with Transaction().set_context(language=lang.code,
|
|
fuzzy_translation=False):
|
|
datas = cls.read(ids,
|
|
fields_names=fields_translate.keys() + ['id'])
|
|
for data in datas:
|
|
data_id = data['id']
|
|
data, _ = convert_data(fields_translate, data)
|
|
cls.write([cls(new_ids[data_id])], data)
|
|
return cls.browse(new_ids.values())
|
|
|
|
@classmethod
|
|
def search(cls, domain, offset=0, limit=None, order=None, count=False):
|
|
'''
|
|
Return a list of records that match the domain.
|
|
'''
|
|
if count:
|
|
return 0
|
|
return []
|
|
|
|
@classmethod
|
|
def search_count(cls, domain):
|
|
'''
|
|
Return the number of records that match the domain.
|
|
'''
|
|
res = cls.search(domain, count=True)
|
|
if isinstance(res, list):
|
|
return len(res)
|
|
return res
|
|
|
|
@classmethod
|
|
def search_read(cls, domain, offset=0, limit=None, order=None,
|
|
fields_names=None):
|
|
'''
|
|
Call search and read functions at once.
|
|
Useful for the client to reduce the number of calls.
|
|
'''
|
|
records = cls.search(domain, offset=offset, limit=limit, order=order)
|
|
|
|
if not fields_names:
|
|
fields_names = cls._fields.keys()
|
|
if 'id' not in fields_names:
|
|
fields_names.append('id')
|
|
return cls.read(map(int, records), fields_names)
|
|
|
|
@classmethod
|
|
def _search_domain_active(cls, domain, active_test=True):
|
|
# reduce_domain return a new instance so we can safety modify domain
|
|
domain = reduce_domain(domain)
|
|
# if the object has a field named 'active', filter out all inactive
|
|
# records unless they were explicitely asked for
|
|
if not ('active' in cls._fields
|
|
and active_test
|
|
and Transaction().context.get('active_test', True)):
|
|
return domain
|
|
|
|
def process(domain):
|
|
i = 0
|
|
active_found = False
|
|
while i < len(domain):
|
|
arg = domain[i]
|
|
#add test for xmlrpc that doesn't handle tuple
|
|
if (isinstance(arg, tuple)
|
|
or (isinstance(arg, list)
|
|
and len(arg) > 2
|
|
and arg[1] in OPERATORS)):
|
|
if arg[0] == 'active':
|
|
active_found = True
|
|
elif isinstance(arg, list):
|
|
domain[i] = process(domain[i])
|
|
i += 1
|
|
if not active_found:
|
|
if (domain and ((isinstance(domain[0], basestring)
|
|
and domain[0] == 'AND')
|
|
or (not isinstance(domain[0], basestring)))):
|
|
domain.append(('active', '=', True))
|
|
else:
|
|
domain = ['AND', domain, ('active', '=', True)]
|
|
return domain
|
|
return process(domain)
|
|
|
|
def get_rec_name(self, name):
|
|
'''
|
|
Return the rec_name of the instance.
|
|
It is used by the Function field rec_name.
|
|
'''
|
|
rec_name = self._rec_name
|
|
if rec_name not in self._fields:
|
|
rec_name = 'id'
|
|
return unicode(getattr(self, rec_name))
|
|
|
|
@classmethod
|
|
def search_rec_name(cls, name, clause):
|
|
'''
|
|
Return a list of arguments for search on rec_name.
|
|
'''
|
|
rec_name = cls._rec_name
|
|
if rec_name not in cls._fields:
|
|
return []
|
|
return [(rec_name,) + tuple(clause[1:])]
|
|
|
|
@classmethod
|
|
def search_global(cls, text):
|
|
'''
|
|
Yield tuples (id, rec_name, icon) for text
|
|
'''
|
|
# TODO improve search clause
|
|
for record in cls.search([
|
|
('rec_name', 'ilike', '%%%s%%' % text),
|
|
]):
|
|
yield record.id, record.rec_name, None
|
|
|
|
@classmethod
|
|
def browse(cls, ids):
|
|
'''
|
|
Return a list of instance for the ids
|
|
'''
|
|
ids = map(int, ids)
|
|
local_cache = LRUDict(RECORD_CACHE_SIZE)
|
|
return [cls(int(x), _ids=ids, _local_cache=local_cache) for x in ids]
|
|
|
|
@staticmethod
|
|
def __export_row(record, fields_names):
|
|
pool = Pool()
|
|
lines = []
|
|
data = ['' for x in range(len(fields_names))]
|
|
done = []
|
|
for fpos in range(len(fields_names)):
|
|
fields_tree = fields_names[fpos]
|
|
if not fields_tree:
|
|
continue
|
|
value = record
|
|
i = 0
|
|
while i < len(fields_tree):
|
|
if not isinstance(value, ModelStorage):
|
|
break
|
|
field_name = fields_tree[i]
|
|
eModel = pool.get(value.__name__)
|
|
field = eModel._fields[field_name]
|
|
if field.states and 'invisible' in field.states:
|
|
pyson_invisible = PYSONEncoder().encode(
|
|
field.states['invisible'])
|
|
env = EvalEnvironment(value, eModel)
|
|
env.update(Transaction().context)
|
|
env['current_date'] = datetime.datetime.today()
|
|
env['time'] = time
|
|
env['context'] = Transaction().context
|
|
env['active_id'] = value.id
|
|
invisible = PYSONDecoder(env).decode(pyson_invisible)
|
|
if invisible:
|
|
value = ''
|
|
break
|
|
value = getattr(value, field_name)
|
|
if isinstance(value, (list, tuple)):
|
|
first = True
|
|
child_fields_names = [(x[:i + 1] == fields_tree[:i + 1] and
|
|
x[i + 1:]) or [] for x in fields_names]
|
|
if child_fields_names in done:
|
|
break
|
|
done.append(child_fields_names)
|
|
for child_record in value:
|
|
child_lines = ModelStorage.__export_row(child_record,
|
|
child_fields_names)
|
|
if first:
|
|
for child_fpos in xrange(len(fields_names)):
|
|
if child_lines and child_lines[0][child_fpos]:
|
|
data[child_fpos] = \
|
|
child_lines[0][child_fpos]
|
|
lines += child_lines[1:]
|
|
first = False
|
|
else:
|
|
lines += child_lines
|
|
break
|
|
i += 1
|
|
if i == len(fields_tree):
|
|
if value is None:
|
|
value = ''
|
|
elif isinstance(value, Model):
|
|
value = str(value)
|
|
data[fpos] = value
|
|
return [data] + lines
|
|
|
|
@classmethod
|
|
def export_data(cls, records, fields_names):
|
|
'''
|
|
Return list of list of values for each record.
|
|
The list of values follows fields_names.
|
|
Relational fields are defined with '/' at any depth.
|
|
'''
|
|
fields_names = [x.split('/') for x in fields_names]
|
|
data = []
|
|
for record in records:
|
|
data += cls.__export_row(record, fields_names)
|
|
return data
|
|
|
|
@classmethod
|
|
def import_data(cls, fields_names, data):
|
|
'''
|
|
Create records for all values in data.
|
|
The field names of values must be defined in fields_names.
|
|
It returns a tuple with
|
|
- the number of records imported
|
|
- the last values if failed
|
|
- the exception if failed
|
|
- the warning if failed
|
|
'''
|
|
pool = Pool()
|
|
|
|
def process_lines(data, prefix, fields_def, position=0):
|
|
|
|
def warn(msgname, *args):
|
|
msg = cls.raise_user_error(msgname, args,
|
|
raise_exception=False)
|
|
logger.warn(msg)
|
|
|
|
def get_selection(selection, value):
|
|
res = None
|
|
if not isinstance(selection, (tuple, list)):
|
|
selection = getattr(cls, selection)()
|
|
for key, _ in selection:
|
|
if str(key) == value:
|
|
res = key
|
|
break
|
|
if value and not res:
|
|
warn('not_found_in_selection', value, '/'.join(field))
|
|
return res
|
|
|
|
def get_many2one(relation, value):
|
|
if not value:
|
|
return None
|
|
Relation = pool.get(relation)
|
|
res = Relation.search([
|
|
('rec_name', '=', value),
|
|
], limit=2)
|
|
if len(res) < 1:
|
|
warn('relation_not_found', value, relation)
|
|
res = None
|
|
elif len(res) > 1:
|
|
warn('too_many_relations_found', value, relation)
|
|
res = None
|
|
else:
|
|
res = res[0].id
|
|
return res
|
|
|
|
def get_many2many(relation, value):
|
|
if not value:
|
|
return None
|
|
res = []
|
|
Relation = pool.get(relation)
|
|
for word in csv.reader(StringIO.StringIO(value), delimiter=',',
|
|
quoting=csv.QUOTE_NONE, escapechar='\\').next():
|
|
res2 = Relation.search([
|
|
('rec_name', '=', word),
|
|
], limit=2)
|
|
if len(res2) < 1:
|
|
warn('relation_not_found', word, relation)
|
|
elif len(res2) > 1:
|
|
warn('too_many_relations_found', word, relation)
|
|
else:
|
|
res.extend(res2)
|
|
if len(res):
|
|
res = [('set', [x.id for x in res])]
|
|
return res
|
|
|
|
def get_one2one(relation, value):
|
|
return ('set', get_many2one(relation, value))
|
|
|
|
def get_reference(value):
|
|
if not value:
|
|
return None
|
|
try:
|
|
relation, value = value.split(',', 1)
|
|
except Exception:
|
|
warn('reference_syntax_error', value, '/'.join(field))
|
|
return None
|
|
Relation = pool.get(relation)
|
|
res = Relation.search([
|
|
('rec_name', '=', value),
|
|
], limit=2)
|
|
if len(res) < 1:
|
|
warn('relation_not_found', value, relation)
|
|
res = None
|
|
elif len(res) > 1:
|
|
warn('too_many_relations_found', value, relation)
|
|
res = None
|
|
else:
|
|
res = '%s,%s' % (relation, res[0].id)
|
|
return res
|
|
|
|
def get_by_id(value):
|
|
if not value:
|
|
return None
|
|
relation = None
|
|
ftype = fields_def[field[-1][:-3]]['type']
|
|
if ftype == 'many2many':
|
|
value = csv.reader(StringIO.StringIO(value), delimiter=',',
|
|
quoting=csv.QUOTE_NONE, escapechar='\\').next()
|
|
elif ftype == 'reference':
|
|
try:
|
|
relation, value = value.split(',', 1)
|
|
except Exception:
|
|
warn('reference_syntax_error', value, '/'.join(field))
|
|
return None
|
|
value = [value]
|
|
else:
|
|
value = [value]
|
|
res_ids = []
|
|
for word in value:
|
|
try:
|
|
module, xml_id = word.rsplit('.', 1)
|
|
except Exception:
|
|
warn('xml_id_syntax_error', word, '/'.join(field))
|
|
continue
|
|
db_id = ModelData.get_id(module, xml_id)
|
|
res_ids.append(db_id)
|
|
if ftype == 'many2many' and res_ids:
|
|
return [('set', res_ids)]
|
|
elif ftype == 'reference' and res_ids:
|
|
return '%s,%s' % (relation, str(res_ids[0]))
|
|
return res_ids and res_ids[0] or False
|
|
|
|
line = data[position]
|
|
row = {}
|
|
translate = {}
|
|
todo = set()
|
|
prefix_len = len(prefix)
|
|
# Import normal fields_names
|
|
for i, field in enumerate(fields_names):
|
|
if i >= len(line):
|
|
raise Exception('ImportError',
|
|
'Please check that all your lines have %d cols.'
|
|
% len(fields_names))
|
|
is_prefix_len = (len(field) == (prefix_len + 1))
|
|
value = line[i]
|
|
if is_prefix_len and field[-1].endswith(':id'):
|
|
row[field[0][:-3]] = get_by_id(value)
|
|
elif is_prefix_len and ':lang=' in field[-1]:
|
|
field_name, lang = field[-1].split(':lang=')
|
|
translate.setdefault(lang, {})[field_name] = value or False
|
|
elif is_prefix_len and prefix == field[:-1]:
|
|
this_field_def = fields_def[field[-1]]
|
|
field_type = this_field_def['type']
|
|
res = None
|
|
if field_type == 'boolean':
|
|
if value.lower() == 'true':
|
|
res = True
|
|
elif value.lower() == 'false':
|
|
res = False
|
|
elif not value:
|
|
res = False
|
|
else:
|
|
res = bool(int(value))
|
|
elif field_type == 'integer':
|
|
res = int(value) if value else None
|
|
elif field_type == 'float':
|
|
res = float(value) if value else None
|
|
elif field_type == 'numeric':
|
|
res = Decimal(value) if value else None
|
|
elif field_type == 'date':
|
|
res = (datetime.date(
|
|
*time.strptime(value, '%Y-%m-%d')[:3])
|
|
if value else None)
|
|
elif field_type == 'datetime':
|
|
res = (datetime.datetime(
|
|
*time.strptime(value, '%Y-%m-%d %H:%M:%S')[:6])
|
|
if value else None)
|
|
elif field_type == 'selection':
|
|
res = get_selection(this_field_def['selection'], value)
|
|
elif field_type == 'many2one':
|
|
res = get_many2one(this_field_def['relation'], value)
|
|
elif field_type == 'many2many':
|
|
res = get_many2many(this_field_def['relation'], value)
|
|
elif field_type == 'one2one':
|
|
res = get_one2one(this_field_def['relation'], value)
|
|
elif field_type == 'reference':
|
|
res = get_reference(value)
|
|
else:
|
|
res = value or None
|
|
row[field[-1]] = res
|
|
elif prefix == field[0:prefix_len]:
|
|
todo.add(field[prefix_len])
|
|
# Import one2many fields
|
|
nbrmax = 1
|
|
for field in todo:
|
|
newfd = pool.get(fields_def[field]['relation']
|
|
).fields_get()
|
|
res = process_lines(data, prefix + [field], newfd,
|
|
position)
|
|
(newrow, max2, _) = res
|
|
nbrmax = max(nbrmax, max2)
|
|
reduce(lambda x, y: x and y, newrow)
|
|
row[field] = (reduce(lambda x, y: x or y, newrow.values()) and
|
|
[('create', [newrow])]) or []
|
|
i = max2
|
|
while (position + i) < len(data):
|
|
test = True
|
|
for j, field2 in enumerate(fields_names):
|
|
if (len(field2) <= (prefix_len + 1)
|
|
and data[position + i][j]):
|
|
test = False
|
|
break
|
|
if not test:
|
|
break
|
|
(newrow, max2, _) = \
|
|
process_lines(data, prefix + [field], newfd,
|
|
position + i)
|
|
if reduce(lambda x, y: x or y, newrow.values()):
|
|
row[field].append(('create', [newrow]))
|
|
i += max2
|
|
nbrmax = max(nbrmax, i)
|
|
if prefix_len == 0:
|
|
for i in xrange(max(nbrmax, 1)):
|
|
data.pop(0)
|
|
return (row, nbrmax, translate)
|
|
|
|
ModelData = pool.get('ir.model.data')
|
|
|
|
# logger for collecting warnings for the client
|
|
logger = logging.Logger("import")
|
|
warning_stream = StringIO.StringIO()
|
|
logger.addHandler(logging.StreamHandler(warning_stream))
|
|
|
|
len_fields_names = len(fields_names)
|
|
assert all(len(x) == len_fields_names for x in data)
|
|
fields_names = [x.split('/') for x in fields_names]
|
|
fields_def = cls.fields_get()
|
|
done = 0
|
|
|
|
warning = ''
|
|
while len(data):
|
|
res = {}
|
|
try:
|
|
(res, _, translate) = \
|
|
process_lines(data, [], fields_def)
|
|
warning = warning_stream.getvalue()
|
|
if warning:
|
|
# XXX should raise Exception
|
|
Transaction().cursor.rollback()
|
|
return (-1, res, warning, '')
|
|
new_id, = cls.create([res])
|
|
for lang in translate:
|
|
with Transaction().set_context(language=lang):
|
|
cls.write(new_id, translate[lang])
|
|
except Exception, exp:
|
|
logger = logging.getLogger('import')
|
|
logger.error(exp)
|
|
# XXX should raise Exception
|
|
Transaction().cursor.rollback()
|
|
tb_s = ''.join(traceback.format_exception(*sys.exc_info()))
|
|
warning = '%s\n%s' % (tb_s, warning)
|
|
return (-1, res, exp, warning)
|
|
done += 1
|
|
return (done, 0, 0, 0)
|
|
|
|
@classmethod
|
|
def check_xml_record(cls, records, values):
|
|
"""
|
|
Check if a list of records and their corresponding fields are
|
|
originating from xml data. This is used by write and delete
|
|
functions: if the return value is True the records can be
|
|
written/deleted, False otherwise. The default behaviour is to
|
|
forbid any modification on records/fields originating from
|
|
xml. Values is the dictionary of written values. If values is
|
|
equal to None, no field by field check is performed, False is
|
|
returned as soon as one of the record comes from the xml.
|
|
"""
|
|
ModelData = Pool().get('ir.model.data')
|
|
# Allow root user to update/delete
|
|
if Transaction().user == 0:
|
|
return True
|
|
with Transaction().set_user(0):
|
|
models_data = ModelData.search([
|
|
('model', '=', cls.__name__),
|
|
('db_id', 'in', map(int, records)),
|
|
])
|
|
if not models_data:
|
|
return True
|
|
if values is None:
|
|
return False
|
|
for model_data in models_data:
|
|
if not model_data.values:
|
|
continue
|
|
xml_values = safe_eval(model_data.values, {
|
|
'Decimal': Decimal,
|
|
'datetime': datetime,
|
|
})
|
|
for key, val in values.iteritems():
|
|
if key in xml_values and val != xml_values[key]:
|
|
return False
|
|
return True
|
|
|
|
@classmethod
|
|
def check_recursion(cls, records, parent='parent', rec_name='rec_name'):
|
|
'''
|
|
Function that checks if there is no recursion in the tree
|
|
composed with parent as parent field name.
|
|
'''
|
|
parent_type = cls._fields[parent]._type
|
|
|
|
if parent_type not in ('many2one', 'many2many', 'one2one'):
|
|
raise Exception(
|
|
'Unsupported field type "%s" for field "%s" on "%s"'
|
|
% (parent_type, parent, cls.__name__))
|
|
|
|
visited = set()
|
|
|
|
for record in records:
|
|
walked = set()
|
|
walker = getattr(record, parent)
|
|
while walker:
|
|
if parent_type == 'many2many':
|
|
for walk in walker:
|
|
walked.add(walk.id)
|
|
if walk.id == record.id:
|
|
parent_rec_name = ', '.join(getattr(r, rec_name)
|
|
for r in getattr(record, parent))
|
|
cls.raise_user_error('recursion_error', {
|
|
'rec_name': getattr(record, rec_name),
|
|
'parent_rec_name': parent_rec_name,
|
|
})
|
|
walker = list(chain(*(getattr(walk, parent)
|
|
for walk in walker if walk.id not in visited)))
|
|
else:
|
|
walked.add(walker.id)
|
|
if walker.id == record.id:
|
|
cls.raise_user_error('recursion_error', {
|
|
'rec_name': getattr(record, rec_name),
|
|
'parent_rec_name': getattr(getattr(record,
|
|
parent), rec_name)
|
|
})
|
|
walker = (getattr(walker, parent) not in visited
|
|
and getattr(walker, parent))
|
|
visited.update(walked)
|
|
|
|
@classmethod
|
|
def _get_error_args(cls, field_name):
|
|
pool = Pool()
|
|
ModelField = pool.get('ir.model.field')
|
|
error_args = (field_name, cls.__name__)
|
|
if ModelField:
|
|
model_fields = ModelField.search([
|
|
('name', '=', field_name),
|
|
('model.model', '=', cls.__name__),
|
|
], limit=1)
|
|
if model_fields:
|
|
model_field, = model_fields
|
|
error_args = (model_field.field_description,
|
|
model_field.model.name)
|
|
return error_args
|
|
|
|
@classmethod
|
|
def validate(cls, records):
|
|
pass
|
|
|
|
@classmethod
|
|
def _validate(cls, records):
|
|
pool = Pool()
|
|
# Ensure that records are readable
|
|
with Transaction().set_user(0, set_context=True):
|
|
records = cls.browse(records)
|
|
|
|
def call(name):
|
|
method = getattr(cls, name)
|
|
if not hasattr(method, 'im_self') or method.im_self:
|
|
return method(records)
|
|
else:
|
|
return all(method(r) for r in records)
|
|
for field in cls._constraints:
|
|
warnings.warn(
|
|
'_constraints is deprecated, override validate instead',
|
|
DeprecationWarning, stacklevel=2)
|
|
if not call(field[0]):
|
|
cls.raise_user_error(field[1])
|
|
|
|
if not 'res.user' in pool.object_name_list() \
|
|
or Transaction().user == 0:
|
|
ctx_pref = {
|
|
}
|
|
else:
|
|
User = pool.get('res.user')
|
|
ctx_pref = User.get_preferences(context_only=True)
|
|
|
|
def is_pyson(test):
|
|
if isinstance(test, PYSON):
|
|
return True
|
|
if isinstance(test, (list, tuple)):
|
|
for i in test:
|
|
if isinstance(i, PYSON):
|
|
return True
|
|
if isinstance(i, (list, tuple)):
|
|
if is_pyson(i):
|
|
return True
|
|
if isinstance(test, dict):
|
|
for key, value in test.items():
|
|
if isinstance(value, PYSON):
|
|
return True
|
|
if isinstance(value, (list, tuple, dict)):
|
|
if is_pyson(value):
|
|
return True
|
|
return False
|
|
|
|
ctx_pref['active_test'] = False
|
|
with Transaction().set_context(ctx_pref):
|
|
for field_name, field in cls._fields.iteritems():
|
|
if isinstance(field, fields.Function) and \
|
|
not field.setter:
|
|
continue
|
|
# validate domain
|
|
if (field._type in
|
|
('many2one', 'many2many', 'one2many', 'one2one')
|
|
and field.domain):
|
|
if field._type in ('many2one', 'one2many'):
|
|
Relation = pool.get(field.model_name)
|
|
else:
|
|
Relation = field.get_target()
|
|
if is_pyson(field.domain):
|
|
pyson_domain = PYSONEncoder().encode(field.domain)
|
|
for record in records:
|
|
env = EvalEnvironment(record, cls)
|
|
env.update(Transaction().context)
|
|
env['current_date'] = datetime.datetime.today()
|
|
env['time'] = time
|
|
env['context'] = Transaction().context
|
|
env['active_id'] = record.id
|
|
domain = PYSONDecoder(env).decode(pyson_domain)
|
|
relation_ids = []
|
|
if getattr(record, field_name):
|
|
if field._type in ('many2one', 'one2one'):
|
|
relation_ids.append(
|
|
getattr(record, field_name).id)
|
|
else:
|
|
relation_ids.extend(
|
|
[x.id for x in getattr(record,
|
|
field_name)])
|
|
if relation_ids and not Relation.search([
|
|
'AND',
|
|
[('id', 'in', relation_ids)],
|
|
domain,
|
|
]):
|
|
cls.raise_user_error(
|
|
'domain_validation_record',
|
|
error_args=cls._get_error_args(
|
|
field_name))
|
|
else:
|
|
relation_ids = []
|
|
for record in records:
|
|
if getattr(record, field_name):
|
|
if field._type in ('many2one', 'one2one'):
|
|
relation_ids.append(
|
|
getattr(record, field_name).id)
|
|
else:
|
|
relation_ids.extend(
|
|
[x.id for x in getattr(record,
|
|
field_name)])
|
|
if relation_ids:
|
|
finds = Relation.search([
|
|
'AND',
|
|
[('id', 'in', relation_ids)],
|
|
field.domain,
|
|
])
|
|
find_ids = map(int, finds)
|
|
if not set(relation_ids) == set(find_ids):
|
|
cls.raise_user_error(
|
|
'domain_validation_record',
|
|
error_args=cls._get_error_args(
|
|
field_name))
|
|
|
|
def required_test(value, field_name):
|
|
if (isinstance(value, (type(None), type(False), list,
|
|
tuple, basestring, dict))
|
|
and not value):
|
|
cls.raise_user_error('required_validation_record',
|
|
error_args=cls._get_error_args(field_name))
|
|
# validate states required
|
|
if field.states and 'required' in field.states:
|
|
if is_pyson(field.states['required']):
|
|
pyson_required = PYSONEncoder().encode(
|
|
field.states['required'])
|
|
for record in records:
|
|
env = EvalEnvironment(record, cls)
|
|
env.update(Transaction().context)
|
|
env['current_date'] = datetime.datetime.today()
|
|
env['time'] = time
|
|
env['context'] = Transaction().context
|
|
env['active_id'] = record.id
|
|
required = PYSONDecoder(env).decode(pyson_required)
|
|
if required:
|
|
required_test(getattr(record, field_name),
|
|
field_name)
|
|
else:
|
|
if field.states['required']:
|
|
for record in records:
|
|
required_test(getattr(record, field_name),
|
|
field_name)
|
|
# validate required
|
|
if field.required:
|
|
for record in records:
|
|
required_test(getattr(record, field_name), field_name)
|
|
# validate size
|
|
if hasattr(field, 'size') and field.size is not None:
|
|
for record in records:
|
|
if isinstance(field.size, PYSON):
|
|
pyson_size = PYSONEncoder().encode(field.size)
|
|
env = EvalEnvironment(record, cls)
|
|
env.update(Transaction().context)
|
|
env['current_date'] = datetime.datetime.today()
|
|
env['time'] = time
|
|
env['context'] = Transaction().context
|
|
env['active_id'] = record.id
|
|
field_size = PYSONDecoder(env).decode(pyson_size)
|
|
else:
|
|
field_size = field.size
|
|
if (len(getattr(record, field_name) or '')
|
|
> field_size >= 0):
|
|
cls.raise_user_error(
|
|
'size_validation_record',
|
|
error_args=cls._get_error_args(field_name))
|
|
|
|
def digits_test(value, digits, field_name):
|
|
def raise_user_error():
|
|
cls.raise_user_error('digits_validation_record',
|
|
error_args=cls._get_error_args(field_name))
|
|
if value is None:
|
|
return
|
|
if isinstance(value, Decimal):
|
|
if (value.quantize(Decimal(str(10.0 ** -digits[1])))
|
|
!= value):
|
|
raise_user_error()
|
|
elif CONFIG.options['db_type'] != 'mysql':
|
|
if not (round(value, digits[1]) == float(value)):
|
|
raise_user_error()
|
|
# validate digits
|
|
if hasattr(field, 'digits') and field.digits:
|
|
if is_pyson(field.digits):
|
|
pyson_digits = PYSONEncoder().encode(field.digits)
|
|
for record in records:
|
|
env = EvalEnvironment(record, cls)
|
|
env.update(Transaction().context)
|
|
env['current_date'] = datetime.datetime.today()
|
|
env['time'] = time
|
|
env['context'] = Transaction().context
|
|
env['active_id'] = record.id
|
|
digits = PYSONDecoder(env).decode(pyson_digits)
|
|
digits_test(getattr(record, field_name), digits,
|
|
field_name)
|
|
else:
|
|
for record in records:
|
|
digits_test(getattr(record, field_name),
|
|
field.digits, field_name)
|
|
|
|
# validate selection
|
|
if hasattr(field, 'selection') and field.selection:
|
|
if isinstance(field.selection, (tuple, list)):
|
|
test = set(dict(field.selection).keys())
|
|
for record in records:
|
|
value = getattr(record, field_name)
|
|
if field._type == 'reference':
|
|
if isinstance(value, ModelStorage):
|
|
value = value.__class__.__name__
|
|
elif value:
|
|
value, _ = value.split(',')
|
|
if not isinstance(field.selection, (tuple, list)):
|
|
sel_func = getattr(cls, field.selection)
|
|
if field.selection_change_with:
|
|
test = sel_func(record)
|
|
else:
|
|
test = sel_func()
|
|
test = set(dict(test))
|
|
# None and '' are equivalent
|
|
if '' in test or None in test:
|
|
test.add('')
|
|
test.add(None)
|
|
if value not in test:
|
|
cls.raise_user_error('selection_validation_record',
|
|
error_args=cls._get_error_args(field_name))
|
|
|
|
def format_test(value, format, field_name):
|
|
if not value:
|
|
return
|
|
if not isinstance(value, datetime.time):
|
|
value = value.time()
|
|
if value != datetime.datetime.strptime(
|
|
value.strftime(format), format).time():
|
|
cls.raise_user_error('time_format_validation_record',
|
|
error_args=cls._get_error_args(field_name))
|
|
|
|
# validate time format
|
|
if (field._type in ('datetime', 'time')
|
|
and field_name not in ('create_date', 'write_date')):
|
|
if is_pyson(field.format):
|
|
pyson_format = PYSONDecoder().encode(field.format)
|
|
for record in records:
|
|
env = EvalEnvironment(record, cls)
|
|
env.update(Transaction().context)
|
|
env['current_date'] = datetime.datetime.today()
|
|
env['time'] = time
|
|
env['context'] = Transaction().context
|
|
env['active_id'] = record.id
|
|
format = PYSONDecoder(env).decode(pyson_format)
|
|
format_test(getattr(record, field_name), format,
|
|
field_name)
|
|
else:
|
|
for record in records:
|
|
format_test(getattr(record, field_name),
|
|
field.format, field_name)
|
|
|
|
for record in records:
|
|
record.pre_validate()
|
|
|
|
cls.validate(records)
|
|
|
|
@classmethod
|
|
def _clean_defaults(cls, defaults):
|
|
pool = Pool()
|
|
vals = {}
|
|
for field in defaults.keys():
|
|
fld_def = cls._fields[field]
|
|
if fld_def._type in ('many2one', 'one2one'):
|
|
if isinstance(defaults[field], (list, tuple)):
|
|
vals[field] = defaults[field][0]
|
|
else:
|
|
vals[field] = defaults[field]
|
|
elif fld_def._type in ('one2many',):
|
|
obj = pool.get(fld_def.model_name)
|
|
vals[field] = []
|
|
for defaults2 in defaults[field]:
|
|
vals2 = obj._clean_defaults(defaults2)
|
|
vals[field].append(('create', [vals2]))
|
|
elif fld_def._type in ('many2many',):
|
|
vals[field] = [('set', defaults[field])]
|
|
elif fld_def._type in ('boolean',):
|
|
vals[field] = bool(defaults[field])
|
|
else:
|
|
vals[field] = defaults[field]
|
|
return vals
|
|
|
|
def __init__(self, id=None, **kwargs):
|
|
_ids = kwargs.pop('_ids', None)
|
|
_local_cache = kwargs.pop('_local_cache', None)
|
|
super(ModelStorage, self).__init__(id, **kwargs)
|
|
self._cursor = Transaction().cursor
|
|
self._user = Transaction().user
|
|
self._context = Transaction().context
|
|
if _ids is not None:
|
|
self._ids = _ids
|
|
assert id in _ids
|
|
else:
|
|
self._ids = [self.id]
|
|
|
|
self._cursor_cache = self._cursor.get_cache(self._context)
|
|
|
|
if _local_cache is not None:
|
|
self._local_cache = _local_cache
|
|
else:
|
|
self._local_cache = LRUDict(RECORD_CACHE_SIZE)
|
|
self._local_cache.counter = Transaction().counter
|
|
|
|
@property
|
|
def _cache(self):
|
|
cache = self._cursor_cache
|
|
if self.__name__ not in cache:
|
|
cache[self.__name__] = LRUDict(RECORD_CACHE_SIZE)
|
|
return cache[self.__name__]
|
|
|
|
def __getattr__(self, name):
|
|
try:
|
|
return super(ModelStorage, self).__getattr__(name)
|
|
except AttributeError:
|
|
if self.id < 0:
|
|
raise
|
|
|
|
counter = Transaction().counter
|
|
if self._local_cache.counter != counter:
|
|
self._local_cache.clear()
|
|
self._local_cache.counter = counter
|
|
|
|
# fetch the definition of the field
|
|
try:
|
|
field = self._fields[name]
|
|
except KeyError:
|
|
raise AttributeError('"%s" has no attribute "%s"' % (self, name))
|
|
|
|
try:
|
|
return self._local_cache[self.id][name]
|
|
except KeyError:
|
|
pass
|
|
try:
|
|
if field._type not in ('many2one', 'reference'):
|
|
return self._cache[self.id][name]
|
|
except KeyError:
|
|
pass
|
|
|
|
# build the list of fields we will fetch
|
|
ffields = {
|
|
name: field,
|
|
}
|
|
if field.loading == 'eager':
|
|
FieldAccess = Pool().get('ir.model.field.access')
|
|
fread_accesses = {}
|
|
fread_accesses.update(FieldAccess.check(self.__name__,
|
|
self._fields.keys(), 'read', access=True))
|
|
to_remove = set(x for x, y in fread_accesses.iteritems()
|
|
if not y and x != name)
|
|
|
|
threshold = BROWSE_FIELD_TRESHOLD
|
|
|
|
def not_cached(item):
|
|
fname, field = item
|
|
return (fname not in self._cache.get(self.id, {})
|
|
and fname not in self._local_cache.get(self.id, {}))
|
|
|
|
def to_load(item):
|
|
fname, field = item
|
|
return (field.loading == 'eager'
|
|
and fname not in to_remove)
|
|
|
|
def overrided(item):
|
|
fname, field = item
|
|
return fname in self._fields
|
|
|
|
ifields = ifilter(to_load,
|
|
ifilter(not_cached,
|
|
self._fields.iteritems()))
|
|
ifields = islice(ifields, 0, threshold)
|
|
ffields.update(ifields)
|
|
|
|
# add datetime_field
|
|
for field in ffields.values():
|
|
if hasattr(field, 'datetime_field') and field.datetime_field:
|
|
datetime_field = self._fields[field.datetime_field]
|
|
ffields[field.datetime_field] = datetime_field
|
|
|
|
def filter_(id_):
|
|
return (name not in self._cache.get(id_, {})
|
|
and name not in self._local_cache.get(id_, {}))
|
|
index = self._ids.index(self.id)
|
|
ids = chain(islice(self._ids, index, None),
|
|
islice(self._ids, 0, max(index - 1, 0)))
|
|
ids = islice(ifilter(filter_, ids), self._cursor.IN_MAX)
|
|
|
|
def instantiate(field, value, data):
|
|
if field._type in ('many2one', 'one2one', 'reference'):
|
|
if value is None or value is False:
|
|
return None
|
|
elif field._type in ('one2many', 'many2many'):
|
|
if not value:
|
|
return ()
|
|
try:
|
|
if field._type == 'reference':
|
|
model_name, record_id = value.split(',')
|
|
Model = Pool().get(model_name)
|
|
try:
|
|
value = int(record_id)
|
|
except ValueError:
|
|
return value
|
|
else:
|
|
Model = field.get_target()
|
|
except KeyError:
|
|
return value
|
|
ctx = {}
|
|
datetime_ = None
|
|
if getattr(field, 'datetime_field', None):
|
|
datetime_ = data.get(field.datetime_field)
|
|
ctx = {'_datetime': datetime_}
|
|
with Transaction().set_context(**ctx):
|
|
local_cache = model2cache.setdefault((Model, datetime_),
|
|
LRUDict(RECORD_CACHE_SIZE))
|
|
ids = model2ids.setdefault((Model, datetime_), [])
|
|
if field._type in ('many2one', 'one2one', 'reference'):
|
|
ids.append(value)
|
|
return Model(value, _ids=ids, _local_cache=local_cache)
|
|
elif field._type in ('one2many', 'many2many'):
|
|
ids.extend(value)
|
|
return tuple(Model(id, _ids=ids, _local_cache=local_cache)
|
|
for id in value)
|
|
|
|
model2ids = {}
|
|
model2cache = {}
|
|
# Read the data
|
|
with contextlib.nested(Transaction().set_cursor(self._cursor),
|
|
Transaction().set_user(self._user),
|
|
Transaction().set_context(self._context)):
|
|
if self.id in self._cache and name in self._cache[self.id]:
|
|
# Use values from cache
|
|
ids = islice(chain(islice(self._ids, index, None),
|
|
islice(self._ids, 0, max(index - 1, 0))),
|
|
self._cursor.IN_MAX)
|
|
ffields = {name: ffields[name]}
|
|
read_data = [{'id': i, name: self._cache[i][name]}
|
|
for i in ids
|
|
if i in self._cache and name in self._cache[i]]
|
|
else:
|
|
read_data = self.read(list(ids), ffields.keys())
|
|
# create browse records for 'remote' models
|
|
for data in read_data:
|
|
for fname, field in ffields.iteritems():
|
|
fvalue = data[fname]
|
|
if field._type in ('many2one', 'one2one', 'one2many',
|
|
'many2many', 'reference'):
|
|
fvalue = instantiate(field, data[fname], data)
|
|
if data['id'] == self.id and fname == name:
|
|
value = fvalue
|
|
if (field._type not in ('many2one', 'one2one', 'one2many',
|
|
'many2many', 'reference')
|
|
and not isinstance(field, fields.Function)):
|
|
continue
|
|
if data['id'] not in self._local_cache:
|
|
self._local_cache[data['id']] = {}
|
|
self._local_cache[data['id']][fname] = fvalue
|
|
if (field._type not in ('many2one', 'reference')
|
|
or getattr(field, 'datetime_field', None)
|
|
or isinstance(field, fields.Function)):
|
|
del data[fname]
|
|
if data['id'] not in self._cache:
|
|
self._cache[data['id']] = {}
|
|
self._cache[data['id']].update(data)
|
|
return value
|
|
|
|
@property
|
|
def _save_values(self):
|
|
values = {}
|
|
if not self._values:
|
|
return values
|
|
for fname, value in self._values.iteritems():
|
|
field = self._fields[fname]
|
|
if field._type in ('many2one', 'one2one', 'reference'):
|
|
if value:
|
|
if value.id < 0 and field._type != 'reference':
|
|
value.save()
|
|
if field._type == 'reference':
|
|
value = str(value)
|
|
else:
|
|
value = value.id
|
|
if field._type in ('one2many', 'many2many'):
|
|
targets = value
|
|
value = [
|
|
('set', []),
|
|
]
|
|
for target in targets:
|
|
if target.id < 0:
|
|
value.append(('create', [target._save_values]))
|
|
else:
|
|
value[0][1].append(target.id)
|
|
if target._save_values:
|
|
value.append(
|
|
('write', [target.id], target._save_values))
|
|
values[fname] = value
|
|
return values
|
|
|
|
def save(self):
|
|
save_values = self._save_values
|
|
values = self._values
|
|
self._values = None
|
|
if save_values or self.id < 0:
|
|
try:
|
|
with contextlib.nested(Transaction().set_cursor(self._cursor),
|
|
Transaction().set_user(self._user),
|
|
Transaction().set_context(self._context)):
|
|
if self.id < 0:
|
|
self._ids.remove(self.id)
|
|
try:
|
|
self.id = self.create([save_values])[0].id
|
|
finally:
|
|
self._ids.append(self.id)
|
|
else:
|
|
self.write([self], save_values)
|
|
except:
|
|
self._values = values
|
|
raise
|
|
|
|
|
|
class EvalEnvironment(dict):
|
|
|
|
def __init__(self, record, Model):
|
|
super(EvalEnvironment, self).__init__()
|
|
self._record = record
|
|
self._model = Model
|
|
|
|
def __getitem__(self, item):
|
|
if item.startswith('_parent_'):
|
|
field = item[8:]
|
|
model_name = self._model._fields[field].model_name
|
|
ParentModel = Pool().get(model_name)
|
|
return EvalEnvironment(getattr(self._record, field), ParentModel)
|
|
if item in self._model._fields:
|
|
value = getattr(self._record, item)
|
|
if isinstance(value, Model):
|
|
if self._model._fields[item]._type == 'reference':
|
|
return str(value)
|
|
return value.id
|
|
elif isinstance(value, (list, tuple)):
|
|
return [r.id for r in value]
|
|
else:
|
|
return value
|
|
return super(EvalEnvironment, self).__getitem__(item)
|
|
|
|
def __getattr__(self, item):
|
|
try:
|
|
return self.__getitem__(item)
|
|
except KeyError, exception:
|
|
raise AttributeError(*exception.args)
|
|
|
|
def get(self, item, default=None):
|
|
try:
|
|
return self.__getitem__(item)
|
|
except Exception:
|
|
pass
|
|
return super(EvalEnvironment, self).get(item, default)
|
|
|
|
def __nonzero__(self):
|
|
return bool(self._record)
|