264 lines
9.9 KiB
Python
264 lines
9.9 KiB
Python
# Copyright 2018 Camptocamp (https://www.camptocamp.com).
|
|
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
|
|
|
|
import logging
|
|
|
|
from functools import partialmethod
|
|
|
|
from lxml import etree
|
|
|
|
from odoo import api, fields, models
|
|
from ..serv_config import serv_config
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
|
|
class ServerEnvMixin(models.AbstractModel):
|
|
"""Mixin to add server environment in existing models
|
|
|
|
Usage::
|
|
|
|
class StorageBackend(models.Model):
|
|
_name = "storage.backend"
|
|
_inherit = ["storage.backend", "server.env.mixin"]
|
|
|
|
@property
|
|
def _server_env_fields(self):
|
|
return {"directory_path": 'get'}
|
|
|
|
With the snippet above, the "storage.backend" model now uses a server
|
|
environment configuration for the field ``directory_path``.
|
|
|
|
Under the hood, this mixin automatically replaces the original field
|
|
by an env-computed field that reads from the configuration files.
|
|
|
|
By default, it looks for the configuration in a section named
|
|
``[model_name.Record Name]`` where ``model_name`` is the ``_name`` of the
|
|
model with ``.`` replaced by ``_``. It can be customized by overriding the
|
|
method :meth:`~_server_env_section_name`.
|
|
|
|
For each field transformed to an env-computed field, a companion field
|
|
``<field>_env_default`` is automatically created. When it's value is set
|
|
and the configuration files do not contain a key, the env-computed field
|
|
uses the default value stored in database. If a key is empty, the
|
|
env-computed field has an empty value.
|
|
|
|
Env-computed fields are conditionally editable, based on the absence
|
|
of their key in environment configuration files. When edited, their
|
|
value is stored in the database.
|
|
"""
|
|
_name = 'server.env.mixin'
|
|
|
|
server_env_defaults = fields.Serialized()
|
|
|
|
@property
|
|
def _server_env_fields(self):
|
|
"""Dict of fields to replace by fields computed from env
|
|
|
|
To override in models. The dictionary is:
|
|
{'name_of_the_field': 'name_of_the_configparser_getter'}
|
|
|
|
The configparser getter can be one of: get, getbool, getint
|
|
|
|
Example::
|
|
|
|
@property
|
|
def _server_env_fields(self):
|
|
base_fields = super()._server_env_fields
|
|
sftp_fields = {
|
|
"sftp_server": "get",
|
|
"sftp_port": "getint",
|
|
"sftp_login": "get",
|
|
"sftp_password": "get",
|
|
}
|
|
sftp_fields.update(base_fields)
|
|
return sftp_fields
|
|
"""
|
|
return {}
|
|
|
|
@api.multi
|
|
def _server_env_section_name(self):
|
|
"""Name of the section in the configuration files
|
|
|
|
Can be customized in your model
|
|
"""
|
|
self.ensure_one()
|
|
return ".".join(
|
|
(self._name.replace(".", "_"), self.name)
|
|
)
|
|
|
|
@api.multi
|
|
def _server_env_read_from_config(self, section_name, field_name,
|
|
config_getter):
|
|
self.ensure_one()
|
|
try:
|
|
getter = getattr(serv_config, config_getter)
|
|
value = getter(section_name, field_name)
|
|
except:
|
|
_logger.exception(
|
|
"error trying to read field %s in section %s",
|
|
field_name,
|
|
section_name,
|
|
)
|
|
return False
|
|
return value
|
|
|
|
@api.multi
|
|
def _compute_server_env(self):
|
|
"""Read values from environment configuration files
|
|
|
|
If an env-computed field has no key in configuration files,
|
|
read from the ``<field>_env_default`` field from database.
|
|
"""
|
|
for record in self:
|
|
for field_name, getter_name in record._server_env_fields.items():
|
|
section_name = record._server_env_section_name()
|
|
if (section_name in serv_config
|
|
and field_name in serv_config[section_name]):
|
|
|
|
value = record._server_env_read_from_config(
|
|
section_name, field_name, getter_name
|
|
)
|
|
|
|
else:
|
|
default_field = record._server_env_default_fieldname(
|
|
field_name
|
|
)
|
|
value = record[default_field]
|
|
|
|
record[field_name] = value
|
|
|
|
def _inverse_server_env(self, field_name):
|
|
default_field = self._server_env_default_fieldname(field_name)
|
|
is_editable_field = self._server_env_is_editable_fieldname(field_name)
|
|
for record in self:
|
|
# when we write in an env-computed field, if it is editable
|
|
# we update the default value in database
|
|
if record[is_editable_field]:
|
|
record[default_field] = record[field_name]
|
|
|
|
@api.multi
|
|
def _compute_server_env_is_editable(self):
|
|
"""Compute <field>_is_editable values
|
|
|
|
We can edit an env-computed filed only if there is no key
|
|
in any environment configuration file. If there is an empty
|
|
key, it's an empty value so we can't edit the env-computed field.
|
|
"""
|
|
# we can't group it with _compute_server_env otherwise when called
|
|
# in ``_inverse_server_env`` it would reset the value of the field
|
|
for record in self:
|
|
for field_name in self._server_env_fields:
|
|
is_editable_field = self._server_env_is_editable_fieldname(
|
|
field_name
|
|
)
|
|
|
|
section_name = record._server_env_section_name()
|
|
is_editable = not (section_name in serv_config
|
|
and field_name in serv_config[section_name])
|
|
record[is_editable_field] = is_editable
|
|
|
|
def _server_env_view_set_readonly(self, view_arch):
|
|
field_xpath = './/field[@name="%s"]'
|
|
for field in self._server_env_fields:
|
|
is_editable_field = self._server_env_is_editable_fieldname(field)
|
|
for elem in view_arch.findall(field_xpath % field):
|
|
# set env-computed fields to readonly if the configuration
|
|
# files have a key
|
|
elem.set('attrs',
|
|
str({'readonly': [(is_editable_field, '=', False)]}))
|
|
if not view_arch.findall(field_xpath % is_editable_field):
|
|
# add the _is_editable fields in the view for the 'attrs'
|
|
# domain
|
|
view_arch.append(
|
|
etree.Element(
|
|
'field',
|
|
name=is_editable_field,
|
|
invisible="1"
|
|
)
|
|
)
|
|
return view_arch
|
|
|
|
def _fields_view_get(self, view_id=None, view_type='form', toolbar=False,
|
|
submenu=False):
|
|
view_data = super()._fields_view_get(
|
|
view_id=view_id, view_type=view_type,
|
|
toolbar=toolbar, submenu=submenu
|
|
)
|
|
view_arch = etree.fromstring(view_data['arch'].encode('utf-8'))
|
|
view_arch = self._server_env_view_set_readonly(view_arch)
|
|
view_data['arch'] = etree.tostring(view_arch, encoding='unicode')
|
|
return view_data
|
|
|
|
def _server_env_default_fieldname(self, base_field_name):
|
|
"""Return the name of the field with default value"""
|
|
return '%s_env_default' % (base_field_name,)
|
|
|
|
def _server_env_is_editable_fieldname(self, base_field_name):
|
|
"""Return the name of the field for "is editable
|
|
|
|
This is the field used to tell if the env-computed field can
|
|
be edited.
|
|
"""
|
|
return '%s_env_is_editable' % (base_field_name,)
|
|
|
|
def _server_env_transform_field_to_read_from_env(self, field):
|
|
"""Transform the original field in a computed field"""
|
|
field.compute = '_compute_server_env'
|
|
inverse_method_name = '_inverse_server_env_%s' % field.name
|
|
inverse_method = partialmethod(
|
|
ServerEnvMixin._inverse_server_env, field.name
|
|
)
|
|
setattr(ServerEnvMixin, inverse_method_name, inverse_method)
|
|
field.inverse = inverse_method_name
|
|
field.store = False
|
|
field.required = False
|
|
field.copy = False
|
|
field.sparse = None
|
|
|
|
def _server_env_add_is_editable_field(self, base_field):
|
|
"""Add a field indicating if we can edit the env-computed fields
|
|
|
|
It is used in the inverse function of the env-computed field
|
|
and in the views to add 'readonly' on the fields.
|
|
"""
|
|
fieldname = self._server_env_is_editable_fieldname(base_field.name)
|
|
if fieldname not in self._fields:
|
|
field = fields.Boolean(
|
|
compute='_compute_server_env_is_editable',
|
|
automatic=True,
|
|
)
|
|
self._add_field(fieldname, field)
|
|
|
|
def _server_env_add_default_field(self, base_field):
|
|
"""Add a field storing the default value
|
|
|
|
The default value is used when there is no key for an env-computed
|
|
field in the configuration files.
|
|
|
|
The field is stored in the serialized field ``server_env_defaults``.
|
|
"""
|
|
fieldname = self._server_env_default_fieldname(base_field.name)
|
|
if fieldname not in self._fields:
|
|
base_field_cls = base_field.__class__
|
|
field_args = base_field.args.copy()
|
|
field_args.pop('_sequence', None)
|
|
field_args.update({
|
|
'sparse': 'server_env_defaults',
|
|
'automatic': True,
|
|
})
|
|
|
|
if hasattr(base_field, 'selection'):
|
|
field_args['selection'] = base_field.selection
|
|
field = base_field_cls(**field_args)
|
|
self._add_field(fieldname, field)
|
|
|
|
@api.model
|
|
def _setup_base(self):
|
|
super()._setup_base()
|
|
for fieldname in self._server_env_fields:
|
|
field = self._fields[fieldname]
|
|
self._server_env_add_default_field(field)
|
|
self._server_env_transform_field_to_read_from_env(field)
|
|
self._server_env_add_is_editable_field(field)
|