Cédric Krier
e0379a9d5b
When a record XML is removed and it can not be deleted, it could also not be allowed to inactivate it. issue4964 review17491002
840 lines
31 KiB
Python
840 lines
31 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 time
|
|
from xml import sax
|
|
import logging
|
|
import re
|
|
from itertools import izip
|
|
from collections import defaultdict
|
|
from decimal import Decimal
|
|
|
|
from . import __version__
|
|
from .tools import grouped_slice
|
|
from .transaction import Transaction
|
|
from .pyson import PYSONEncoder, CONTEXT
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
CDATA_START = re.compile('^\s*\<\!\[cdata\[', re.IGNORECASE)
|
|
CDATA_END = re.compile('\]\]\>\s*$', re.IGNORECASE)
|
|
|
|
|
|
class DummyTagHandler:
|
|
"""Dubhandler implementing empty methods. Will be used when whe
|
|
want to ignore the xml content"""
|
|
|
|
def __init__(self):
|
|
pass
|
|
|
|
def startElement(self, name, attributes):
|
|
pass
|
|
|
|
def characters(self, data):
|
|
pass
|
|
|
|
def endElement(self, name):
|
|
pass
|
|
|
|
|
|
class MenuitemTagHandler:
|
|
"""Taghandler for the tag <record> """
|
|
def __init__(self, master_handler):
|
|
self.mh = master_handler
|
|
self.xml_id = None
|
|
|
|
def startElement(self, name, attributes):
|
|
cursor = Transaction().cursor
|
|
|
|
values = {}
|
|
|
|
self.xml_id = attributes['id']
|
|
|
|
for attr in ('name', 'icon', 'sequence', 'parent', 'action', 'groups'):
|
|
if attributes.get(attr):
|
|
values[attr] = attributes.get(attr)
|
|
|
|
if attributes.get('active'):
|
|
values['active'] = bool(eval(attributes['active']))
|
|
|
|
if values.get('parent'):
|
|
values['parent'] = self.mh.get_id(values['parent'])
|
|
|
|
action_name = None
|
|
if values.get('action'):
|
|
action_id = self.mh.get_id(values['action'])
|
|
|
|
# TODO maybe use a prefetch for this:
|
|
action = self.mh.pool.get('ir.action').__table__()
|
|
report = self.mh.pool.get('ir.action.report').__table__()
|
|
act_window = self.mh.pool.get('ir.action.act_window').__table__()
|
|
wizard = self.mh.pool.get('ir.action.wizard').__table__()
|
|
url = self.mh.pool.get('ir.action.url').__table__()
|
|
act_window_view = self.mh.pool.get(
|
|
'ir.action.act_window.view').__table__()
|
|
view = self.mh.pool.get('ir.ui.view').__table__()
|
|
icon = self.mh.pool.get('ir.ui.icon').__table__()
|
|
cursor.execute(*action.join(
|
|
report, 'LEFT',
|
|
condition=action.id == report.action
|
|
).join(act_window, 'LEFT',
|
|
condition=action.id == act_window.action
|
|
).join(wizard, 'LEFT',
|
|
condition=action.id == wizard.action
|
|
).join(url, 'LEFT',
|
|
condition=action.id == url.action
|
|
).join(act_window_view, 'LEFT',
|
|
condition=act_window.id == act_window_view.act_window
|
|
).join(view, 'LEFT',
|
|
condition=view.id == act_window_view.view
|
|
).join(icon, 'LEFT',
|
|
condition=action.icon == icon.id).select(
|
|
action.name.as_('action_name'),
|
|
action.type.as_('action_type'),
|
|
view.type.as_('view_type'),
|
|
view.field_childs.as_('field_childs'),
|
|
icon.name.as_('icon_name'),
|
|
where=(report.id == action_id)
|
|
| (act_window.id == action_id)
|
|
| (wizard.id == action_id)
|
|
| (url.id == action_id),
|
|
order_by=act_window_view.sequence, limit=1))
|
|
action_name, action_type, view_type, field_childs, icon_name = \
|
|
cursor.fetchone()
|
|
|
|
values['action'] = '%s,%s' % (action_type, action_id)
|
|
|
|
icon = attributes.get('icon', '')
|
|
if icon:
|
|
values['icon'] = icon
|
|
elif icon_name:
|
|
values['icon'] = icon_name
|
|
elif action_type == 'ir.action.wizard':
|
|
values['icon'] = 'tryton-executable'
|
|
elif action_type == 'ir.action.report':
|
|
values['icon'] = 'tryton-print'
|
|
elif action_type == 'ir.action.act_window':
|
|
if view_type == 'tree':
|
|
if field_childs:
|
|
values['icon'] = 'tryton-tree'
|
|
else:
|
|
values['icon'] = 'tryton-list'
|
|
elif view_type == 'form':
|
|
values['icon'] = 'tryton-new'
|
|
elif view_type == 'graph':
|
|
values['icon'] = 'tryton-graph'
|
|
elif view_type == 'calendar':
|
|
values['icon'] = 'tryton-calendar'
|
|
elif action_type == 'ir.action.url':
|
|
values['icon'] = 'tryton-web-browser'
|
|
else:
|
|
values['icon'] = 'tryton-new'
|
|
|
|
if values.get('groups'):
|
|
raise Exception("Please use separate records for groups")
|
|
|
|
if not values.get('name'):
|
|
if not action_name:
|
|
raise Exception("Please provide at least a 'name' attributes "
|
|
"or a 'action' attributes on the menuitem tags.")
|
|
else:
|
|
values['name'] = action_name
|
|
|
|
if values.get('sequence'):
|
|
values['sequence'] = int(values['sequence'])
|
|
|
|
self.values = values
|
|
|
|
def characters(self, data):
|
|
pass
|
|
|
|
def endElement(self, name):
|
|
"""Must return the object to use for the next call """
|
|
if name != "menuitem":
|
|
return self
|
|
else:
|
|
self.mh.import_record('ir.ui.menu', self.values, self.xml_id)
|
|
return None
|
|
|
|
def current_state(self):
|
|
return "Tag menuitem with id: %s" % self.xml_id
|
|
|
|
|
|
class RecordTagHandler:
|
|
|
|
"""Taghandler for the tag <record> and all the tags inside it"""
|
|
|
|
def __init__(self, master_handler):
|
|
# Remind reference of parent handler
|
|
self.mh = master_handler
|
|
# stock xml_id parsed in one module
|
|
self.xml_ids = []
|
|
self.model = None
|
|
self.xml_id = None
|
|
self.update = None
|
|
self.values = None
|
|
self.current_field = None
|
|
self.cdata = None
|
|
self.start_cdata = None
|
|
|
|
def startElement(self, name, attributes):
|
|
|
|
# Manage the top level tag
|
|
if name == "record":
|
|
self.model = self.mh.pool.get(attributes["model"])
|
|
assert self.model, ("The model %s does not exist !"
|
|
% (attributes["model"],))
|
|
|
|
self.xml_id = attributes["id"]
|
|
self.update = bool(int(attributes.get('update', '0')))
|
|
|
|
# create/update a dict containing fields values
|
|
self.values = {}
|
|
|
|
self.current_field = None
|
|
self.cdata = False
|
|
|
|
return self.xml_id
|
|
|
|
# Manage included tags:
|
|
elif name == "field":
|
|
|
|
field_name = attributes['name']
|
|
field_type = attributes.get('type', '')
|
|
# Create a new entry in the values
|
|
self.values[field_name] = ""
|
|
# Remind the current name (see characters)
|
|
self.current_field = field_name
|
|
# Put a flag to escape cdata tags
|
|
if field_type == "xml":
|
|
self.cdata = "start"
|
|
|
|
# Catch the known attributes
|
|
search_attr = attributes.get('search', '')
|
|
ref_attr = attributes.get('ref', '')
|
|
eval_attr = attributes.get('eval', '')
|
|
pyson_attr = bool(int(attributes.get('pyson', '0')))
|
|
|
|
if search_attr:
|
|
search_model = self.model._fields[field_name].model_name
|
|
SearchModel = self.mh.pool.get(search_model)
|
|
with Transaction().set_context(active_test=False):
|
|
found, = SearchModel.search(eval(search_attr))
|
|
self.values[field_name] = found.id
|
|
|
|
elif ref_attr:
|
|
self.values[field_name] = self.mh.get_id(ref_attr)
|
|
|
|
elif eval_attr:
|
|
context = {}
|
|
context['time'] = time
|
|
context['version'] = __version__.rsplit('.', 1)[0]
|
|
context['ref'] = self.mh.get_id
|
|
context['obj'] = lambda *a: 1
|
|
context['Decimal'] = Decimal
|
|
if pyson_attr:
|
|
context.update(CONTEXT)
|
|
value = eval(eval_attr, context)
|
|
if pyson_attr:
|
|
value = PYSONEncoder().encode(value)
|
|
self.values[field_name] = value
|
|
|
|
else:
|
|
raise Exception("Tags '%s' not supported inside tag record." %
|
|
(name,))
|
|
|
|
def characters(self, data):
|
|
|
|
"""If whe are in a field tag, consume all the content"""
|
|
|
|
if not self.current_field:
|
|
return
|
|
# Escape start cdata tag if necessary
|
|
if self.cdata == "start":
|
|
data = CDATA_START.sub('', data)
|
|
self.start_cdata = "inside"
|
|
|
|
self.values[self.current_field] += data
|
|
|
|
def endElement(self, name):
|
|
|
|
"""Must return the object to use for the next call, if name is
|
|
not 'record' we return self to keep our hand on the
|
|
process. If name is 'record' we return None to end the
|
|
delegation"""
|
|
|
|
if name == "field":
|
|
if not self.current_field:
|
|
raise Exception("Application error"
|
|
"current_field expected to be set.")
|
|
# Escape end cdata tag :
|
|
if self.cdata in ('inside', 'start'):
|
|
self.values[self.current_field] = \
|
|
CDATA_END.sub('', self.values[self.current_field])
|
|
self.cdata = 'done'
|
|
|
|
value = self.values[self.current_field]
|
|
match = re.findall('[^%]%\((.*?)\)[ds]', value)
|
|
xml_ids = {}
|
|
for xml_id in match:
|
|
xml_ids[xml_id] = self.mh.get_id(xml_id)
|
|
self.values[self.current_field] = value % xml_ids
|
|
|
|
self.current_field = None
|
|
return self
|
|
|
|
elif name == "record":
|
|
if self.xml_id in self.xml_ids and not self.update:
|
|
raise Exception('Duplicate id: "%s".' % (self.xml_id,))
|
|
self.mh.import_record(
|
|
self.model.__name__, self.values, self.xml_id)
|
|
self.xml_ids.append(self.xml_id)
|
|
return None
|
|
else:
|
|
raise Exception("Unexpected closing tag '%s'" % (name,))
|
|
|
|
def current_state(self):
|
|
return "In tag record: model %s with id %s." % \
|
|
(self.model and self.model.__name__ or "?", self.xml_id)
|
|
|
|
|
|
# Custom exception:
|
|
class Unhandled_field(Exception):
|
|
"""
|
|
Raised when a field type is not supported by the update mechanism.
|
|
"""
|
|
pass
|
|
|
|
|
|
class Fs2bdAccessor:
|
|
"""
|
|
Used in TrytondXmlHandler.
|
|
Provide some helper function to ease cache access and management.
|
|
"""
|
|
|
|
def __init__(self, ModelData, pool):
|
|
self.fs2db = {}
|
|
self.fetched_modules = []
|
|
self.ModelData = ModelData
|
|
self.browserecord = {}
|
|
self.pool = pool
|
|
|
|
def get(self, module, fs_id):
|
|
if module not in self.fetched_modules:
|
|
self.fetch_new_module(module)
|
|
return self.fs2db[module].get(fs_id, None)
|
|
|
|
def get_browserecord(self, module, model_name, db_id):
|
|
if module not in self.fetched_modules:
|
|
self.fetch_new_module(module)
|
|
if model_name in self.browserecord[module] \
|
|
and db_id in self.browserecord[module][model_name]:
|
|
return self.browserecord[module][model_name][db_id]
|
|
return None
|
|
|
|
def set(self, module, fs_id, values):
|
|
"""
|
|
Whe call the prefetch function here to. Like that whe are sure
|
|
not to erase data when get is called.
|
|
"""
|
|
if module not in self.fetched_modules:
|
|
self.fetch_new_module(module)
|
|
if fs_id not in self.fs2db[module]:
|
|
self.fs2db[module][fs_id] = {}
|
|
fs2db_val = self.fs2db[module][fs_id]
|
|
for key, val in values.items():
|
|
fs2db_val[key] = val
|
|
|
|
def reset_browsercord(self, module, model_name, ids=None):
|
|
if module not in self.fetched_modules:
|
|
return
|
|
self.browserecord[module].setdefault(model_name, {})
|
|
Model = self.pool.get(model_name)
|
|
if not ids:
|
|
ids = self.browserecord[module][model_name].keys()
|
|
models = Model.browse(ids)
|
|
for model in models:
|
|
if model.id in self.browserecord[module][model_name]:
|
|
for cache in Transaction().cursor.cache.values():
|
|
for cache in (cache, cache.get('_language_cache',
|
|
{}).values()):
|
|
if (model_name in cache
|
|
and model.id in cache[model_name]):
|
|
cache[model_name][model.id] = {}
|
|
self.browserecord[module][model_name][model.id] = model
|
|
|
|
def fetch_new_module(self, module):
|
|
self.fs2db[module] = {}
|
|
module_data_ids = self.ModelData.search([
|
|
('module', '=', module),
|
|
], order=[('db_id', 'ASC')])
|
|
|
|
record_ids = {}
|
|
for rec in self.ModelData.browse(module_data_ids):
|
|
self.fs2db[rec.module][rec.fs_id] = {
|
|
"db_id": rec.db_id, "model": rec.model,
|
|
"id": rec.id, "values": rec.values
|
|
}
|
|
record_ids.setdefault(rec.model, [])
|
|
record_ids[rec.model].append(rec.db_id)
|
|
|
|
self.browserecord[module] = {}
|
|
for model_name in record_ids.keys():
|
|
try:
|
|
Model = self.pool.get(model_name)
|
|
except KeyError:
|
|
continue
|
|
self.browserecord[module][model_name] = {}
|
|
for sub_record_ids in grouped_slice(record_ids[model_name]):
|
|
with Transaction().set_context(active_test=False):
|
|
records = Model.search([
|
|
('id', 'in', list(sub_record_ids)),
|
|
], order=[('id', 'ASC')])
|
|
with Transaction().set_context(language='en_US'):
|
|
models = Model.browse(map(int, records))
|
|
for model in models:
|
|
self.browserecord[module][model_name][model.id] = model
|
|
self.fetched_modules.append(module)
|
|
|
|
|
|
class TrytondXmlHandler(sax.handler.ContentHandler):
|
|
|
|
def __init__(self, pool, module, module_state):
|
|
"Register known taghandlers, and managed tags."
|
|
sax.handler.ContentHandler.__init__(self)
|
|
|
|
self.pool = pool
|
|
self.module = module
|
|
self.ModelData = pool.get('ir.model.data')
|
|
self.fs2db = Fs2bdAccessor(self.ModelData, pool)
|
|
self.to_delete = self.populate_to_delete()
|
|
self.noupdate = None
|
|
self.module_state = module_state
|
|
self.grouped = None
|
|
self.grouped_creations = defaultdict(dict)
|
|
self.grouped_write = defaultdict(list)
|
|
self.grouped_model_data = []
|
|
self.skip_data = False
|
|
Module = pool.get('ir.module')
|
|
self.installed_modules = [m.name for m in Module.search([
|
|
('state', 'in', ['installed', 'to upgrade']),
|
|
])]
|
|
|
|
# Tag handlders are used to delegate the processing
|
|
self.taghandlerlist = {
|
|
'record': RecordTagHandler(self),
|
|
'menuitem': MenuitemTagHandler(self),
|
|
}
|
|
self.taghandler = None
|
|
|
|
# Managed tags are handled by the current class
|
|
self.managedtags = ["data", "tryton"]
|
|
|
|
# Connect to the sax api:
|
|
self.sax_parser = sax.make_parser()
|
|
# Tell the parser we are not interested in XML namespaces
|
|
self.sax_parser.setFeature(sax.handler.feature_namespaces, 0)
|
|
self.sax_parser.setContentHandler(self)
|
|
|
|
def parse_xmlstream(self, stream):
|
|
"""
|
|
Take a byte stream has input and parse the xml content.
|
|
"""
|
|
|
|
source = sax.InputSource()
|
|
source.setByteStream(stream)
|
|
|
|
try:
|
|
self.sax_parser.parse(source)
|
|
except Exception:
|
|
logger.error(
|
|
"Error while parsing xml file:\n" + self.current_state(),
|
|
exc_info=True)
|
|
raise
|
|
return self.to_delete
|
|
|
|
def startElement(self, name, attributes):
|
|
"""Rebind the current handler if necessary and call
|
|
startElement on it"""
|
|
|
|
if not self.taghandler:
|
|
|
|
if name in self.taghandlerlist:
|
|
self.taghandler = self.taghandlerlist[name]
|
|
self.taghandler.startElement(name, attributes)
|
|
|
|
elif name == "data":
|
|
self.noupdate = bool(int(attributes.get("noupdate", '0')))
|
|
self.grouped = bool(int(attributes.get('grouped', 0)))
|
|
if self.pool.test and \
|
|
bool(int(attributes.get("skiptest", '0'))):
|
|
self.skip_data = True
|
|
else:
|
|
self.skip_data = False
|
|
depends = attributes.get('depends', '').split(',')
|
|
depends = [m.strip() for m in depends if m]
|
|
if depends:
|
|
if not all((m in self.installed_modules for m in depends)):
|
|
self.skip_data = True
|
|
|
|
elif name == "tryton":
|
|
pass
|
|
|
|
else:
|
|
logger.info("Tag %s not supported", (name,))
|
|
return
|
|
elif not self.skip_data:
|
|
self.taghandler.startElement(name, attributes)
|
|
|
|
def characters(self, data):
|
|
if self.taghandler:
|
|
self.taghandler.characters(data)
|
|
|
|
def endElement(self, name):
|
|
|
|
if name == 'data' and self.grouped:
|
|
for model, values in self.grouped_creations.iteritems():
|
|
self.create_records(model, values.values(), values.keys())
|
|
self.grouped_creations.clear()
|
|
for key, actions in self.grouped_write.iteritems():
|
|
module, model = key
|
|
self.write_records(module, model, *actions)
|
|
self.grouped_write.clear()
|
|
if name == 'data' and self.grouped_model_data:
|
|
self.ModelData.write(*self.grouped_model_data)
|
|
del self.grouped_model_data[:]
|
|
|
|
# Closing tag found, if we are in a delegation the handler
|
|
# know what to do:
|
|
if self.taghandler and not self.skip_data:
|
|
self.taghandler = self.taghandler.endElement(name)
|
|
if self.taghandler == self.taghandlerlist.get(name):
|
|
self.taghandler = None
|
|
|
|
def current_state(self):
|
|
if self.taghandler:
|
|
return self.taghandler.current_state()
|
|
else:
|
|
return ''
|
|
|
|
def get_id(self, xml_id):
|
|
|
|
if '.' in xml_id:
|
|
module, xml_id = xml_id.split('.')
|
|
else:
|
|
module = self.module
|
|
|
|
if self.fs2db.get(module, xml_id) is None:
|
|
raise Exception("Reference to %s not found"
|
|
% ".".join([module, xml_id]))
|
|
return self.fs2db.get(module, xml_id)["db_id"]
|
|
|
|
@staticmethod
|
|
def _clean_value(key, record):
|
|
"""
|
|
Take a field name, a browse_record, and a reference to the
|
|
corresponding object. Return a raw value has it must look on the
|
|
db.
|
|
"""
|
|
Model = record.__class__
|
|
# search the field type in the object or in a parent
|
|
field_type = Model._fields[key]._type
|
|
|
|
# handle the value regarding to the type
|
|
if field_type == 'many2one':
|
|
return getattr(record, key).id if getattr(record, key) else None
|
|
elif field_type == 'reference':
|
|
if not getattr(record, key):
|
|
return None
|
|
return str(getattr(record, key))
|
|
elif field_type in ['one2many', 'many2many']:
|
|
raise Unhandled_field("Unhandled field %s" % key)
|
|
else:
|
|
return getattr(record, key)
|
|
|
|
def populate_to_delete(self):
|
|
"""Create a list of all the records that whe should met in the update
|
|
process. The records that are not encountered are deleted from the
|
|
database in post_import."""
|
|
|
|
# Fetch the data in id descending order to avoid depedendcy
|
|
# problem when the corresponding recordds will be deleted:
|
|
module_data = self.ModelData.search([
|
|
('module', '=', self.module),
|
|
], order=[('id', 'DESC')])
|
|
return set(rec.fs_id for rec in module_data)
|
|
|
|
def import_record(self, model, values, fs_id):
|
|
module = self.module
|
|
|
|
if not fs_id:
|
|
raise Exception('import_record : Argument fs_id is mandatory')
|
|
|
|
if '.' in fs_id:
|
|
assert len(fs_id.split('.')) == 2, ('"%s" contains too many dots. '
|
|
'file system ids should contain ot most one dot ! '
|
|
'These are used to refer to other modules data, '
|
|
'as in module.reference_id' % (fs_id))
|
|
|
|
module, fs_id = fs_id.split('.')
|
|
if not self.fs2db.get(module, fs_id):
|
|
raise Exception('Reference to %s.%s not found'
|
|
% (module, fs_id))
|
|
|
|
Model = self.pool.get(model)
|
|
|
|
if self.fs2db.get(module, fs_id):
|
|
|
|
# Remove this record from the to_delete list. This means that
|
|
# the corresponding record have been found.
|
|
if module == self.module and fs_id in self.to_delete:
|
|
self.to_delete.remove(fs_id)
|
|
|
|
if self.noupdate and self.module_state != 'to install':
|
|
return
|
|
|
|
# this record is already in the db:
|
|
# XXX maybe use only one call to get()
|
|
db_id, db_model, mdata_id, old_values = [
|
|
self.fs2db.get(module, fs_id)[x]
|
|
for x in ["db_id", "model", "id", "values"]]
|
|
|
|
if not old_values:
|
|
old_values = {}
|
|
else:
|
|
old_values = self.ModelData.load_values(old_values)
|
|
|
|
for key in old_values:
|
|
if isinstance(old_values[key], str):
|
|
# Fix for migration to unicode
|
|
old_values[key] = old_values[key].decode('utf-8')
|
|
|
|
if model != db_model:
|
|
raise Exception("This record try to overwrite "
|
|
"data with the wrong model: %s (module: %s)"
|
|
% (fs_id, module))
|
|
|
|
record = self.fs2db.get_browserecord(module, Model.__name__, db_id)
|
|
# Re-create record if it was deleted
|
|
if not record:
|
|
with Transaction().set_context(
|
|
module=module, language='en_US'):
|
|
record, = Model.create([values])
|
|
|
|
# reset_browsercord
|
|
self.fs2db.reset_browsercord(
|
|
module, Model.__name__, [record.id])
|
|
|
|
record = self.fs2db.get_browserecord(
|
|
module, Model.__name__, record.id)
|
|
|
|
data = self.ModelData.search([
|
|
('fs_id', '=', fs_id),
|
|
('module', '=', module),
|
|
('model', '=', Model.__name__),
|
|
], limit=1)
|
|
self.ModelData.write(data, {
|
|
'db_id': record.id,
|
|
})
|
|
self.fs2db.get(module, fs_id)["db_id"] = record.id
|
|
|
|
to_update = {}
|
|
for key in values:
|
|
|
|
db_field = self._clean_value(key, record)
|
|
|
|
# if the fs value is the same has in the db, whe ignore it
|
|
val = values[key]
|
|
if isinstance(values[key], str):
|
|
# Fix for migration to unicode
|
|
val = values[key].decode('utf-8')
|
|
if db_field == val:
|
|
continue
|
|
|
|
# we cannot update a field if it was changed by a user...
|
|
if key not in old_values:
|
|
expected_value = Model._defaults.get(key,
|
|
lambda *a: None)()
|
|
else:
|
|
expected_value = old_values[key]
|
|
|
|
# Migration from 2.0: Reference field change value
|
|
field_type = Model._fields[key]._type
|
|
if field_type == 'reference':
|
|
if (expected_value and expected_value.endswith(',0')
|
|
and not db_field):
|
|
db_field = expected_value
|
|
|
|
# ... and we consider that there is an update if the
|
|
# expected value differs from the actual value, _and_
|
|
# if they are not false in a boolean context (ie None,
|
|
# False, {} or [])
|
|
if db_field != expected_value and (db_field or expected_value):
|
|
logger.warning(
|
|
"Field %s of %s@%s not updated (id: %s), because "
|
|
"it has changed since the last update",
|
|
key, record.id, model, fs_id)
|
|
continue
|
|
|
|
# so, the field in the fs and in the db are different,
|
|
# and no user changed the value in the db:
|
|
to_update[key] = values[key]
|
|
|
|
if self.grouped:
|
|
self.grouped_write[(module, model)].extend(
|
|
(record, to_update, old_values, fs_id, mdata_id))
|
|
else:
|
|
self.write_records(module, model, record, to_update,
|
|
old_values, fs_id, mdata_id)
|
|
self.grouped_model_data.extend(([self.ModelData(mdata_id)], {
|
|
'fs_values': self.ModelData.dump_values(values),
|
|
}))
|
|
else:
|
|
if self.grouped:
|
|
self.grouped_creations[model][fs_id] = values
|
|
else:
|
|
self.create_records(model, [values], [fs_id])
|
|
|
|
def create_records(self, model, vlist, fs_ids):
|
|
Model = self.pool.get(model)
|
|
|
|
with Transaction().set_context(module=self.module, language='en_US'):
|
|
records = Model.create(vlist)
|
|
|
|
mdata_values = []
|
|
for record, values, fs_id in izip(records, vlist, fs_ids):
|
|
for key in values:
|
|
values[key] = self._clean_value(key, record)
|
|
|
|
mdata_values.append({
|
|
'fs_id': fs_id,
|
|
'model': model,
|
|
'module': self.module,
|
|
'db_id': record.id,
|
|
'values': self.ModelData.dump_values(values),
|
|
'fs_values': self.ModelData.dump_values(values),
|
|
'noupdate': self.noupdate,
|
|
})
|
|
|
|
models_data = self.ModelData.create(mdata_values)
|
|
|
|
for record, values, fs_id, mdata in izip(
|
|
records, vlist, fs_ids, models_data):
|
|
self.fs2db.set(self.module, fs_id, {
|
|
'db_id': record.id,
|
|
'model': model,
|
|
'id': mdata.id,
|
|
'values': self.ModelData.dump_values(values),
|
|
})
|
|
self.fs2db.reset_browsercord(self.module, model,
|
|
[r.id for r in records])
|
|
|
|
def write_records(self, module, model,
|
|
record, values, old_values, fs_id, mdata_id, *args):
|
|
args = (record, values, old_values, fs_id, mdata_id) + args
|
|
Model = self.pool.get(model)
|
|
|
|
actions = iter(args)
|
|
to_update = []
|
|
for record, values, _, _, _ in zip(*((actions,) * 5)):
|
|
if values:
|
|
to_update += [[record], values]
|
|
# if there is values to update:
|
|
if to_update:
|
|
# write the values in the db:
|
|
with Transaction().set_context(
|
|
module=module, language='en_US'):
|
|
Model.write(*to_update)
|
|
self.fs2db.reset_browsercord(
|
|
module, Model.__name__, sum(to_update[::2], []))
|
|
|
|
actions = iter(to_update)
|
|
for records, values in zip(actions, actions):
|
|
record, = records
|
|
# re-read it: this ensure that we store the real value
|
|
# in the model_data table:
|
|
record = self.fs2db.get_browserecord(
|
|
module, Model.__name__, record.id)
|
|
if not record:
|
|
record = Model(record.id)
|
|
for key in values:
|
|
values[key] = self._clean_value(key, record)
|
|
|
|
actions = iter(args)
|
|
for record, values, old_values, fs_id, mdata_id in zip(
|
|
*((actions,) * 5)):
|
|
temp_values = old_values.copy()
|
|
temp_values.update(values)
|
|
values = temp_values
|
|
|
|
if values != old_values:
|
|
self.grouped_model_data.extend(([self.ModelData(mdata_id)], {
|
|
'fs_id': fs_id,
|
|
'model': model,
|
|
'module': module,
|
|
'db_id': record.id,
|
|
'values': self.ModelData.dump_values(values),
|
|
}))
|
|
|
|
# reset_browsercord to keep cache memory low
|
|
self.fs2db.reset_browsercord(module, Model.__name__, args[::5])
|
|
|
|
|
|
def post_import(pool, module, to_delete):
|
|
"""
|
|
Remove the records that are given in to_delete.
|
|
"""
|
|
cursor = Transaction().cursor
|
|
mdata_delete = []
|
|
ModelData = pool.get("ir.model.data")
|
|
|
|
with Transaction().set_context(active_test=False):
|
|
mdata = ModelData.search([
|
|
('fs_id', 'in', to_delete),
|
|
('module', '=', module),
|
|
], order=[('id', 'DESC')])
|
|
|
|
for mrec in mdata:
|
|
model, db_id, fs_id = mrec.model, mrec.db_id, mrec.fs_id
|
|
|
|
logger.info('Deleting %s@%s from %s.%s', db_id, model, module, fs_id)
|
|
try:
|
|
# Deletion of the record
|
|
try:
|
|
Model = pool.get(model)
|
|
except KeyError:
|
|
Model = None
|
|
if Model:
|
|
Model.delete([Model(db_id)])
|
|
mdata_delete.append(mrec)
|
|
else:
|
|
logger.warning(
|
|
'Could not delete id %d of model %s because model no '
|
|
'longer exists.', db_id, model)
|
|
cursor.commit()
|
|
except Exception:
|
|
cursor.rollback()
|
|
logger.error(
|
|
'Could not delete id: %d of model %s\n'
|
|
'There should be some relation '
|
|
'that points to this resource\n'
|
|
'You should manually fix this '
|
|
'and restart --update=module\n',
|
|
db_id, model, exc_info=True)
|
|
if 'active' in Model._fields:
|
|
try:
|
|
Model.write([Model(db_id)], {
|
|
'active': False,
|
|
})
|
|
except Exception:
|
|
cursor.rollback()
|
|
logger.error(
|
|
'Could not inactivate id: %d of model %s\n',
|
|
db_id, model, exc_info=True)
|
|
|
|
# Clean model_data:
|
|
if mdata_delete:
|
|
ModelData.delete(mdata_delete)
|
|
cursor.commit()
|
|
|
|
return True
|