diff options
Diffstat (limited to 'addons/web_editor/models/ir_ui_view.py')
| -rw-r--r-- | addons/web_editor/models/ir_ui_view.py | 382 |
1 files changed, 382 insertions, 0 deletions
diff --git a/addons/web_editor/models/ir_ui_view.py b/addons/web_editor/models/ir_ui_view.py new file mode 100644 index 00000000..884e1b5a --- /dev/null +++ b/addons/web_editor/models/ir_ui_view.py @@ -0,0 +1,382 @@ +# -*- coding: utf-8 -*- +# Part of Odoo. See LICENSE file for full copyright and licensing details. + +import copy +import logging +import uuid +from lxml import etree, html + +from odoo.exceptions import AccessError +from odoo import api, models + +_logger = logging.getLogger(__name__) + +EDITING_ATTRIBUTES = ['data-oe-model', 'data-oe-id', 'data-oe-field', 'data-oe-xpath', 'data-note-id'] + + +class IrUiView(models.Model): + _inherit = 'ir.ui.view' + + 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) + + @api.model + def read_template(self, xml_id): + """ This method is deprecated + """ + if xml_id == 'web_editor.colorpicker' and self.env.user.has_group('base.group_user'): + # TODO this should be handled another way but was required as a + # stable fix in 14.0. The views are now private by default: they + # can be read thanks to read_template provided they declare a group + # that the user has and that the user has read access rights. + # + # For the case 'read_template web_editor.colorpicker', it works for + # website editor users as the view has the base.group_user group + # *and they have access rights thanks to publisher/designer groups*. + # For mass mailing users, no such group exists though so they simply + # do not have the rights to read that template anymore. Seems safer + # to force it for this template only while waiting for a better + # access rights refactoring. + # + # Note: using 'render_public_asset' which allows to bypass rights if + # the user has the group the view requires was also a solution. + # However, that would turn the 'read' into a 'render', which is + # a less stable change. + self = self.sudo() + return super().read_template(xml_id) + + #------------------------------------------------------ + # 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}) + + 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) + attributes = {k: v for k, v in el.attrib.items() if k not in EDITING_ATTRIBUTES} + structure = etree.Element(el.tag, attrib=attributes) + structure.text = el.text + 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', + 'mode': 'extension', + } + vals.update(self._save_oe_structure_hook()) + self.env['ir.ui.view'].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 zip(arch1, arch2)) + + 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 + + # We need to replace some attrib for styles changes on the root element + for attribute in ('style', 'class'): + if attribute in replacement.attrib: + root.attrib[attribute] = replacement.attrib[attribute] + + # 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.model + def _set_noupdate(self): + self.sudo().mapped('model_data_id').write({'noupdate': True}) + + 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._set_noupdate() + self.write({'arch': self._pretty_arch(new_arch)}) + + @api.model + def _view_get_inherited_children(self, view): + return view.inherit_children_ids + + @api.model + def _view_obj(self, view_id): + if isinstance(view_id, str): + return self.search([('key', '=', view_id)], limit=1) or self.env.ref(view_id) + elif isinstance(view_id, int): + return self.browse(view_id) + # It can already be a view object when called by '_views_get()' that is calling '_view_obj' + # for it's inherit_children_ids, passing them directly as object record. + 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, get_children=True, bundles=False, root=True, visited=None): + """ 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 self.env['ir.ui.view'] + + if visited is None: + visited = [] + 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 and called_view not in views_to_return and called_view.id not in visited: + views_to_return += self._views_get(called_view, get_children=get_children, bundles=bundles, visited=visited + views_to_return.ids) + + if not get_children: + return views_to_return + + extensions = self._view_get_inherited_children(view) + + # Keep children 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 + if extension.id not in visited: + for ext_view in self._views_get(extension, get_children=extension.active, root=False, visited=visited + views_to_return.ids): + 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) + View = self.with_context(active_test=False, lang=None) + views = View._views_get(key, bundles=bundles) + return views.filtered(lambda v: not v.groups_id or len(user_groups.intersection(v.groups_id))) + + # -------------------------------------------------------------------------- + # Snippet saving + # -------------------------------------------------------------------------- + + @api.model + def _get_snippet_addition_view_key(self, template_key, key): + return '%s.%s' % (template_key, key) + + @api.model + def _snippet_save_view_values_hook(self): + return {} + + @api.model + def save_snippet(self, name, arch, template_key, snippet_key, thumbnail_url): + """ + Saves a new snippet arch so that it appears with the given name when + using the given snippets template. + + :param name: the name of the snippet to save + :param arch: the html structure of the snippet to save + :param template_key: the key of the view regrouping all snippets in + which the snippet to save is meant to appear + :param snippet_key: the key (without module part) to identify + the snippet from which the snippet to save originates + :param thumbnail_url: the url of the thumbnail to use when displaying + the snippet to save + """ + app_name = template_key.split('.')[0] + snippet_key = '%s_%s' % (snippet_key, uuid.uuid4().hex) + full_snippet_key = '%s.%s' % (app_name, snippet_key) + + # html to xml to add '/' at the end of self closing tags like br, ... + xml_arch = etree.tostring(html.fromstring(arch), encoding='utf-8') + new_snippet_view_values = { + 'name': name, + 'key': full_snippet_key, + 'type': 'qweb', + 'arch': xml_arch, + } + new_snippet_view_values.update(self._snippet_save_view_values_hook()) + self.create(new_snippet_view_values) + + custom_section = self.search([('key', '=', template_key)]) + snippet_addition_view_values = { + 'name': name + ' Block', + 'key': self._get_snippet_addition_view_key(template_key, snippet_key), + 'inherit_id': custom_section.id, + 'type': 'qweb', + 'arch': """ + <data inherit_id="%s"> + <xpath expr="//div[@id='snippet_custom']" position="attributes"> + <attribute name="class" remove="d-none" separator=" "/> + </xpath> + <xpath expr="//div[@id='snippet_custom_body']" position="inside"> + <t t-snippet="%s" t-thumbnail="%s"/> + </xpath> + </data> + """ % (template_key, full_snippet_key, thumbnail_url), + } + snippet_addition_view_values.update(self._snippet_save_view_values_hook()) + self.create(snippet_addition_view_values) + + @api.model + def delete_snippet(self, view_id, template_key): + snippet_view = self.browse(view_id) + key = snippet_view.key.split('.')[1] + custom_key = self._get_snippet_addition_view_key(template_key, key) + snippet_addition_view = self.search([('key', '=', custom_key)]) + (snippet_addition_view | snippet_view).unlink() |