Initial commit: OCA Technical packages (595 packages)

odoo-bringout-oca-server-tools-base_changeset/base_changeset/models/base.py

@@ -0,0 +1,214 @@
+# 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