Initial commit: OCA Technical packages (595 packages)

odoo-bringout-oca-ddmrp-ddmrp_warning/ddmrp_warning/models/__init__.py

@@ -0,0 +1,3 @@
+from . import ddmrp_warning_definition
+from . import ddmrp_warning_item
+from . import stock_buffer

odoo-bringout-oca-ddmrp-ddmrp_warning/ddmrp_warning/models/ddmrp_warning_definition.py

@@ -0,0 +1,79 @@
+# Copyright 2021 ForgeFlow S.L. (https://www.forgeflow.com)
+# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl.html).
+
+from odoo import _, fields, models, tools
+from odoo.exceptions import UserError
+from odoo.osv import expression
+from odoo.tools.safe_eval import safe_eval
+
+
+class DdmrpWarningDefinition(models.Model):
+    _name = "ddmrp.warning.definition"
+    _description = "DDMRP Warning Definition"
+
+    name = fields.Char(
+        string="Description",
+    )
+    python_code = fields.Text(
+        string="Warning Expression",
+        help="Write Python code that defines when this warning should "
+        "raise. The result of executing the expression must be "
+        "a boolean.",
+        default="""# Available locals:\n#  - buffer: A buffer record\nTrue""",
+    )
+    severity = fields.Selection(
+        selection=[("1_low", "Low"), ("2_mid", "Medium"), ("3_high", "High")],
+        default="2_mid",
+    )
+    active = fields.Boolean(default=True)
+    warning_domain = fields.Char(
+        string="Buffer Applicable Domain",
+        default="[]",
+        help="Domain based on Stock Buffer, to define if the "
+        "warning is applicable or not.",
+    )
+    ddmrp_warning_item_ids = fields.One2many(
+        comodel_name="ddmrp.warning.item",
+        inverse_name="warning_definition_id",
+        readonly=True,
+    )
+
+    def _eval_warning_domain(self, buffer, domain):
+        buffer_domain = [("id", "=", buffer.id)]
+        return bool(
+            self.env["stock.buffer"].search_count(
+                expression.AND([buffer_domain, domain])
+            )
+        )
+
+    def _is_warning_applicable(self, buffer):
+        domain = safe_eval(self.warning_domain) or []
+        if domain:
+            return self._eval_warning_domain(buffer, domain)
+        return True
+
+    def evaluate_definition(self, buffer):
+        self.ensure_one()
+        try:
+            res = safe_eval(
+                self.python_code,
+                globals_dict={
+                    "buffer": buffer,
+                    "time": tools.safe_eval.time,
+                    "datetime": tools.safe_eval.datetime,
+                    "dateutil": tools.safe_eval.dateutil,
+                },
+            )
+        except Exception as error:
+            raise UserError(
+                _("Error evaluating %(name)s.\n %(error)s")
+                % ({"name": self._name, "error": error})
+            ) from error
+        return res
+
+    def write(self, vals):
+        # Unlink warning items when definition is archived
+        res = super().write(vals)
+        if "active" in vals and not vals.get("active"):
+            self.ddmrp_warning_item_ids.unlink()
+        return res

odoo-bringout-oca-ddmrp-ddmrp_warning/ddmrp_warning/models/ddmrp_warning_item.py

@@ -0,0 +1,39 @@
+# Copyright 2021 ForgeFlow S.L. (https://www.forgeflow.com)
+# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl.html).
+
+from odoo import fields, models
+
+
+class DdmrpWarningItem(models.Model):
+    _name = "ddmrp.warning.item"
+    _description = "DDMRP Warning Item"
+    _order = "severity desc, id"
+
+    warning_definition_id = fields.Many2one(
+        comodel_name="ddmrp.warning.definition",
+        ondelete="cascade",
+    )
+    buffer_id = fields.Many2one(comodel_name="stock.buffer", ondelete="cascade")
+    name = fields.Char(
+        compute="_compute_name",
+    )
+    product_id = fields.Many2one(related="buffer_id.product_id")
+    location_id = fields.Many2one(
+        related="buffer_id.location_id", groups="stock.group_stock_multi_locations"
+    )
+    severity = fields.Selection(
+        related="warning_definition_id.severity",
+        store=True,
+        readonly=True,
+    )
+    company_id = fields.Many2one(
+        related="buffer_id.company_id",
+        store=True,
+    )
+
+    def _compute_name(self):
+        for rec in self:
+            rec.name = "{} in {}".format(
+                rec.warning_definition_id.display_name,
+                rec.buffer_id.display_name,
+            )

odoo-bringout-oca-ddmrp-ddmrp_warning/ddmrp_warning/models/stock_buffer.py

@@ -0,0 +1,79 @@
+# Copyright 2021 ForgeFlow S.L. (https://www.forgeflow.com)
+# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl.html).
+
+import logging
+import threading
+
+from odoo import api, fields, models
+from odoo.tools.misc import split_every
+
+_logger = logging.getLogger(__name__)
+
+
+class Buffer(models.Model):
+    _inherit = "stock.buffer"
+
+    ddmrp_warning_item_ids = fields.One2many(
+        comodel_name="ddmrp.warning.item",
+        inverse_name="buffer_id",
+        readonly=True,
+    )
+
+    def _generate_ddmrp_warnings(self):
+        definitions = self.env["ddmrp.warning.definition"].search([])
+        item_model = self.env["ddmrp.warning.item"]
+        for rec in self:
+            for d in definitions:
+                existing = item_model.search(
+                    [("buffer_id", "=", rec.id), ("warning_definition_id", "=", d.id)]
+                )
+                warning_applicable = d._is_warning_applicable(rec)
+                if warning_applicable:
+                    warning_raised = d.evaluate_definition(rec)
+                    if warning_raised and not existing:
+                        item_model.create(
+                            {"buffer_id": rec.id, "warning_definition_id": d.id}
+                        )
+                    elif not warning_raised and existing:
+                        existing.unlink()
+                elif not warning_applicable and existing:
+                    existing.unlink()
+
+    def action_generate_warnings(self):
+        self._generate_ddmrp_warnings()
+        return True
+
+    @api.model
+    def cron_generate_ddmrp_warnings(self, automatic=False):
+        auto_commit = not getattr(threading.current_thread(), "testing", False)
+        buffer_ids = self.search([]).ids
+        i = 0
+        j = len(buffer_ids)
+        for buffer_chunk_ids in split_every(self.CRON_DDMRP_CHUNKS, buffer_ids):
+            for b in self.browse(buffer_chunk_ids).exists():
+                try:
+                    i += 1
+                    _logger.debug(
+                        "ddmrp cron_generate_ddmrp_warnings: {}. ({}/{})".format(
+                            b.name, i, j
+                        )
+                    )
+                    if automatic:
+                        with self.env.cr.savepoint():
+                            b._generate_ddmrp_warnings()
+                    else:
+                        b._generate_ddmrp_warnings()
+                except Exception:
+                    _logger.exception("Fail to compute Warnings for buffer %s", b.name)
+                    if not automatic:
+                        raise
+            if auto_commit:
+                self._cr.commit()  # pylint: disable=E8102
+        return True
+
+    def write(self, vals):
+        # Unlink warning items when buffer is archived
+        res = super().write(vals)
+        if "active" in vals and not vals.get("active"):
+            self.ddmrp_warning_item_ids.unlink()
+        return res