summaryrefslogtreecommitdiff
path: root/addons/web_editor/models
diff options
context:
space:
mode:
Diffstat (limited to 'addons/web_editor/models')
-rw-r--r--addons/web_editor/models/__init__.py12
-rw-r--r--addons/web_editor/models/assets.py278
-rw-r--r--addons/web_editor/models/ir_attachment.py62
-rw-r--r--addons/web_editor/models/ir_http.py26
-rw-r--r--addons/web_editor/models/ir_qweb.py618
-rw-r--r--addons/web_editor/models/ir_translation.py46
-rw-r--r--addons/web_editor/models/ir_ui_view.py382
-rw-r--r--addons/web_editor/models/test_models.py37
8 files changed, 1461 insertions, 0 deletions
diff --git a/addons/web_editor/models/__init__.py b/addons/web_editor/models/__init__.py
new file mode 100644
index 00000000..e9a790f7
--- /dev/null
+++ b/addons/web_editor/models/__init__.py
@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from . import ir_attachment
+from . import ir_qweb
+from . import ir_ui_view
+from . import ir_http
+from . import ir_translation
+
+from . import assets
+
+from . import test_models
diff --git a/addons/web_editor/models/assets.py b/addons/web_editor/models/assets.py
new file mode 100644
index 00000000..425c5376
--- /dev/null
+++ b/addons/web_editor/models/assets.py
@@ -0,0 +1,278 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+import base64
+import os
+import re
+import uuid
+
+from lxml import etree
+
+from odoo import models
+from odoo.modules.module import get_resource_path, get_module_path
+
+_match_asset_file_url_regex = re.compile("^/(\w+)/(.+?)(\.custom\.(.+))?\.(\w+)$")
+
+
+class Assets(models.AbstractModel):
+ _name = 'web_editor.assets'
+ _description = 'Assets Utils'
+
+ def get_all_custom_attachments(self, urls):
+ """
+ Fetch all the ir.attachment records related to given URLs.
+
+ Params:
+ urls (str[]): list of urls
+
+ Returns:
+ ir.attachment(): attachment records related to the given URLs.
+ """
+ return self._get_custom_attachment(urls, op='in')
+
+ def get_asset_content(self, url, url_info=None, custom_attachments=None):
+ """
+ Fetch the content of an asset (scss / js) file. That content is either
+ the one of the related file on the disk or the one of the corresponding
+ custom ir.attachment record.
+
+ Params:
+ url (str): the URL of the asset (scss / js) file/ir.attachment
+
+ url_info (dict, optional):
+ the related url info (see get_asset_info) (allows to optimize
+ some code which already have the info and do not want this
+ function to re-get it)
+
+ custom_attachments (ir.attachment(), optional):
+ the related custom ir.attachment records the function might need
+ to search into (allows to optimize some code which already have
+ that info and do not want this function to re-get it)
+
+ Returns:
+ utf-8 encoded content of the asset (scss / js)
+ """
+ if url_info is None:
+ url_info = self.get_asset_info(url)
+
+ if url_info["customized"]:
+ # If the file is already customized, the content is found in the
+ # corresponding attachment
+ attachment = None
+ if custom_attachments is None:
+ attachment = self._get_custom_attachment(url)
+ else:
+ attachment = custom_attachments.filtered(lambda r: r.url == url)
+ return attachment and base64.b64decode(attachment.datas) or False
+
+ # If the file is not yet customized, the content is found by reading
+ # the local scss file
+ module = url_info["module"]
+ module_path = get_module_path(module)
+ module_resource_path = get_resource_path(module, url_info["resource_path"])
+ if module_path and module_resource_path:
+ module_path = os.path.join(os.path.normpath(module_path), '') # join ensures the path ends with '/'
+ module_resource_path = os.path.normpath(module_resource_path)
+ if module_resource_path.startswith(module_path):
+ with open(module_resource_path, "rb") as f:
+ return f.read()
+
+ def get_asset_info(self, url):
+ """
+ Return information about an asset (scss / js) file/ir.attachment just by
+ looking at its URL.
+
+ Params:
+ url (str): the url of the asset (scss / js) file/ir.attachment
+
+ Returns:
+ dict:
+ module (str): the original asset's related app
+
+ resource_path (str):
+ the relative path to the original asset from the related app
+
+ customized (bool): whether the asset is a customized one or not
+
+ bundle (str):
+ the name of the bundle the asset customizes (False if this
+ is not a customized asset)
+ """
+ m = _match_asset_file_url_regex.match(url)
+ if not m:
+ return False
+ return {
+ 'module': m.group(1),
+ 'resource_path': "%s.%s" % (m.group(2), m.group(5)),
+ 'customized': bool(m.group(3)),
+ 'bundle': m.group(4) or False
+ }
+
+ def make_custom_asset_file_url(self, url, bundle_xmlid):
+ """
+ Return the customized version of an asset URL, that is the URL the asset
+ would have if it was customized.
+
+ Params:
+ url (str): the original asset's url
+ bundle_xmlid (str): the name of the bundle the asset would customize
+
+ Returns:
+ str: the URL the given asset would have if it was customized in the
+ given bundle
+ """
+ parts = url.rsplit(".", 1)
+ return "%s.custom.%s.%s" % (parts[0], bundle_xmlid, parts[1])
+
+ def reset_asset(self, url, bundle_xmlid):
+ """
+ Delete the potential customizations made to a given (original) asset.
+
+ Params:
+ url (str): the URL of the original asset (scss / js) file
+
+ bundle_xmlid (str):
+ the name of the bundle in which the customizations to delete
+ were made
+ """
+ custom_url = self.make_custom_asset_file_url(url, bundle_xmlid)
+
+ # Simply delete the attachement which contains the modified scss/js file
+ # and the xpath view which links it
+ self._get_custom_attachment(custom_url).unlink()
+ self._get_custom_view(custom_url).unlink()
+
+ def save_asset(self, url, bundle_xmlid, content, file_type):
+ """
+ Customize the content of a given asset (scss / js).
+
+ Params:
+ url (src):
+ the URL of the original asset to customize (whether or not the
+ asset was already customized)
+
+ bundle_xmlid (src):
+ the name of the bundle in which the customizations will take
+ effect
+
+ content (src): the new content of the asset (scss / js)
+
+ file_type (src):
+ either 'scss' or 'js' according to the file being customized
+ """
+ custom_url = self.make_custom_asset_file_url(url, bundle_xmlid)
+ datas = base64.b64encode((content or "\n").encode("utf-8"))
+
+ # Check if the file to save had already been modified
+ custom_attachment = self._get_custom_attachment(custom_url)
+ if custom_attachment:
+ # If it was already modified, simply override the corresponding
+ # attachment content
+ custom_attachment.write({"datas": datas})
+ else:
+ # If not, create a new attachment to copy the original scss/js file
+ # content, with its modifications
+ new_attach = {
+ 'name': url.split("/")[-1],
+ 'type': "binary",
+ 'mimetype': (file_type == 'js' and 'text/javascript' or 'text/scss'),
+ 'datas': datas,
+ 'url': custom_url,
+ }
+ new_attach.update(self._save_asset_attachment_hook())
+ self.env["ir.attachment"].create(new_attach)
+
+ # Create a view to extend the template which adds the original file
+ # to link the new modified version instead
+ file_type_info = {
+ 'tag': 'link' if file_type == 'scss' else 'script',
+ 'attribute': 'href' if file_type == 'scss' else 'src',
+ }
+
+ def views_linking_url(view):
+ """
+ Returns whether the view arch has some html tag linked to
+ the url. (note: searching for the URL string is not enough as it
+ could appear in a comment or an xpath expression.)
+ """
+ tree = etree.XML(view.arch)
+ return bool(tree.xpath("//%%(tag)s[@%%(attribute)s='%(url)s']" % {
+ 'url': url,
+ } % file_type_info))
+
+ IrUiView = self.env["ir.ui.view"]
+ view_to_xpath = IrUiView.get_related_views(bundle_xmlid, bundles=True).filtered(views_linking_url)
+ new_view = {
+ 'name': custom_url,
+ 'key': 'web_editor.%s_%s' % (file_type, str(uuid.uuid4())[:6]),
+ 'mode': "extension",
+ 'inherit_id': view_to_xpath.id,
+ 'arch': """
+ <data inherit_id="%(inherit_xml_id)s" name="%(name)s">
+ <xpath expr="//%%(tag)s[@%%(attribute)s='%(url_to_replace)s']" position="attributes">
+ <attribute name="%%(attribute)s">%(new_url)s</attribute>
+ </xpath>
+ </data>
+ """ % {
+ 'inherit_xml_id': view_to_xpath.xml_id,
+ 'name': custom_url,
+ 'url_to_replace': url,
+ 'new_url': custom_url,
+ } % file_type_info
+ }
+ new_view.update(self._save_asset_view_hook())
+ IrUiView.create(new_view)
+
+ self.env["ir.qweb"].clear_caches()
+
+ def _get_custom_attachment(self, custom_url, op='='):
+ """
+ Fetch the ir.attachment record related to the given customized asset.
+
+ Params:
+ custom_url (str): the URL of the customized asset
+ op (str, default: '='): the operator to use to search the records
+
+ Returns:
+ ir.attachment()
+ """
+ assert op in ('in', '='), 'Invalid operator'
+ return self.env["ir.attachment"].search([("url", op, custom_url)])
+
+ def _get_custom_view(self, custom_url, op='='):
+ """
+ Fetch the ir.ui.view record related to the given customized asset (the
+ inheriting view which replace the original asset by the customized one).
+
+ Params:
+ custom_url (str): the URL of the customized asset
+ op (str, default: '='): the operator to use to search the records
+
+ Returns:
+ ir.ui.view()
+ """
+ assert op in ('='), 'Invalid operator'
+ return self.env["ir.ui.view"].search([("name", op, custom_url)])
+
+ def _save_asset_attachment_hook(self):
+ """
+ Returns the additional values to use to write the DB on customized
+ attachment creation.
+
+ Returns:
+ dict
+ """
+ return {}
+
+ def _save_asset_view_hook(self):
+ """
+ Returns the additional values to use to write the DB on customized
+ asset's related view creation.
+
+ Returns:
+ dict
+ """
+ return {}
+
+ def _get_public_asset_xmlids(self):
+ return ["web_editor.compiled_assets_wysiwyg"]
diff --git a/addons/web_editor/models/ir_attachment.py b/addons/web_editor/models/ir_attachment.py
new file mode 100644
index 00000000..791f9194
--- /dev/null
+++ b/addons/web_editor/models/ir_attachment.py
@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from werkzeug.urls import url_quote
+
+from odoo import api, models, fields, tools
+
+SUPPORTED_IMAGE_MIMETYPES = ['image/gif', 'image/jpe', 'image/jpeg', 'image/jpg', 'image/gif', 'image/png', 'image/svg+xml']
+
+class IrAttachment(models.Model):
+
+ _inherit = "ir.attachment"
+
+ local_url = fields.Char("Attachment URL", compute='_compute_local_url')
+ image_src = fields.Char(compute='_compute_image_src')
+ image_width = fields.Integer(compute='_compute_image_size')
+ image_height = fields.Integer(compute='_compute_image_size')
+ original_id = fields.Many2one('ir.attachment', string="Original (unoptimized, unresized) attachment", index=True)
+
+ def _compute_local_url(self):
+ for attachment in self:
+ if attachment.url:
+ attachment.local_url = attachment.url
+ else:
+ attachment.local_url = '/web/image/%s?unique=%s' % (attachment.id, attachment.checksum)
+
+ @api.depends('mimetype', 'url', 'name')
+ def _compute_image_src(self):
+ for attachment in self:
+ # Only add a src for supported images
+ if attachment.mimetype not in SUPPORTED_IMAGE_MIMETYPES:
+ attachment.image_src = False
+ continue
+
+ if attachment.type == 'url':
+ attachment.image_src = attachment.url
+ else:
+ # Adding unique in URLs for cache-control
+ unique = attachment.checksum[:8]
+ if attachment.url:
+ # For attachments-by-url, unique is used as a cachebuster. They
+ # currently do not leverage max-age headers.
+ attachment.image_src = '%s?unique=%s' % (attachment.url, unique)
+ else:
+ name = url_quote(attachment.name)
+ attachment.image_src = '/web/image/%s-%s/%s' % (attachment.id, unique, name)
+
+ @api.depends('datas')
+ def _compute_image_size(self):
+ for attachment in self:
+ try:
+ image = tools.base64_to_image(attachment.datas)
+ attachment.image_width = image.width
+ attachment.image_height = image.height
+ except Exception:
+ attachment.image_width = 0
+ attachment.image_height = 0
+
+ def _get_media_info(self):
+ """Return a dict with the values that we need on the media dialog."""
+ self.ensure_one()
+ return self._read_format(['id', 'name', 'description', 'mimetype', 'checksum', 'url', 'type', 'res_id', 'res_model', 'public', 'access_token', 'image_src', 'image_width', 'image_height', 'original_id'])[0]
diff --git a/addons/web_editor/models/ir_http.py b/addons/web_editor/models/ir_http.py
new file mode 100644
index 00000000..d9690f5e
--- /dev/null
+++ b/addons/web_editor/models/ir_http.py
@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import models
+from odoo.http import request
+
+
+class IrHttp(models.AbstractModel):
+ _inherit = 'ir.http'
+
+ @classmethod
+ def _dispatch(cls):
+ context = dict(request.context)
+ if 'editable' in request.httprequest.args and 'editable' not in context:
+ context['editable'] = True
+ if 'edit_translations' in request.httprequest.args and 'edit_translations' not in context:
+ context['edit_translations'] = True
+ if context.get('edit_translations') and 'translatable' not in context:
+ context['translatable'] = True
+ request.context = context
+ return super(IrHttp, cls)._dispatch()
+
+ @classmethod
+ def _get_translation_frontend_modules_name(cls):
+ mods = super(IrHttp, cls)._get_translation_frontend_modules_name()
+ return mods + ['web_editor']
diff --git a/addons/web_editor/models/ir_qweb.py b/addons/web_editor/models/ir_qweb.py
new file mode 100644
index 00000000..05b274c9
--- /dev/null
+++ b/addons/web_editor/models/ir_qweb.py
@@ -0,0 +1,618 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+"""
+Web_editor-context rendering needs to add some metadata to rendered and allow to edit fields,
+as well as render a few fields differently.
+
+Also, adds methods to convert values back to Odoo models.
+"""
+
+import ast
+import babel
+import base64
+import io
+import itertools
+import json
+import logging
+import os
+import re
+import hashlib
+from datetime import datetime
+
+import pytz
+import requests
+from datetime import datetime
+from lxml import etree, html
+from PIL import Image as I
+from werkzeug import urls
+
+import odoo.modules
+
+from odoo import api, models, fields
+from odoo.tools import ustr, posix_to_ldml, pycompat
+from odoo.tools import html_escape as escape
+from odoo.tools.misc import get_lang, babel_locale_parse
+from odoo.addons.base.models import ir_qweb
+
+REMOTE_CONNECTION_TIMEOUT = 2.5
+
+logger = logging.getLogger(__name__)
+
+
+class QWeb(models.AbstractModel):
+ """ QWeb object for rendering editor stuff
+ """
+ _inherit = 'ir.qweb'
+
+ # compile directives
+
+ def _compile_node(self, el, options):
+ snippet_key = options.get('snippet-key')
+ if snippet_key == options['template'] \
+ or options.get('snippet-sub-call-key') == options['template']:
+ # Get the path of element to only consider the first node of the
+ # snippet template content (ignoring all ancestors t elements which
+ # are not t-call ones)
+ nb_real_elements_in_hierarchy = 0
+ node = el
+ while node is not None and nb_real_elements_in_hierarchy < 2:
+ if node.tag != 't' or 't-call' in node.attrib:
+ nb_real_elements_in_hierarchy += 1
+ node = node.getparent()
+ if nb_real_elements_in_hierarchy == 1:
+ # The first node might be a call to a sub template
+ sub_call = el.get('t-call')
+ if sub_call:
+ el.set('t-call-options', f"{{'snippet-key': '{snippet_key}', 'snippet-sub-call-key': '{sub_call}'}}")
+ # If it already has a data-snippet it is a saved snippet.
+ # Do not override it.
+ elif 'data-snippet' not in el.attrib:
+ el.attrib['data-snippet'] = snippet_key.split('.', 1)[-1]
+
+ return super()._compile_node(el, options)
+
+ def _compile_directive_snippet(self, el, options):
+ key = el.attrib.pop('t-snippet')
+ el.set('t-call', key)
+ el.set('t-call-options', "{'snippet-key': '" + key + "'}")
+ View = self.env['ir.ui.view'].sudo()
+ view_id = View.get_view_id(key)
+ name = View.browse(view_id).name
+ thumbnail = el.attrib.pop('t-thumbnail', "oe-thumbnail")
+ div = u'<div name="%s" data-oe-type="snippet" data-oe-thumbnail="%s" data-oe-snippet-id="%s" data-oe-keywords="%s">' % (
+ escape(pycompat.to_text(name)),
+ escape(pycompat.to_text(thumbnail)),
+ escape(pycompat.to_text(view_id)),
+ escape(pycompat.to_text(el.findtext('keywords')))
+ )
+ return [self._append(ast.Str(div))] + self._compile_node(el, options) + [self._append(ast.Str(u'</div>'))]
+
+ def _compile_directive_snippet_call(self, el, options):
+ key = el.attrib.pop('t-snippet-call')
+ el.set('t-call', key)
+ el.set('t-call-options', "{'snippet-key': '" + key + "'}")
+ return self._compile_node(el, options)
+
+ def _compile_directive_install(self, el, options):
+ if self.user_has_groups('base.group_system'):
+ module = self.env['ir.module.module'].search([('name', '=', el.attrib.get('t-install'))])
+ if not module or module.state == 'installed':
+ return []
+ name = el.attrib.get('string') or 'Snippet'
+ thumbnail = el.attrib.pop('t-thumbnail', 'oe-thumbnail')
+ div = u'<div name="%s" data-oe-type="snippet" data-module-id="%s" data-oe-thumbnail="%s"><section/></div>' % (
+ escape(pycompat.to_text(name)),
+ module.id,
+ escape(pycompat.to_text(thumbnail))
+ )
+ return [self._append(ast.Str(div))]
+ else:
+ return []
+
+ def _compile_directive_tag(self, el, options):
+ if el.get('t-placeholder'):
+ el.set('t-att-placeholder', el.attrib.pop('t-placeholder'))
+ return super(QWeb, self)._compile_directive_tag(el, options)
+
+ # order and ignore
+
+ def _directives_eval_order(self):
+ directives = super(QWeb, self)._directives_eval_order()
+ directives.insert(directives.index('call'), 'snippet')
+ directives.insert(directives.index('call'), 'snippet-call')
+ directives.insert(directives.index('call'), 'install')
+ return directives
+
+
+#------------------------------------------------------
+# QWeb fields
+#------------------------------------------------------
+
+
+class Field(models.AbstractModel):
+ _name = 'ir.qweb.field'
+ _description = 'Qweb Field'
+ _inherit = 'ir.qweb.field'
+
+ @api.model
+ def attributes(self, record, field_name, options, values):
+ attrs = super(Field, self).attributes(record, field_name, options, values)
+ field = record._fields[field_name]
+
+ placeholder = options.get('placeholder') or getattr(field, 'placeholder', None)
+ if placeholder:
+ attrs['placeholder'] = placeholder
+
+ if options['translate'] and field.type in ('char', 'text'):
+ name = "%s,%s" % (record._name, field_name)
+ domain = [('name', '=', name), ('res_id', '=', record.id), ('type', '=', 'model'), ('lang', '=', options.get('lang'))]
+ translation = record.env['ir.translation'].search(domain, limit=1)
+ attrs['data-oe-translation-state'] = translation and translation.state or 'to_translate'
+
+ return attrs
+
+ def value_from_string(self, value):
+ return value
+
+ @api.model
+ def from_html(self, model, field, element):
+ return self.value_from_string(element.text_content().strip())
+
+
+class Integer(models.AbstractModel):
+ _name = 'ir.qweb.field.integer'
+ _description = 'Qweb Field Integer'
+ _inherit = 'ir.qweb.field.integer'
+
+ value_from_string = int
+
+
+class Float(models.AbstractModel):
+ _name = 'ir.qweb.field.float'
+ _description = 'Qweb Field Float'
+ _inherit = 'ir.qweb.field.float'
+
+ @api.model
+ def from_html(self, model, field, element):
+ lang = self.user_lang()
+ value = element.text_content().strip()
+ return float(value.replace(lang.thousands_sep, '')
+ .replace(lang.decimal_point, '.'))
+
+
+class ManyToOne(models.AbstractModel):
+ _name = 'ir.qweb.field.many2one'
+ _description = 'Qweb Field Many to One'
+ _inherit = 'ir.qweb.field.many2one'
+
+ @api.model
+ def attributes(self, record, field_name, options, values):
+ attrs = super(ManyToOne, self).attributes(record, field_name, options, values)
+ if options.get('inherit_branding'):
+ many2one = getattr(record, field_name)
+ if many2one:
+ attrs['data-oe-many2one-id'] = many2one.id
+ attrs['data-oe-many2one-model'] = many2one._name
+ return attrs
+
+ @api.model
+ def from_html(self, model, field, element):
+ Model = self.env[element.get('data-oe-model')]
+ id = int(element.get('data-oe-id'))
+ M2O = self.env[field.comodel_name]
+ field_name = element.get('data-oe-field')
+ many2one_id = int(element.get('data-oe-many2one-id'))
+ record = many2one_id and M2O.browse(many2one_id)
+ if record and record.exists():
+ # save the new id of the many2one
+ Model.browse(id).write({field_name: many2one_id})
+
+ # not necessary, but might as well be explicit about it
+ return None
+
+
+class Contact(models.AbstractModel):
+ _name = 'ir.qweb.field.contact'
+ _description = 'Qweb Field Contact'
+ _inherit = 'ir.qweb.field.contact'
+
+ @api.model
+ def attributes(self, record, field_name, options, values):
+ attrs = super(Contact, self).attributes(record, field_name, options, values)
+ if options.get('inherit_branding'):
+ options.pop('template_options') # remove options not specific to this widget
+ attrs['data-oe-contact-options'] = json.dumps(options)
+ return attrs
+
+ # helper to call the rendering of contact field
+ @api.model
+ def get_record_to_html(self, ids, options=None):
+ return self.value_to_html(self.env['res.partner'].search([('id', '=', ids[0])]), options=options)
+
+
+class Date(models.AbstractModel):
+ _name = 'ir.qweb.field.date'
+ _description = 'Qweb Field Date'
+ _inherit = 'ir.qweb.field.date'
+
+ @api.model
+ def attributes(self, record, field_name, options, values):
+ attrs = super(Date, self).attributes(record, field_name, options, values)
+ if options.get('inherit_branding'):
+ attrs['data-oe-original'] = record[field_name]
+
+ if record._fields[field_name].type == 'datetime':
+ attrs = self.env['ir.qweb.field.datetime'].attributes(record, field_name, options, values)
+ attrs['data-oe-type'] = 'datetime'
+ return attrs
+
+ lg = self.env['res.lang']._lang_get(self.env.user.lang) or get_lang(self.env)
+ locale = babel_locale_parse(lg.code)
+ babel_format = value_format = posix_to_ldml(lg.date_format, locale=locale)
+
+ if record[field_name]:
+ date = fields.Date.from_string(record[field_name])
+ value_format = pycompat.to_text(babel.dates.format_date(date, format=babel_format, locale=locale))
+
+ attrs['data-oe-original-with-format'] = value_format
+ return attrs
+
+ @api.model
+ def from_html(self, model, field, element):
+ value = element.text_content().strip()
+ if not value:
+ return False
+
+ lg = self.env['res.lang']._lang_get(self.env.user.lang) or get_lang(self.env)
+ date = datetime.strptime(value, lg.date_format)
+ return fields.Date.to_string(date)
+
+
+class DateTime(models.AbstractModel):
+ _name = 'ir.qweb.field.datetime'
+ _description = 'Qweb Field Datetime'
+ _inherit = 'ir.qweb.field.datetime'
+
+ @api.model
+ def attributes(self, record, field_name, options, values):
+ attrs = super(DateTime, self).attributes(record, field_name, options, values)
+
+ if options.get('inherit_branding'):
+ value = record[field_name]
+
+ lg = self.env['res.lang']._lang_get(self.env.user.lang) or get_lang(self.env)
+ locale = babel_locale_parse(lg.code)
+ babel_format = value_format = posix_to_ldml('%s %s' % (lg.date_format, lg.time_format), locale=locale)
+ tz = record.env.context.get('tz') or self.env.user.tz
+
+ if isinstance(value, str):
+ value = fields.Datetime.from_string(value)
+
+ if value:
+ # convert from UTC (server timezone) to user timezone
+ value = fields.Datetime.context_timestamp(self.with_context(tz=tz), timestamp=value)
+ value_format = pycompat.to_text(babel.dates.format_datetime(value, format=babel_format, locale=locale))
+ value = fields.Datetime.to_string(value)
+
+ attrs['data-oe-original'] = value
+ attrs['data-oe-original-with-format'] = value_format
+ attrs['data-oe-original-tz'] = tz
+ return attrs
+
+ @api.model
+ def from_html(self, model, field, element):
+ value = element.text_content().strip()
+ if not value:
+ return False
+
+ # parse from string to datetime
+ lg = self.env['res.lang']._lang_get(self.env.user.lang) or get_lang(self.env)
+ dt = datetime.strptime(value, '%s %s' % (lg.date_format, lg.time_format))
+
+ # convert back from user's timezone to UTC
+ tz_name = element.attrib.get('data-oe-original-tz') or self.env.context.get('tz') or self.env.user.tz
+ if tz_name:
+ try:
+ user_tz = pytz.timezone(tz_name)
+ utc = pytz.utc
+
+ dt = user_tz.localize(dt).astimezone(utc)
+ except Exception:
+ logger.warning(
+ "Failed to convert the value for a field of the model"
+ " %s back from the user's timezone (%s) to UTC",
+ model, tz_name,
+ exc_info=True)
+
+ # format back to string
+ return fields.Datetime.to_string(dt)
+
+
+class Text(models.AbstractModel):
+ _name = 'ir.qweb.field.text'
+ _description = 'Qweb Field Text'
+ _inherit = 'ir.qweb.field.text'
+
+ @api.model
+ def from_html(self, model, field, element):
+ return html_to_text(element)
+
+
+class Selection(models.AbstractModel):
+ _name = 'ir.qweb.field.selection'
+ _description = 'Qweb Field Selection'
+ _inherit = 'ir.qweb.field.selection'
+
+ @api.model
+ def from_html(self, model, field, element):
+ value = element.text_content().strip()
+ selection = field.get_description(self.env)['selection']
+ for k, v in selection:
+ if isinstance(v, str):
+ v = ustr(v)
+ if value == v:
+ return k
+
+ raise ValueError(u"No value found for label %s in selection %s" % (
+ value, selection))
+
+
+class HTML(models.AbstractModel):
+ _name = 'ir.qweb.field.html'
+ _description = 'Qweb Field HTML'
+ _inherit = 'ir.qweb.field.html'
+
+ @api.model
+ def from_html(self, model, field, element):
+ content = []
+ if element.text:
+ content.append(element.text)
+ content.extend(html.tostring(child, encoding='unicode')
+ for child in element.iterchildren(tag=etree.Element))
+ return '\n'.join(content)
+
+
+class Image(models.AbstractModel):
+ """
+ Widget options:
+
+ ``class``
+ set as attribute on the generated <img> tag
+ """
+ _name = 'ir.qweb.field.image'
+ _description = 'Qweb Field Image'
+ _inherit = 'ir.qweb.field.image'
+
+ local_url_re = re.compile(r'^/(?P<module>[^]]+)/static/(?P<rest>.+)$')
+
+ @api.model
+ def from_html(self, model, field, element):
+ if element.find('img') is None:
+ return False
+ url = element.find('img').get('src')
+
+ url_object = urls.url_parse(url)
+ if url_object.path.startswith('/web/image'):
+ fragments = url_object.path.split('/')
+ query = url_object.decode_query()
+ url_id = fragments[3].split('-')[0]
+ # ir.attachment image urls: /web/image/<id>[-<checksum>][/...]
+ if url_id.isdigit():
+ model = 'ir.attachment'
+ oid = url_id
+ field = 'datas'
+ # url of binary field on model: /web/image/<model>/<id>/<field>[/...]
+ else:
+ model = query.get('model', fragments[3])
+ oid = query.get('id', fragments[4])
+ field = query.get('field', fragments[5])
+ item = self.env[model].browse(int(oid))
+ return item[field]
+
+ if self.local_url_re.match(url_object.path):
+ return self.load_local_url(url)
+
+ return self.load_remote_url(url)
+
+ def load_local_url(self, url):
+ match = self.local_url_re.match(urls.url_parse(url).path)
+
+ rest = match.group('rest')
+ for sep in os.sep, os.altsep:
+ if sep and sep != '/':
+ rest.replace(sep, '/')
+
+ path = odoo.modules.get_module_resource(
+ match.group('module'), 'static', *(rest.split('/')))
+
+ if not path:
+ return None
+
+ try:
+ with open(path, 'rb') as f:
+ # force complete image load to ensure it's valid image data
+ image = I.open(f)
+ image.load()
+ f.seek(0)
+ return base64.b64encode(f.read())
+ except Exception:
+ logger.exception("Failed to load local image %r", url)
+ return None
+
+ def load_remote_url(self, url):
+ try:
+ # should probably remove remote URLs entirely:
+ # * in fields, downloading them without blowing up the server is a
+ # challenge
+ # * in views, may trigger mixed content warnings if HTTPS CMS
+ # linking to HTTP images
+ # implement drag & drop image upload to mitigate?
+
+ req = requests.get(url, timeout=REMOTE_CONNECTION_TIMEOUT)
+ # PIL needs a seekable file-like image so wrap result in IO buffer
+ image = I.open(io.BytesIO(req.content))
+ # force a complete load of the image data to validate it
+ image.load()
+ except Exception:
+ logger.exception("Failed to load remote image %r", url)
+ return None
+
+ # don't use original data in case weird stuff was smuggled in, with
+ # luck PIL will remove some of it?
+ out = io.BytesIO()
+ image.save(out, image.format)
+ return base64.b64encode(out.getvalue())
+
+
+class Monetary(models.AbstractModel):
+ _name = 'ir.qweb.field.monetary'
+ _inherit = 'ir.qweb.field.monetary'
+
+ @api.model
+ def from_html(self, model, field, element):
+ lang = self.user_lang()
+
+ value = element.find('span').text.strip()
+
+ return float(value.replace(lang.thousands_sep, '')
+ .replace(lang.decimal_point, '.'))
+
+
+class Duration(models.AbstractModel):
+ _name = 'ir.qweb.field.duration'
+ _description = 'Qweb Field Duration'
+ _inherit = 'ir.qweb.field.duration'
+
+ @api.model
+ def attributes(self, record, field_name, options, values):
+ attrs = super(Duration, self).attributes(record, field_name, options, values)
+ if options.get('inherit_branding'):
+ attrs['data-oe-original'] = record[field_name]
+ return attrs
+
+ @api.model
+ def from_html(self, model, field, element):
+ value = element.text_content().strip()
+
+ # non-localized value
+ return float(value)
+
+
+class RelativeDatetime(models.AbstractModel):
+ _name = 'ir.qweb.field.relative'
+ _description = 'Qweb Field Relative'
+ _inherit = 'ir.qweb.field.relative'
+
+ # get formatting from ir.qweb.field.relative but edition/save from datetime
+
+
+class QwebView(models.AbstractModel):
+ _name = 'ir.qweb.field.qweb'
+ _description = 'Qweb Field qweb'
+ _inherit = 'ir.qweb.field.qweb'
+
+
+def html_to_text(element):
+ """ Converts HTML content with HTML-specified line breaks (br, p, div, ...)
+ in roughly equivalent textual content.
+
+ Used to replace and fixup the roundtripping of text and m2o: when using
+ libxml 2.8.0 (but not 2.9.1) and parsing HTML with lxml.html.fromstring
+ whitespace text nodes (text nodes composed *solely* of whitespace) are
+ stripped out with no recourse, and fundamentally relying on newlines
+ being in the text (e.g. inserted during user edition) is probably poor form
+ anyway.
+
+ -> this utility function collapses whitespace sequences and replaces
+ nodes by roughly corresponding linebreaks
+ * p are pre-and post-fixed by 2 newlines
+ * br are replaced by a single newline
+ * block-level elements not already mentioned are pre- and post-fixed by
+ a single newline
+
+ ought be somewhat similar (but much less high-tech) to aaronsw's html2text.
+ the latter produces full-blown markdown, our text -> html converter only
+ replaces newlines by <br> elements at this point so we're reverting that,
+ and a few more newline-ish elements in case the user tried to add
+ newlines/paragraphs into the text field
+
+ :param element: lxml.html content
+ :returns: corresponding pure-text output
+ """
+
+ # output is a list of str | int. Integers are padding requests (in minimum
+ # number of newlines). When multiple padding requests, fold them into the
+ # biggest one
+ output = []
+ _wrap(element, output)
+
+ # remove any leading or tailing whitespace, replace sequences of
+ # (whitespace)\n(whitespace) by a single newline, where (whitespace) is a
+ # non-newline whitespace in this case
+ return re.sub(
+ r'[ \t\r\f]*\n[ \t\r\f]*',
+ '\n',
+ ''.join(_realize_padding(output)).strip())
+
+_PADDED_BLOCK = set('p h1 h2 h3 h4 h5 h6'.split())
+# https://developer.mozilla.org/en-US/docs/HTML/Block-level_elements minus p
+_MISC_BLOCK = set((
+ 'address article aside audio blockquote canvas dd dl div figcaption figure'
+ ' footer form header hgroup hr ol output pre section tfoot ul video'
+).split())
+
+
+def _collapse_whitespace(text):
+ """ Collapses sequences of whitespace characters in ``text`` to a single
+ space
+ """
+ return re.sub('\s+', ' ', text)
+
+
+def _realize_padding(it):
+ """ Fold and convert padding requests: integers in the output sequence are
+ requests for at least n newlines of padding. Runs thereof can be collapsed
+ into the largest requests and converted to newlines.
+ """
+ padding = 0
+ for item in it:
+ if isinstance(item, int):
+ padding = max(padding, item)
+ continue
+
+ if padding:
+ yield '\n' * padding
+ padding = 0
+
+ yield item
+ # leftover padding irrelevant as the output will be stripped
+
+
+def _wrap(element, output, wrapper=u''):
+ """ Recursively extracts text from ``element`` (via _element_to_text), and
+ wraps it all in ``wrapper``. Extracted text is added to ``output``
+
+ :type wrapper: basestring | int
+ """
+ output.append(wrapper)
+ if element.text:
+ output.append(_collapse_whitespace(element.text))
+ for child in element:
+ _element_to_text(child, output)
+ output.append(wrapper)
+
+
+def _element_to_text(e, output):
+ if e.tag == 'br':
+ output.append(u'\n')
+ elif e.tag in _PADDED_BLOCK:
+ _wrap(e, output, 2)
+ elif e.tag in _MISC_BLOCK:
+ _wrap(e, output, 1)
+ else:
+ # inline
+ _wrap(e, output)
+
+ if e.tail:
+ output.append(_collapse_whitespace(e.tail))
diff --git a/addons/web_editor/models/ir_translation.py b/addons/web_editor/models/ir_translation.py
new file mode 100644
index 00000000..0a0e34da
--- /dev/null
+++ b/addons/web_editor/models/ir_translation.py
@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from lxml import etree
+
+from odoo import models, api
+from odoo.tools.translate import encode, xml_translate, html_translate
+
+
+def edit_translation_mapping(data):
+ data = dict(data, model=data['name'].partition(',')[0], value=data['value'] or data['src'])
+ return '<span data-oe-model="%(model)s" data-oe-translation-id="%(id)s" data-oe-translation-state="%(state)s">%(value)s</span>' % data
+
+
+class IrTranslation(models.Model):
+ _inherit = 'ir.translation'
+
+ @api.model
+ def _get_terms_mapping(self, field, records):
+ if self._context.get('edit_translations'):
+ self.insert_missing(field, records)
+ return edit_translation_mapping
+ return super(IrTranslation, self)._get_terms_mapping(field, records)
+
+ def save_html(self, value):
+ """ Convert the HTML fragment ``value`` to XML if necessary, and write
+ it as the value of translation ``self``.
+ """
+ assert len(self) == 1 and self.type == 'model_terms'
+ mname, fname = self.name.split(',')
+ field = self.env[mname]._fields[fname]
+ if field.translate == xml_translate:
+ # wrap value inside a div and parse it as HTML
+ div = "<div>%s</div>" % encode(value)
+ root = etree.fromstring(div, etree.HTMLParser(encoding='utf-8'))
+ # root is html > body > div
+ # serialize div as XML and discard surrounding tags
+ value = etree.tostring(root[0][0], encoding='utf-8')[5:-6]
+ elif field.translate == html_translate:
+ # wrap value inside a div and parse it as HTML
+ div = "<div>%s</div>" % encode(value)
+ root = etree.fromstring(div, etree.HTMLParser(encoding='utf-8'))
+ # root is html > body > div
+ # serialize div as HTML and discard surrounding tags
+ value = etree.tostring(root[0][0], encoding='utf-8', method='html')[5:-6]
+ return self.write({'value': value})
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()
diff --git a/addons/web_editor/models/test_models.py b/addons/web_editor/models/test_models.py
new file mode 100644
index 00000000..282b703c
--- /dev/null
+++ b/addons/web_editor/models/test_models.py
@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import models, fields
+
+
+class ConverterTest(models.Model):
+ _name = 'web_editor.converter.test'
+ _description = 'Web Editor Converter Test'
+
+ # disable translation export for those brilliant field labels and values
+ _translate = False
+
+ char = fields.Char()
+ integer = fields.Integer()
+ float = fields.Float()
+ numeric = fields.Float(digits=(16, 2))
+ many2one = fields.Many2one('web_editor.converter.test.sub')
+ binary = fields.Binary(attachment=False)
+ date = fields.Date()
+ datetime = fields.Datetime()
+ selection_str = fields.Selection([
+ ('A', "Qu'il n'est pas arrivé à Toronto"),
+ ('B', "Qu'il était supposé arriver à Toronto"),
+ ('C', "Qu'est-ce qu'il fout ce maudit pancake, tabernacle ?"),
+ ('D', "La réponse D"),
+ ], string=u"Lorsqu'un pancake prend l'avion à destination de Toronto et "
+ u"qu'il fait une escale technique à St Claude, on dit:")
+ html = fields.Html()
+ text = fields.Text()
+
+
+class ConverterTestSub(models.Model):
+ _name = 'web_editor.converter.test.sub'
+ _description = 'Web Editor Converter Subtest'
+
+ name = fields.Char()
generated by cgit v1.2.3 (git 2.25.1) at 2026-04-18 00:30:44 +0000