Romain Derie
7aa2136938
web_editor dirty elements are saved by calling the ir.ui.view `save()` method.
As this method is called through call_kw _rpc on the ir.ui.view model, self
is binded to the view which has the `id` sent in the request.
In some cases, when editing a field for example, the id sent is the id of the
field's record (eg: product.template for price field).
In that case, the view binded on self will be the view with the id of the
field's record being edited.
If there is no ir.ui.view with the same ID as the field's record, self won't
exists.
This misbehavior resulted in no error luckily since we only use self to call
ir.ui.view methods without ever using self properties.
Since multi-website 47b00c5d53 overrided the `save()` method and used self.key
it was crashing when the self record did not exists.
This commit will fix that by doing the multi-website check only when it is a
view and not a field that is being edited. (We know that if xpath is set)
opw-1904637
Step to reproduce:
- Go to a product on ecommerce, eg product.template 13013
- Edit the product price field, the oe-id attribut is 13013
- Delete the ir.ui.view that has the same ID than the product (13013)
- Save -> It will crash since self is binded to "ir.ui.view(13013,)" but it
does not exists and we try to access key
closes odoo/odoo#28469
268 lines
9.9 KiB
Python
268 lines
9.9 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
import copy
|
|
import logging
|
|
from lxml import etree, html
|
|
|
|
from odoo.exceptions import AccessError
|
|
from odoo import api, fields, models
|
|
from odoo.tools import pycompat
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
|
|
class IrUiView(models.Model):
|
|
_inherit = 'ir.ui.view'
|
|
|
|
@api.multi
|
|
def render(self, values=None, engine='ir.qweb', minimal_qcontext=False):
|
|
if values and values.get('editable'):
|
|
try:
|
|
self.check_access_rights('write')
|
|
self.check_access_rule('write')
|
|
except AccessError:
|
|
values['editable'] = False
|
|
|
|
return super(IrUiView, self).render(values=values, engine=engine, minimal_qcontext=minimal_qcontext)
|
|
|
|
#------------------------------------------------------
|
|
# Save from html
|
|
#------------------------------------------------------
|
|
|
|
@api.model
|
|
def extract_embedded_fields(self, arch):
|
|
return arch.xpath('//*[@data-oe-model != "ir.ui.view"]')
|
|
|
|
@api.model
|
|
def extract_oe_structures(self, arch):
|
|
return arch.xpath('//*[hasclass("oe_structure")][contains(@id, "oe_structure")]')
|
|
|
|
@api.model
|
|
def get_default_lang_code(self):
|
|
return False
|
|
|
|
@api.model
|
|
def save_embedded_field(self, el):
|
|
Model = self.env[el.get('data-oe-model')]
|
|
field = el.get('data-oe-field')
|
|
|
|
model = 'ir.qweb.field.' + el.get('data-oe-type')
|
|
converter = self.env[model] if model in self.env else self.env['ir.qweb.field']
|
|
value = converter.from_html(Model, Model._fields[field], el)
|
|
|
|
if value is not None:
|
|
# TODO: batch writes?
|
|
if not self.env.context.get('lang') and self.get_default_lang_code():
|
|
Model.browse(int(el.get('data-oe-id'))).with_context(lang=self.get_default_lang_code()).write({field: value})
|
|
else:
|
|
Model.browse(int(el.get('data-oe-id'))).write({field: value})
|
|
|
|
@api.multi
|
|
def save_oe_structure(self, el):
|
|
self.ensure_one()
|
|
|
|
if el.get('id') in self.key:
|
|
# Do not inherit if the oe_structure already has its own inheriting view
|
|
return False
|
|
|
|
arch = etree.Element('data')
|
|
xpath = etree.Element('xpath', expr="//*[hasclass('oe_structure')][@id='{}']".format(el.get('id')), position="replace")
|
|
arch.append(xpath)
|
|
structure = etree.Element(el.tag, attrib=el.attrib)
|
|
xpath.append(structure)
|
|
for child in el.iterchildren(tag=etree.Element):
|
|
structure.append(copy.deepcopy(child))
|
|
|
|
vals = {
|
|
'inherit_id': self.id,
|
|
'name': '%s (%s)' % (self.name, el.get('id')),
|
|
'arch': self._pretty_arch(arch),
|
|
'key': '%s_%s' % (self.key, el.get('id')),
|
|
'type': 'qweb',
|
|
}
|
|
vals.update(self._save_oe_structure_hook())
|
|
self.create(vals)
|
|
|
|
return True
|
|
|
|
@api.model
|
|
def _save_oe_structure_hook(self):
|
|
return {}
|
|
|
|
@api.model
|
|
def _pretty_arch(self, arch):
|
|
# remove_blank_string does not seem to work on HTMLParser, and
|
|
# pretty-printing with lxml more or less requires stripping
|
|
# whitespace: http://lxml.de/FAQ.html#why-doesn-t-the-pretty-print-option-reformat-my-xml-output
|
|
# so serialize to XML, parse as XML (remove whitespace) then serialize
|
|
# as XML (pretty print)
|
|
arch_no_whitespace = etree.fromstring(
|
|
etree.tostring(arch, encoding='utf-8'),
|
|
parser=etree.XMLParser(encoding='utf-8', remove_blank_text=True))
|
|
return etree.tostring(
|
|
arch_no_whitespace, encoding='unicode', pretty_print=True)
|
|
|
|
@api.model
|
|
def _are_archs_equal(self, arch1, arch2):
|
|
# Note that comparing the strings would not be ok as attributes order
|
|
# must not be relevant
|
|
if arch1.tag != arch2.tag:
|
|
return False
|
|
if arch1.text != arch2.text:
|
|
return False
|
|
if arch1.tail != arch2.tail:
|
|
return False
|
|
if arch1.attrib != arch2.attrib:
|
|
return False
|
|
if len(arch1) != len(arch2):
|
|
return False
|
|
return all(self._are_archs_equal(arch1, arch2) for arch1, arch2 in pycompat.izip(arch1, arch2))
|
|
|
|
@api.multi
|
|
def replace_arch_section(self, section_xpath, replacement, replace_tail=False):
|
|
# the root of the arch section shouldn't actually be replaced as it's
|
|
# not really editable itself, only the content truly is editable.
|
|
self.ensure_one()
|
|
arch = etree.fromstring(self.arch.encode('utf-8'))
|
|
# => get the replacement root
|
|
if not section_xpath:
|
|
root = arch
|
|
else:
|
|
# ensure there's only one match
|
|
[root] = arch.xpath(section_xpath)
|
|
|
|
root.text = replacement.text
|
|
# Note: after a standard edition, the tail *must not* be replaced
|
|
if replace_tail:
|
|
root.tail = replacement.tail
|
|
# replace all children
|
|
del root[:]
|
|
for child in replacement:
|
|
root.append(copy.deepcopy(child))
|
|
|
|
return arch
|
|
|
|
@api.model
|
|
def to_field_ref(self, el):
|
|
# filter out meta-information inserted in the document
|
|
attributes = {k: v for k, v in el.attrib.items()
|
|
if not k.startswith('data-oe-')}
|
|
attributes['t-field'] = el.get('data-oe-expression')
|
|
|
|
out = html.html_parser.makeelement(el.tag, attrib=attributes)
|
|
out.tail = el.tail
|
|
return out
|
|
|
|
@api.model
|
|
def to_empty_oe_structure(self, el):
|
|
out = html.html_parser.makeelement(el.tag, attrib=el.attrib)
|
|
out.tail = el.tail
|
|
return out
|
|
|
|
@api.multi
|
|
def save(self, value, xpath=None):
|
|
""" Update a view section. The view section may embed fields to write
|
|
|
|
Note that `self` record might not exist when saving an embed field
|
|
|
|
:param str xpath: valid xpath to the tag to replace
|
|
"""
|
|
self.ensure_one()
|
|
|
|
arch_section = html.fromstring(
|
|
value, parser=html.HTMLParser(encoding='utf-8'))
|
|
|
|
if xpath is None:
|
|
# value is an embedded field on its own, not a view section
|
|
self.save_embedded_field(arch_section)
|
|
return
|
|
|
|
for el in self.extract_embedded_fields(arch_section):
|
|
self.save_embedded_field(el)
|
|
|
|
# transform embedded field back to t-field
|
|
el.getparent().replace(el, self.to_field_ref(el))
|
|
|
|
for el in self.extract_oe_structures(arch_section):
|
|
if self.save_oe_structure(el):
|
|
# empty oe_structure in parent view
|
|
empty = self.to_empty_oe_structure(el)
|
|
if el == arch_section:
|
|
arch_section = empty
|
|
else:
|
|
el.getparent().replace(el, empty)
|
|
|
|
new_arch = self.replace_arch_section(xpath, arch_section)
|
|
old_arch = etree.fromstring(self.arch.encode('utf-8'))
|
|
if not self._are_archs_equal(old_arch, new_arch):
|
|
self.sudo().model_data_id.write({'noupdate': True}) # TODO check if we remove this
|
|
self.write({'arch': self._pretty_arch(new_arch)})
|
|
|
|
@api.model
|
|
def _view_obj(self, view_id):
|
|
if isinstance(view_id, pycompat.string_types):
|
|
return self.search([('key', '=', view_id)]) or self.env.ref(view_id)
|
|
elif isinstance(view_id, pycompat.integer_types):
|
|
return self.browse(view_id)
|
|
# assume it's already a view object (WTF?)
|
|
return view_id
|
|
|
|
# Returns all views (called and inherited) related to a view
|
|
# Used by translation mechanism, SEO and optional templates
|
|
|
|
@api.model
|
|
def _views_get(self, view_id, options=True, bundles=False, root=True):
|
|
""" For a given view ``view_id``, should return:
|
|
* the view itself
|
|
* all views inheriting from it, enabled or not
|
|
- but not the optional children of a non-enabled child
|
|
* all views called from it (via t-call)
|
|
:returns recordset of ir.ui.view
|
|
"""
|
|
try:
|
|
view = self._view_obj(view_id)
|
|
except ValueError:
|
|
_logger.warning("Could not find view object with view_id '%s'", view_id)
|
|
return []
|
|
|
|
while root and view.inherit_id:
|
|
view = view.inherit_id
|
|
|
|
views_to_return = view
|
|
|
|
node = etree.fromstring(view.arch)
|
|
xpath = "//t[@t-call]"
|
|
if bundles:
|
|
xpath += "| //t[@t-call-assets]"
|
|
for child in node.xpath(xpath):
|
|
try:
|
|
called_view = self._view_obj(child.get('t-call', child.get('t-call-assets')))
|
|
except ValueError:
|
|
continue
|
|
if called_view not in views_to_return:
|
|
views_to_return += self._views_get(called_view, options=options, bundles=bundles)
|
|
|
|
extensions = view.inherit_children_ids
|
|
if not options:
|
|
# only active children
|
|
extensions = view.inherit_children_ids.filtered(lambda view: view.active)
|
|
|
|
# Keep options in a deterministic order regardless of their applicability
|
|
for extension in extensions.sorted(key=lambda v: v.id):
|
|
# only return optional grandchildren if this child is enabled
|
|
for ext_view in self._views_get(extension, options=extension.active, root=False):
|
|
if ext_view not in views_to_return:
|
|
views_to_return += ext_view
|
|
return views_to_return
|
|
|
|
@api.model
|
|
def get_related_views(self, key, bundles=False):
|
|
""" Get inherit view's informations of the template ``key``.
|
|
returns templates info (which can be active or not)
|
|
``bundles=True`` returns also the asset bundles
|
|
"""
|
|
user_groups = set(self.env.user.groups_id)
|
|
views = self.with_context(active_test=False)._views_get(key, bundles=bundles)
|
|
return views.filtered(lambda v: not v.groups_id or len(user_groups.intersection(v.groups_id)))
|