Merge remote-tracking branch 'origin/19.0' into 19.0-mig-sale_mrp

Author: GarethGloSystems

cpq/README.rst

@@ -0,0 +1,16 @@
+===
+cpq
+===
+
+This module provides the base functionality:
+
+- Prevents the automatic creation of variants
+- Extends of product attributes to allow custom options
+- Custom options are propagated to variants, preventing the stock system from mixing them up
+- An Owl based UI to configure products (read: create variants)
+
+Additional modules should almost always be installed:
+- cpq_sale for sale integration
+- cpq_mrp for dynamic BoM generation
+- cpq_account for accounts integration
+

cpq/__init__.py

@@ -0,0 +1,2 @@
+from . import controllers
+from . import models

cpq/__manifest__.py

@@ -0,0 +1,21 @@
+{
+    "name": "cpq",
+    "summary": "Dynamic Configure-Price-Quote-style generation of products",
+    "version": "19.0.1.0.0",
+    "author": "Glo Networks",
+    "website": "https://github.com/GlodoUK/odoo-addons",
+    "depends": ["product"],
+    "data": [
+        "security/ir.model.access.csv",
+        "views/product_attribute.xml",
+        "views/product_product.xml",
+        "views/product_template.xml",
+    ],
+    "assets": {
+        "web.assets_backend": [
+            "cpq/static/src/components/**/*.js",
+            "cpq/static/src/components/**/*.xml",
+        ],
+    },
+    "license": "LGPL-3",
+}

cpq/controllers/__init__.py

@@ -0,0 +1 @@
+from . import main

cpq/controllers/main.py

@@ -0,0 +1,94 @@
+from odoo.exceptions import UserError
+from odoo.http import Controller, request, route
+
+
+class ProductConfiguratorController(Controller):
+    def _cpq_extract_from_combination(self, product_tmpl_id, combination):
+        ptav_ids = request.env["product.template.attribute.value"].sudo()
+        custom_dict = {}
+
+        valid_product_tmpl_ptav_ids = (
+            product_tmpl_id.valid_product_template_attribute_line_ids.mapped(
+                "product_template_value_ids"
+            )
+        )
+
+        for k, v in combination.items():
+            ptav_id = valid_product_tmpl_ptav_ids.filtered(
+                lambda v, k=k: v.id == int(k)
+            )
+            ptav_id.ensure_one()
+
+            if ptav_id.is_custom:
+                custom_dict.update({ptav_id: v})
+
+            ptav_ids |= ptav_id
+
+        return (ptav_ids, custom_dict)
+
+    @route("/cpq/<int:product_tmpl_id>/data", type="jsonrpc", auth="user")
+    def cpq_tmpl_data(
+        self,
+        product_tmpl_id,
+        company_id=None,
+        pricelist_id=None,
+        ptav_ids=None,
+    ):
+        product_tmpl_id = request.env["product.template"].browse(product_tmpl_id)
+        if not product_tmpl_id.cpq_ok:
+            raise UserError(request.env._("Not a CPQ enabled product!"))
+
+        return product_tmpl_id._cpq_get_combination_info()
+
+    @route("/cpq/<int:product_tmpl_id>/validate", type="jsonrpc", auth="user")
+    def cpq_validate(
+        self,
+        product_tmpl_id,
+        combination,
+    ):
+        product_tmpl_id = request.env["product.template"].sudo().browse(product_tmpl_id)
+        if not product_tmpl_id.cpq_ok:
+            return {
+                "valid": False,
+                "msg": request.env._("Not CPQ Enabled!"),
+            }
+
+        (ptav_ids, custom_dict) = self._cpq_extract_from_combination(
+            product_tmpl_id, combination
+        )
+
+        (variant_ok, msg) = product_tmpl_id._cpq_ensure_valid_values(
+            ptav_ids,
+            custom_dict,
+            raise_on_invalidity=False,
+            validate_only=True,
+        )
+
+        return {
+            "valid": variant_ok,
+            "errors": msg,
+        }
+
+    @route("/cpq/<int:product_tmpl_id>/configure", type="jsonrpc", auth="user")
+    def cpq_configure(
+        self,
+        product_tmpl_id,
+        combination,
+    ):
+        product_tmpl_id = request.env["product.template"].sudo().browse(product_tmpl_id)
+        if not product_tmpl_id.cpq_ok:
+            raise UserError(request.env._("Not a CPQ enabled product!"))
+
+        (ptav_ids, custom_dict) = self._cpq_extract_from_combination(
+            product_tmpl_id, combination
+        )
+
+        variant_id = product_tmpl_id._cpq_get_create_variant(
+            ptav_ids,
+            custom_dict,
+        )
+
+        return {
+            "product_tmpl_id": product_tmpl_id.id,
+            "product_id": variant_id.id,
+        }

cpq/models/__init__.py

@@ -0,0 +1,3 @@
+from . import product_attribute
+from . import product_template
+from . import product_product

cpq/models/product_attribute.py

@@ -0,0 +1,168 @@
+from odoo import api, fields, models
+
+
+class ProductAttribute(models.Model):
+    _inherit = "product.attribute"
+    _order = "sequence"
+
+    cpq_propagate_to_variant = fields.Boolean(
+        "Propagate To Variant",
+        default=True,
+    )
+
+    def copy_data(self, default=None):
+        default = dict(default or {})
+        vals_list = super().copy_data(default=default)
+        if "name" not in default:
+            for attribute, vals in zip(self, vals_list, strict=False):
+                vals["name"] = self.env._("%s (copy)", attribute.name)
+        return vals_list
+
+
+class ProductAttributeValue(models.Model):
+    _inherit = "product.attribute.value"
+
+    cpq_custom_type = fields.Selection(
+        [
+            ("integer", "Integer"),
+            ("float", "Float"),
+            ("char", "Text"),
+        ],
+        "Configurable Custom Type",
+    )
+
+    def copy_data(self, default=None):
+        default = dict(default or {})
+        vals_list = super().copy_data(default=default)
+        if "name" not in default:
+            for value, vals in zip(self, vals_list, strict=False):
+                vals["name"] = self.env._("%s (copy)", value.name)
+        return vals_list
+
+    def _cpq_cast_custom(self, value):
+        """
+        Cast the stored custom_value into the real value.
+        i.e. custom_value may store a int, which we need to cast into an Odoo
+        record
+        """
+        self.ensure_one()
+
+        if not self.is_custom or not self.cpq_custom_type:
+            return value
+
+        method = f"_cpq_cast_custom_{self.cpq_custom_type}"
+        return getattr(self, method)(value)
+
+    def _cpq_cast_custom_integer(self, value):
+        return self._cpq_sanitise_custom_integer(value)
+
+    def _cpq_cast_custom_float(self, value):
+        return self._cpq_sanitise_custom_float(value)
+
+    def _cpq_cast_custom_char(self, value):
+        return self._cpq_sanitise_custom_char(value)
+
+    def _cpq_sanitise_custom(self, value):
+        self.ensure_one()
+
+        if not self.is_custom or not self.cpq_custom_type:
+            return value
+
+        method = f"_cpq_sanitise_custom_{self.cpq_custom_type}"
+        return getattr(self, method)(value)
+
+    @api.model
+    def _cpq_sanitise_custom_integer(self, value):
+        return int(value)
+
+    @api.model
+    def _cpq_sanitise_custom_float(self, value):
+        return float(value)
+
+    @api.model
+    def _cpq_sanitise_custom_char(self, value):
+        if not value:
+            return ""
+        return value.strip()
+
+    def _cpq_validate_custom(self, value):
+        self.ensure_one()
+
+        if not self.is_custom or not self.cpq_custom_type:
+            return True
+
+        method = f"_cpq_validate_custom_{self.cpq_custom_type}"
+        return getattr(self, method)(value)
+
+    @api.model
+    def _cpq_validate_custom_integer(self, value):
+        if isinstance(value, bool):
+            return False
+        try:
+            int(value)
+            return True
+        except (ValueError, TypeError):
+            return False
+
+    @api.model
+    def _cpq_validate_custom_float(self, value):
+        if isinstance(value, bool):
+            return False
+        try:
+            float(value)
+            return True
+        except (ValueError, TypeError):
+            return False
+
+    @api.model
+    def _cpq_validate_custom_char(self, value):
+        return isinstance(value, str) and value.strip()
+
+
+class ProductTemplateAttributeLine(models.Model):
+    _inherit = "product.template.attribute.line"
+
+    cpq_propagate_to_variant = fields.Boolean(
+        related="attribute_id.cpq_propagate_to_variant", store=True
+    )
+
+    def _cpq_get_combination_info(self):
+        self.ensure_one()
+        i = self
+
+        return {
+            "id": i.id,
+            "name": i.display_name,
+            "display_type": i.attribute_id.display_type,
+            "ptav_ids": [
+                ptav_id._cpq_get_combination_info()
+                for ptav_id in i.product_template_value_ids.filtered(
+                    lambda attr_line: attr_line.ptav_active
+                )
+            ],
+        }
+
+
+class ProductTemplateAttributeValue(models.Model):
+    _inherit = "product.template.attribute.value"
+
+    cpq_propagate_to_variant = fields.Boolean(
+        related="attribute_id.cpq_propagate_to_variant"
+    )
+    cpq_custom_type = fields.Selection(
+        related="product_attribute_value_id.cpq_custom_type"
+    )
+
+    def _cpq_get_combination_info(self):
+        self.ensure_one()
+        ptav_id = self
+
+        return {
+            "id": ptav_id.id,
+            "name": ptav_id.name,
+            "html_color": ptav_id.html_color,
+            "is_custom": ptav_id.is_custom,
+            "price_extra": 0.0,
+            "excluded": False,
+            "cpq_custom_type": ptav_id.cpq_custom_type,
+        }