215 lines
7.9 KiB
Python
215 lines
7.9 KiB
Python
# Copyright 2020 Onestein (<https://www.onestein.eu>)
|
|
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
|
|
|
|
import json
|
|
|
|
from lxml import etree
|
|
|
|
from odoo import _, api, fields, models
|
|
from odoo.tools import config, ormcache
|
|
|
|
# put this object into context key '__no_changeset' to disable changeset
|
|
# functionality
|
|
disable_changeset = object()
|
|
|
|
|
|
class Base(models.AbstractModel):
|
|
_inherit = "base"
|
|
|
|
changeset_ids = fields.One2many(
|
|
comodel_name="record.changeset",
|
|
compute="_compute_changeset_ids",
|
|
string="Changesets",
|
|
)
|
|
changeset_change_ids = fields.One2many(
|
|
comodel_name="record.changeset.change",
|
|
compute="_compute_changeset_ids",
|
|
string="Changeset Changes",
|
|
)
|
|
count_changesets = fields.Integer(
|
|
compute="_compute_count_pending_changesets",
|
|
help="The overall number of changesets of this record",
|
|
)
|
|
count_pending_changesets = fields.Integer(
|
|
compute="_compute_count_pending_changesets",
|
|
help="The number of pending changesets of this record",
|
|
)
|
|
count_pending_changeset_changes = fields.Integer(
|
|
compute="_compute_count_pending_changesets",
|
|
help="The number of pending changes of this record",
|
|
)
|
|
user_can_see_changeset = fields.Boolean(compute="_compute_user_can_see_changeset")
|
|
|
|
def _compute_changeset_ids(self):
|
|
model_name = self._name
|
|
for record in self:
|
|
changesets = self.env["record.changeset"].search(
|
|
[("model", "=", model_name), ("res_id", "=", record.id)]
|
|
)
|
|
record.changeset_ids = changesets
|
|
record.changeset_change_ids = changesets.mapped("change_ids")
|
|
|
|
def _compute_count_pending_changesets(self):
|
|
model_name = self._name
|
|
if model_name in self.models_to_track_changeset():
|
|
for rec in self:
|
|
rec.count_changesets = len(rec.changeset_ids)
|
|
changesets = rec.changeset_ids.filtered(
|
|
lambda rev: rev.state == "draft"
|
|
and rev.res_id == rec.id
|
|
and rev.model == model_name
|
|
)
|
|
changes = changesets.mapped("change_ids")
|
|
changes = changes.filtered(
|
|
lambda c: c.state in c.get_pending_changes_states()
|
|
)
|
|
rec.count_pending_changesets = len(changesets)
|
|
rec.count_pending_changeset_changes = len(changes)
|
|
else:
|
|
for rec in self:
|
|
rec.count_changesets = 0
|
|
rec.count_pending_changesets = 0
|
|
rec.count_pending_changeset_changes = 0
|
|
|
|
@api.model
|
|
@ormcache(skiparg=1)
|
|
def models_to_track_changeset(self):
|
|
"""Models to be tracked for changes
|
|
:args:
|
|
:returns: list of models
|
|
"""
|
|
models = (
|
|
self.env["changeset.field.rule"].sudo().search([]).mapped("model_id.model")
|
|
)
|
|
if config["test_enable"] and self.env.context.get("test_record_changeset"):
|
|
if "res.partner" not in models:
|
|
models += ["res.partner"] # Used in tests
|
|
return models
|
|
|
|
@api.model_create_multi
|
|
def create(self, vals_list):
|
|
result = super().create(vals_list)
|
|
if self._changeset_disabled():
|
|
return result
|
|
for this, vals in zip(result, vals_list):
|
|
local_vals = self.env["record.changeset"].add_changeset(
|
|
this, vals, create=True
|
|
)
|
|
local_vals = {
|
|
key: value for key, value in local_vals.items() if vals[key] != value
|
|
}
|
|
if local_vals:
|
|
this.with_context(
|
|
__no_changeset=disable_changeset,
|
|
tracking_disable=True,
|
|
).write(local_vals)
|
|
return result
|
|
|
|
def write(self, values):
|
|
if self._changeset_disabled():
|
|
return super().write(values)
|
|
|
|
for record in self:
|
|
local_values = self.env["record.changeset"].add_changeset(record, values)
|
|
super(Base, record).write(local_values)
|
|
return True
|
|
|
|
def _changeset_disabled(self):
|
|
if self.env.context.get("__no_changeset") == disable_changeset:
|
|
return True
|
|
# To avoid conflicts with tests of other modules
|
|
if config["test_enable"] and not self.env.context.get("test_record_changeset"):
|
|
return True
|
|
if self._name not in self.models_to_track_changeset():
|
|
return True
|
|
return False
|
|
|
|
def action_record_changeset_change_view(self):
|
|
self.ensure_one()
|
|
res = {
|
|
"type": "ir.actions.act_window",
|
|
"res_model": "record.changeset.change",
|
|
"view_mode": "tree",
|
|
"views": [
|
|
[
|
|
self.env.ref("base_changeset.view_record_changeset_change_tree").id,
|
|
"list",
|
|
]
|
|
],
|
|
"context": self.env.context,
|
|
"name": _("Record Changes"),
|
|
"search_view_id": [
|
|
self.env.ref("base_changeset.view_record_changeset_change_search").id,
|
|
"search",
|
|
],
|
|
}
|
|
record_id = self.env.context.get("search_default_record_id")
|
|
if record_id:
|
|
res.update(
|
|
{
|
|
"domain": [
|
|
("model", "=", self._name),
|
|
("changeset_id.res_id", "=", record_id),
|
|
]
|
|
}
|
|
)
|
|
return res
|
|
|
|
@api.model
|
|
def get_view(self, view_id=None, view_type="form", **options):
|
|
"""Insert the pending changes smart button in the form view of tracked models."""
|
|
res = super().get_view(view_id=view_id, view_type=view_type, **options)
|
|
if (
|
|
view_type == "form"
|
|
and self._name in self.models_to_track_changeset()
|
|
and self._user_can_see_changeset()
|
|
):
|
|
button_label = _("Changes")
|
|
doc = etree.XML(res["arch"])
|
|
for node in doc.xpath("//div[@name='button_box']"):
|
|
field_count_changesets = etree.Element(
|
|
"field",
|
|
{
|
|
"name": "count_changesets",
|
|
"modifiers": json.dumps({"invisible": True}),
|
|
},
|
|
)
|
|
field_count_pending_changeset_changes = etree.Element(
|
|
"field",
|
|
{
|
|
"name": "count_pending_changeset_changes",
|
|
"string": button_label,
|
|
"widget": "statinfo",
|
|
},
|
|
)
|
|
xml_button = etree.Element(
|
|
"button",
|
|
{
|
|
"type": "object",
|
|
"name": "action_record_changeset_change_view",
|
|
"icon": "fa-code-fork",
|
|
"context": "{'search_default_draft': 1, "
|
|
"'search_default_record_id': active_id}",
|
|
"modifiers": json.dumps(
|
|
{"invisible": [("count_changesets", "=", 0)]}
|
|
),
|
|
},
|
|
)
|
|
xml_button.insert(0, field_count_pending_changeset_changes)
|
|
xml_button.insert(0, field_count_changesets)
|
|
node.insert(0, xml_button)
|
|
res["arch"] = etree.tostring(doc, encoding="unicode")
|
|
return res
|
|
|
|
@api.model
|
|
def _user_can_see_changeset(self):
|
|
"""Return if the current user has changeset access"""
|
|
return self.env.is_superuser() or self.user_has_groups(
|
|
"base_changeset.group_changeset_user"
|
|
)
|
|
|
|
def _compute_user_can_see_changeset(self):
|
|
user_can_see_changeset = self._user_can_see_changeset()
|
|
for rec in self:
|
|
rec.user_can_see_changeset = user_can_see_changeset
|