mirror of
https://github.com/bringout/oca-ocb-web.git
synced 2026-04-20 07:52:04 +02:00
Initial commit: Web packages
This commit is contained in:
Ernad Husremovic
commit
cd458d4b85
791 changed files with 410049 additions and 0 deletions
|
|
@ -0,0 +1,13 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
from . import ir_attachment
|
||||
from . import ir_qweb_fields
|
||||
from . import ir_ui_view
|
||||
from . import ir_http
|
||||
from . import ir_websocket
|
||||
from . import models
|
||||
|
||||
from . import assets
|
||||
|
||||
from . import test_models
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
227
odoo-bringout-oca-ocb-web_editor/web_editor/models/assets.py
Normal file
227
odoo-bringout-oca-ocb-web_editor/web_editor/models/assets.py
Normal file
|
|
@ -0,0 +1,227 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
import base64
|
||||
import re
|
||||
|
||||
from odoo import api, models
|
||||
from odoo.tools import misc
|
||||
from odoo.addons.base.models.assetsbundle import EXTENSIONS
|
||||
|
||||
_match_asset_file_url_regex = re.compile(r"^/(\w+)/(.+?)(\.custom\.(.+))?\.(\w+)$")
|
||||
|
||||
|
||||
class Assets(models.AbstractModel):
|
||||
_name = 'web_editor.assets'
|
||||
_description = 'Assets Utils'
|
||||
|
||||
@api.model
|
||||
def reset_asset(self, url, bundle):
|
||||
"""
|
||||
Delete the potential customizations made to a given (original) asset.
|
||||
|
||||
Params:
|
||||
url (str): the URL of the original asset (scss / js) file
|
||||
|
||||
bundle (str):
|
||||
the name of the bundle in which the customizations to delete
|
||||
were made
|
||||
"""
|
||||
custom_url = self._make_custom_asset_url(url, bundle)
|
||||
|
||||
# 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_asset(custom_url).unlink()
|
||||
|
||||
@api.model
|
||||
def save_asset(self, url, bundle, 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 (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_url(url, bundle)
|
||||
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_hook())
|
||||
self.env["ir.attachment"].create(new_attach)
|
||||
|
||||
# Create an asset with the new attachment
|
||||
IrAsset = self.env['ir.asset']
|
||||
new_asset = {
|
||||
'path': custom_url,
|
||||
'target': url,
|
||||
'directive': 'replace',
|
||||
**self._save_asset_hook(),
|
||||
}
|
||||
target_asset = self._get_custom_asset(url)
|
||||
if target_asset:
|
||||
new_asset['name'] = target_asset.name + ' override'
|
||||
new_asset['bundle'] = target_asset.bundle
|
||||
new_asset['sequence'] = target_asset.sequence
|
||||
else:
|
||||
new_asset['name'] = '%s: replace %s' % (bundle, custom_url.split('/')[-1])
|
||||
new_asset['bundle'] = IrAsset._get_related_bundle(url, bundle)
|
||||
IrAsset.create(new_asset)
|
||||
|
||||
self.env["ir.qweb"].clear_caches()
|
||||
|
||||
@api.model
|
||||
def _get_content_from_url(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_data_from_url) (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_data_from_url(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 file
|
||||
with misc.file_open(url.strip('/'), 'rb', filter_ext=EXTENSIONS) as f:
|
||||
return f.read()
|
||||
|
||||
@api.model
|
||||
def _get_data_from_url(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
|
||||
}
|
||||
|
||||
@api.model
|
||||
def _make_custom_asset_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])
|
||||
|
||||
@api.model
|
||||
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)])
|
||||
|
||||
@api.model
|
||||
def _get_custom_asset(self, custom_url):
|
||||
"""
|
||||
Fetch the ir.asset 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
|
||||
|
||||
Returns:
|
||||
ir.asset()
|
||||
"""
|
||||
url = custom_url[1:] if custom_url.startswith(('/', '\\')) else custom_url
|
||||
return self.env['ir.asset'].search([('path', 'like', url)])
|
||||
|
||||
@api.model
|
||||
def _save_asset_hook(self):
|
||||
"""
|
||||
Returns the additional values to use to write the DB on customized
|
||||
attachment and asset creation.
|
||||
|
||||
Returns:
|
||||
dict
|
||||
"""
|
||||
return {}
|
||||
|
|
@ -0,0 +1,74 @@
|
|||
# -*- 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/png', 'image/svg+xml']
|
||||
SUPPORTED_IMAGE_EXTENSIONS = ['.gif', '.jpe', '.jpeg', '.jpg', '.png', '.svg']
|
||||
|
||||
|
||||
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")
|
||||
|
||||
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 not attachment.mimetype or attachment.mimetype.split(';')[0] 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.
|
||||
separator = '&' if '?' in attachment.url else '?'
|
||||
attachment.image_src = '%s%sunique=%s' % (attachment.url, separator, 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]
|
||||
|
||||
def _can_bypass_rights_on_media_dialog(self, **attachment_data):
|
||||
""" This method is meant to be overridden, for instance to allow to
|
||||
create image attachment despite the user not allowed to create
|
||||
attachment, eg:
|
||||
- Portal user uploading an image on the forum (bypass acl)
|
||||
- Non admin user uploading an unsplash image (bypass binary/url check)
|
||||
"""
|
||||
return False
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
from odoo import models
|
||||
from odoo.http import request
|
||||
|
||||
|
||||
CONTEXT_KEYS = ['editable', 'edit_translations', 'translatable']
|
||||
|
||||
|
||||
class IrHttp(models.AbstractModel):
|
||||
_inherit = 'ir.http'
|
||||
|
||||
@classmethod
|
||||
def _get_web_editor_context(cls):
|
||||
""" Check for ?editable and stuff in the query-string """
|
||||
return {
|
||||
key: True
|
||||
for key in CONTEXT_KEYS
|
||||
if key in request.httprequest.args and key not in request.env.context
|
||||
}
|
||||
|
||||
@classmethod
|
||||
def _pre_dispatch(cls, rule, args):
|
||||
super()._pre_dispatch(rule, args)
|
||||
ctx = cls._get_web_editor_context()
|
||||
request.update_context(**ctx)
|
||||
|
||||
@classmethod
|
||||
def _get_translation_frontend_modules_name(cls):
|
||||
mods = super(IrHttp, cls)._get_translation_frontend_modules_name()
|
||||
return mods + ['web_editor']
|
||||
|
|
@ -0,0 +1,665 @@
|
|||
# -*- 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 babel
|
||||
import base64
|
||||
import io
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
|
||||
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.exceptions import UserError, ValidationError
|
||||
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
|
||||
|
||||
REMOTE_CONNECTION_TIMEOUT = 2.5
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class IrQWeb(models.AbstractModel):
|
||||
""" IrQWeb object for rendering editor stuff
|
||||
"""
|
||||
_inherit = 'ir.qweb'
|
||||
|
||||
def _compile_node(self, el, compile_context, indent):
|
||||
snippet_key = compile_context.get('snippet-key')
|
||||
if snippet_key == compile_context['template'] \
|
||||
or compile_context.get('snippet-sub-call-key') == compile_context['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-options', f"{{'snippet-key': '{snippet_key}', 'snippet-sub-call-key': '{sub_call}'}}")
|
||||
# If it already has a data-snippet it is a saved or an inherited 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, compile_context, indent)
|
||||
|
||||
# compile directives
|
||||
|
||||
def _compile_directive_snippet(self, el, compile_context, indent):
|
||||
key = el.attrib.pop('t-snippet')
|
||||
el.set('t-call', key)
|
||||
snippet_lang = self._context.get('snippet_lang')
|
||||
if snippet_lang:
|
||||
el.set('t-lang', f"'{snippet_lang}'")
|
||||
|
||||
el.set('t-options', f"{{'snippet-key': {key!r}}}")
|
||||
view = self.env['ir.ui.view']._get(key).sudo()
|
||||
name = el.attrib.pop('string', view.name)
|
||||
thumbnail = el.attrib.pop('t-thumbnail', "oe-thumbnail")
|
||||
# Forbid sanitize contains the specific reason:
|
||||
# - "true": always forbid
|
||||
# - "form": forbid if forms are sanitized
|
||||
forbid_sanitize = el.attrib.pop('t-forbid-sanitize', None)
|
||||
div = '<div name="%s" data-oe-type="snippet" data-oe-thumbnail="%s" data-oe-snippet-id="%s" data-oe-keywords="%s" %s>' % (
|
||||
escape(pycompat.to_text(name)),
|
||||
escape(pycompat.to_text(thumbnail)),
|
||||
escape(pycompat.to_text(view.id)),
|
||||
escape(pycompat.to_text(el.findtext('keywords'))),
|
||||
f'data-oe-forbid-sanitize="{forbid_sanitize}"' if forbid_sanitize else '',
|
||||
)
|
||||
self._append_text(div, compile_context)
|
||||
code = self._compile_node(el, compile_context, indent)
|
||||
self._append_text('</div>', compile_context)
|
||||
return code
|
||||
|
||||
def _compile_directive_snippet_call(self, el, compile_context, indent):
|
||||
key = el.attrib.pop('t-snippet-call')
|
||||
el.set('t-call', key)
|
||||
el.set('t-options', f"{{'snippet-key': {key!r}}}")
|
||||
return self._compile_node(el, compile_context, indent)
|
||||
|
||||
def _compile_directive_install(self, el, compile_context, indent):
|
||||
key = el.attrib.pop('t-install')
|
||||
thumbnail = el.attrib.pop('t-thumbnail', 'oe-thumbnail')
|
||||
if self.user_has_groups('base.group_system'):
|
||||
module = self.env['ir.module.module'].search([('name', '=', key)])
|
||||
if not module or module.state == 'installed':
|
||||
return []
|
||||
name = el.attrib.get('string') or 'Snippet'
|
||||
div = '<div name="%s" data-oe-type="snippet" data-module-id="%s" data-module-display-name="%s" data-oe-thumbnail="%s"><section/></div>' % (
|
||||
escape(pycompat.to_text(name)),
|
||||
module.id,
|
||||
module.display_name,
|
||||
escape(pycompat.to_text(thumbnail))
|
||||
)
|
||||
self._append_text(div, compile_context)
|
||||
return []
|
||||
|
||||
def _compile_directive_placeholder(self, el, compile_context, indent):
|
||||
el.set('t-att-placeholder', el.attrib.pop('t-placeholder'))
|
||||
return []
|
||||
|
||||
# order and ignore
|
||||
|
||||
def _directives_eval_order(self):
|
||||
directives = super()._directives_eval_order()
|
||||
# Insert before "att" as those may rely on static attributes like
|
||||
# "string" and "att" clears all of those
|
||||
index = directives.index('att') - 1
|
||||
directives.insert(index, 'placeholder')
|
||||
directives.insert(index, 'snippet')
|
||||
directives.insert(index, 'snippet-call')
|
||||
directives.insert(index, 'install')
|
||||
return directives
|
||||
|
||||
def _get_template_cache_keys(self):
|
||||
return super()._get_template_cache_keys() + ['snippet_lang']
|
||||
|
||||
|
||||
#------------------------------------------------------
|
||||
# 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'):
|
||||
lang = record.env.lang or 'en_US'
|
||||
base_lang = record._get_base_lang()
|
||||
if lang == base_lang:
|
||||
attrs['data-oe-translation-state'] = 'translated'
|
||||
else:
|
||||
base_value = record.with_context(lang=base_lang)[field_name]
|
||||
value = record[field_name]
|
||||
attrs['data-oe-translation-state'] = 'translated' if base_value != value else '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'
|
||||
|
||||
@api.model
|
||||
def from_html(self, model, field, element):
|
||||
lang = self.user_lang()
|
||||
value = element.text_content().strip()
|
||||
return int(value.replace(lang.thousands_sep or '', ''))
|
||||
|
||||
|
||||
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 or '', '')
|
||||
.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 = 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'):
|
||||
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)
|
||||
try:
|
||||
datetime_format = f'{lg.date_format} {lg.time_format}'
|
||||
dt = datetime.strptime(value, datetime_format)
|
||||
except ValueError:
|
||||
raise ValidationError(_("The datetime %s does not match the format %s", value, datetime_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 attributes(self, record, field_name, options, values=None):
|
||||
attrs = super().attributes(record, field_name, options, values)
|
||||
if options.get('inherit_branding'):
|
||||
field = record._fields[field_name]
|
||||
if field.sanitize:
|
||||
if field.sanitize_overridable and not record.user_has_groups('base.group_sanitize_override'):
|
||||
try:
|
||||
field.convert_to_column(record[field_name], record)
|
||||
except UserError:
|
||||
# The field contains element(s) that would be removed if
|
||||
# sanitized. It means that someone who was part of a
|
||||
# group allowing to bypass the sanitation saved that
|
||||
# field previously. Mark the field as not editable.
|
||||
attrs['data-oe-sanitize-prevent-edition'] = 1
|
||||
if not (field.sanitize_overridable and record.user_has_groups('base.group_sanitize_override')):
|
||||
# Don't mark the field as 'sanitize' if the sanitize is
|
||||
# defined as overridable and the user has the right to do so
|
||||
attrs['data-oe-sanitize'] = 1 if field.sanitize_form else 'allow_form'
|
||||
|
||||
return attrs
|
||||
|
||||
@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.warning("Failed to load remote image %r", url, exc_info=True)
|
||||
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_content().strip()
|
||||
|
||||
return float(value.replace(lang.thousands_sep or '', '')
|
||||
.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(r'\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=''):
|
||||
""" 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('\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))
|
||||
523
odoo-bringout-oca-ocb-web_editor/web_editor/models/ir_ui_view.py
Normal file
523
odoo-bringout-oca-ocb-web_editor/web_editor/models/ir_ui_view.py
Normal file
|
|
@ -0,0 +1,523 @@
|
|||
# -*- 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 import api, models, _
|
||||
from odoo.osv import expression
|
||||
from odoo.exceptions import ValidationError
|
||||
from odoo.addons.base.models.ir_ui_view import MOVABLE_BRANDING
|
||||
|
||||
_logger = logging.getLogger(__name__)
|
||||
|
||||
EDITING_ATTRIBUTES = MOVABLE_BRANDING + [
|
||||
'data-oe-type',
|
||||
'data-oe-expression',
|
||||
'data-oe-translation-id',
|
||||
'data-note-id'
|
||||
]
|
||||
|
||||
|
||||
class IrUiView(models.Model):
|
||||
_inherit = 'ir.ui.view'
|
||||
|
||||
def _get_cleaned_non_editing_attributes(self, attributes):
|
||||
"""
|
||||
Returns a new mapping of attributes -> value without the parts that are
|
||||
not meant to be saved (branding, editing classes, ...). Note that
|
||||
classes are meant to be cleaned on the client side before saving as
|
||||
mostly linked to the related options (so we are not supposed to know
|
||||
which to remove here).
|
||||
|
||||
:param attributes: a mapping of attributes -> value
|
||||
:return: a new mapping of attributes -> value
|
||||
"""
|
||||
attributes = {k: v for k, v in attributes if k not in EDITING_ATTRIBUTES}
|
||||
if 'class' in attributes:
|
||||
classes = attributes['class'].split()
|
||||
attributes['class'] = ' '.join([c for c in classes if c != 'o_editable'])
|
||||
if attributes.get('contenteditable') == 'true':
|
||||
del attributes['contenteditable']
|
||||
return attributes
|
||||
|
||||
#------------------------------------------------------
|
||||
# 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']
|
||||
|
||||
try:
|
||||
value = converter.from_html(Model, Model._fields[field], el)
|
||||
if value is not None:
|
||||
# TODO: batch writes?
|
||||
record = Model.browse(int(el.get('data-oe-id')))
|
||||
if not self.env.context.get('lang') and self.get_default_lang_code():
|
||||
record.with_context(lang=self.get_default_lang_code()).write({field: value})
|
||||
else:
|
||||
record.write({field: value})
|
||||
|
||||
if callable(Model._fields[field].translate):
|
||||
self._copy_custom_snippet_translations(record, field)
|
||||
|
||||
except (ValueError, TypeError):
|
||||
raise ValidationError(_("Invalid field value for %s: %s", Model._fields[field].string, el.text_content().strip()))
|
||||
|
||||
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 = self._get_cleaned_non_editing_attributes(el.attrib.items())
|
||||
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())
|
||||
oe_structure_view = self.env['ir.ui.view'].create(vals)
|
||||
self._copy_custom_snippet_translations(oe_structure_view, 'arch_db')
|
||||
|
||||
return True
|
||||
|
||||
@api.model
|
||||
def _copy_custom_snippet_translations(self, record, html_field):
|
||||
""" Given a ``record`` and its HTML ``field``, detect any
|
||||
usage of a custom snippet and copy its translations.
|
||||
"""
|
||||
lang_value = record[html_field]
|
||||
if not lang_value:
|
||||
return
|
||||
|
||||
tree = html.fromstring(lang_value)
|
||||
for custom_snippet_el in tree.xpath('//*[hasclass("s_custom_snippet")]'):
|
||||
custom_snippet_name = custom_snippet_el.get('data-name')
|
||||
custom_snippet_view = self.search([('name', '=', custom_snippet_name)], limit=1)
|
||||
if custom_snippet_view:
|
||||
self._copy_field_terms_translations(custom_snippet_view, 'arch_db', record, html_field)
|
||||
|
||||
@api.model
|
||||
def _copy_field_terms_translations(self, record_from, name_field_from, record_to, name_field_to):
|
||||
""" Copy model terms translations from ``record_from.name_field_from``
|
||||
to ``record_to.name_field_to`` for all activated languages if the term
|
||||
in ``record_to.name_field_to`` is untranslated (the term matches the
|
||||
one in the current language).
|
||||
|
||||
For instance, copy the translations of a
|
||||
``product.template.html_description`` field to a ``ir.ui.view.arch_db``
|
||||
field.
|
||||
|
||||
The method takes care of read and write access of both records/fields.
|
||||
"""
|
||||
record_to.check_access_rights('write')
|
||||
record_to.check_access_rule('write')
|
||||
record_to.check_field_access_rights('write', [name_field_to])
|
||||
|
||||
# This will also implicitly check for `read` access rights
|
||||
if not record_from[name_field_from] or not record_to[name_field_to]:
|
||||
return
|
||||
|
||||
field_from = record_from._fields[name_field_from]
|
||||
field_to = record_to._fields[name_field_to]
|
||||
error_callable_msg = "'translate' property of field %r is not callable"
|
||||
if not callable(field_from.translate):
|
||||
raise ValueError(error_callable_msg % field_from)
|
||||
if not callable(field_to.translate):
|
||||
raise ValueError(error_callable_msg % field_to)
|
||||
if not field_to.store:
|
||||
raise ValueError("Field %r is not stored" % field_to)
|
||||
|
||||
lang_env = self.env.lang or 'en_US'
|
||||
langs = set(lang for lang, _ in self.env['res.lang'].get_installed())
|
||||
|
||||
# 1. Get translations
|
||||
record_from.flush_model([name_field_from])
|
||||
existing_translation_dictionary = field_to.get_translation_dictionary(
|
||||
record_to[name_field_to],
|
||||
{lang: record_to.with_context(prefetch_langs=True, lang=lang)[name_field_to] for lang in langs if lang != lang_env}
|
||||
)
|
||||
extra_translation_dictionary = field_from.get_translation_dictionary(
|
||||
record_from[name_field_from],
|
||||
{lang: record_from.with_context(prefetch_langs=True, lang=lang)[name_field_from] for lang in langs if lang != lang_env}
|
||||
)
|
||||
for term, extra_translation_values in extra_translation_dictionary.items():
|
||||
existing_translation_values = existing_translation_dictionary.setdefault(term, {})
|
||||
# Update only default translation values that aren't customized by the user.
|
||||
for lang, extra_translation in extra_translation_values.items():
|
||||
if existing_translation_values.get(lang, term) == term:
|
||||
existing_translation_values[lang] = extra_translation
|
||||
translation_dictionary = existing_translation_dictionary
|
||||
|
||||
# The `en_US` jsonb value should always be set, even if english is not
|
||||
# installed. If we don't do this, the custom snippet `arch_db` will only
|
||||
# have a `fr_BE` key but no `en_US` key.
|
||||
langs.add('en_US')
|
||||
|
||||
# 2. Set translations
|
||||
new_value = {
|
||||
lang: field_to.translate(lambda term: translation_dictionary.get(term, {}).get(lang), record_to[name_field_to])
|
||||
for lang in langs
|
||||
}
|
||||
record_to.env.cache.update_raw(record_to, field_to, [new_value], dirty=True)
|
||||
# Call `write` to trigger compute etc (`modified()`)
|
||||
record_to[name_field_to] = new_value[lang_env]
|
||||
|
||||
@api.model
|
||||
def _save_oe_structure_hook(self):
|
||||
return {}
|
||||
|
||||
@api.model
|
||||
def _pretty_arch(self, arch):
|
||||
# TODO: Remove this method in 16.3.
|
||||
return etree.tostring(arch, encoding='unicode')
|
||||
|
||||
@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))
|
||||
|
||||
@api.model
|
||||
def _get_allowed_root_attrs(self):
|
||||
return ['style', 'class', 'target', 'href']
|
||||
|
||||
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 self._get_allowed_root_attrs():
|
||||
if attribute in replacement.attrib:
|
||||
root.attrib[attribute] = replacement.attrib[attribute]
|
||||
elif attribute in root.attrib:
|
||||
del root.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)})
|
||||
self._copy_custom_snippet_translations(self, 'arch_db')
|
||||
|
||||
@api.model
|
||||
def _view_get_inherited_children(self, view):
|
||||
if self._context.get('no_primary_children', False):
|
||||
original_hierarchy = self._context.get('__views_get_original_hierarchy', [])
|
||||
return view.inherit_children_ids.filtered(lambda extension: extension.mode != 'primary' or extension.id in original_hierarchy)
|
||||
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 (starting from its top most parent)
|
||||
* 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 = []
|
||||
original_hierarchy = self._context.get('__views_get_original_hierarchy', [])
|
||||
while root and view.inherit_id:
|
||||
original_hierarchy.append(view.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)
|
||||
new_context = {
|
||||
**self._context,
|
||||
'active_test': False,
|
||||
}
|
||||
new_context.pop('lang', None)
|
||||
View = self.with_context(new_context)
|
||||
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 {}
|
||||
|
||||
def _find_available_name(self, name, used_names):
|
||||
attempt = 1
|
||||
candidate_name = name
|
||||
while candidate_name in used_names:
|
||||
attempt += 1
|
||||
candidate_name = f"{name} ({attempt})"
|
||||
return candidate_name
|
||||
|
||||
@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)
|
||||
|
||||
# find available name
|
||||
current_website = self.env['website'].browse(self._context.get('website_id'))
|
||||
website_domain = current_website.website_domain()
|
||||
used_names = self.search(expression.AND([
|
||||
[('name', '=like', '%s%%' % name)], website_domain
|
||||
])).mapped('name')
|
||||
name = self._find_available_name(name, used_names)
|
||||
|
||||
# html to xml to add '/' at the end of self closing tags like br, ...
|
||||
arch_tree = html.fromstring(arch)
|
||||
attributes = self._get_cleaned_non_editing_attributes(arch_tree.attrib.items())
|
||||
for attr in arch_tree.attrib:
|
||||
if attr in attributes:
|
||||
arch_tree.attrib[attr] = attributes[attr]
|
||||
else:
|
||||
del arch_tree.attrib[attr]
|
||||
xml_arch = etree.tostring(arch_tree, 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())
|
||||
custom_snippet_view = self.create(new_snippet_view_values)
|
||||
model = self._context.get('model')
|
||||
field = self._context.get('field')
|
||||
if field == 'arch':
|
||||
# Special case for `arch` which is a kind of related (through a
|
||||
# compute) to `arch_db` but which is hosting XML/HTML content while
|
||||
# being a char field.. Which is then messing around with the
|
||||
# `get_translation_dictionary` call, returning XML instead of
|
||||
# strings
|
||||
field = 'arch_db'
|
||||
res_id = self._context.get('resId')
|
||||
if model and field and res_id:
|
||||
self._copy_field_terms_translations(
|
||||
self.env[model].browse(int(res_id)),
|
||||
field,
|
||||
custom_snippet_view,
|
||||
'arch_db',
|
||||
)
|
||||
|
||||
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 rename_snippet(self, name, 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)])
|
||||
if snippet_addition_view:
|
||||
snippet_addition_view.name = name + ' Block'
|
||||
snippet_view.name = name
|
||||
|
||||
@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()
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
|
||||
import re
|
||||
|
||||
from odoo import models
|
||||
from odoo.exceptions import AccessDenied
|
||||
|
||||
|
||||
class IrWebsocket(models.AbstractModel):
|
||||
_inherit = 'ir.websocket'
|
||||
|
||||
def _build_bus_channel_list(self, channels):
|
||||
if self.env.uid:
|
||||
# Do not alter original list.
|
||||
channels = list(channels)
|
||||
for channel in channels:
|
||||
if isinstance(channel, str):
|
||||
match = re.match(r'editor_collaboration:(\w+(?:\.\w+)*):(\w+):(\d+)', channel)
|
||||
if match:
|
||||
model_name = match[1]
|
||||
field_name = match[2]
|
||||
res_id = int(match[3])
|
||||
|
||||
# Verify access to the edition channel.
|
||||
if not self.env.user._is_internal():
|
||||
raise AccessDenied()
|
||||
|
||||
document = self.env[model_name].browse([res_id])
|
||||
if not document.exists():
|
||||
continue
|
||||
|
||||
document.check_access_rights('read')
|
||||
document.check_field_access_rights('read', [field_name])
|
||||
document.check_access_rule('read')
|
||||
document.check_access_rights('write')
|
||||
document.check_field_access_rights('write', [field_name])
|
||||
document.check_access_rule('write')
|
||||
|
||||
channels.append((self.env.registry.db_name, 'editor_collaboration', model_name, field_name, res_id))
|
||||
return super()._build_bus_channel_list(channels)
|
||||
28
odoo-bringout-oca-ocb-web_editor/web_editor/models/models.py
Normal file
28
odoo-bringout-oca-ocb-web_editor/web_editor/models/models.py
Normal file
|
|
@ -0,0 +1,28 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
||||
from hashlib import sha256
|
||||
|
||||
from odoo import api, models
|
||||
|
||||
|
||||
class Base(models.AbstractModel):
|
||||
_inherit = 'base'
|
||||
|
||||
@api.model
|
||||
def _get_view_field_attributes(self):
|
||||
keys = super()._get_view_field_attributes()
|
||||
keys.append('sanitize')
|
||||
keys.append('sanitize_tags')
|
||||
return keys
|
||||
|
||||
|
||||
class BaseModel(models.AbstractModel):
|
||||
_inherit = 'base'
|
||||
|
||||
def update_field_translations_sha(self, fname, translations):
|
||||
field = self._fields[fname]
|
||||
if callable(field.translate):
|
||||
for translation in translations.values():
|
||||
for key, value in translation.items():
|
||||
translation[key] = field.translate.term_converter(value)
|
||||
return self._update_field_translations(fname, translations, lambda old_term: sha256(old_term.encode()).hexdigest())
|
||||
|
|
@ -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()
|
||||
Loading…
Add table
Add a link
Reference in a new issue