+
Web Domain Field
+
+
+

+
When you define a view you can specify on the relational fields a domain
+attribute. This attribute is evaluated as filter to apply when displaying
+existing records for selection.
+
Table of contents
+
+
+
+
When you define a view you can specify on the relational fields a domain
+attribute. This attribute is evaluated as filter to apply when displaying
+existing records for selection.
+
+<field name="product_id" domain="[('type','=','product')]"/>
+
+
The value provided for the domain attribute must be a string representing a
+valid Odoo domain. This string is evaluated on the client side in a
+restricted context where we can reference as right operand the values of
+fields present into the form and a limited set of functions.
+
In this context it’s hard to build complex domain and we are facing to some
+limitations as:
+
+
+- The syntax to include in your domain a criteria involving values from a
+x2many field is complex.
+- The right side of domain in case of x2many can involve huge amount of ids
+(performance problem).
+- Domains computed by an onchange on an other field are not recomputed when
+you modify the form and don’t modify the field triggering the onchange.
+- It’s not possible to extend an existing domain. You must completely redefine
+the domain in your specialized addon
+- etc…
+
+
+
In order to mitigate these limitations this new addon allows you to use the
+value of a field as domain of an other field in the xml definition of your
+view.
+
+<field name="product_id_domain" invisible="1"/>
+<field name="product_id" domain="product_id_domain"/>
+
+
The field used as domain must provide the domain as a JSON encoded string.
+
+product_id_domain = fields.Char(
+ compute="_compute_product_id_domain",
+ readonly=True,
+ store=False,
+)
+
+@api.depends('name')
+def _compute_product_id_domain(self):
+ for rec in self:
+ rec.product_id_domain = json.dumps(
+ [('type', '=', 'product'), ('name', 'like', rec.name)]
+ )
+
+
+
+
+
Bugs are tracked on GitHub Issues.
+In case of trouble, please check there if your issue has already been reported.
+If you spotted it first, help us to smash it by providing a detailed and welcomed
+feedback.
+
Do not contact contributors directly about support or help with technical issues.
+
+
+
+
+
+
+
+
This module is maintained by the OCA.
+

+
OCA, or the Odoo Community Association, is a nonprofit organization whose
+mission is to support the collaborative development of Odoo features and
+promote its widespread use.
+
This module is part of the OCA/web project on GitHub.
+
You are welcome to contribute. To learn how please visit https://odoo-community.org/page/Contribute.
+
+
+
+
+
diff --git a/odex30_base/web_domain_field/static/lib/js/pyeval.js b/odex30_base/web_domain_field/static/lib/js/pyeval.js
new file mode 100644
index 0000000..004fac6
--- /dev/null
+++ b/odex30_base/web_domain_field/static/lib/js/pyeval.js
@@ -0,0 +1,94 @@
+/** @odoo-module **/
+
+import { toPyValue } from "@web/core/py_js/py_utils";
+import { evaluateExpr } from "@web/core/py_js/py";
+import { user } from "@web/core/user";
+import { patch } from "@web/core/utils/patch";
+
+/**
+ * Web Domain Field Module for Odoo 18
+ *
+ * This module extends Odoo's domain evaluation system to allow using
+ * computed field values as domains. It patches the core domain evaluation
+ * to check if a string domain reference corresponds to a field value
+ * in the evaluation context, and if so, uses that field's value as the domain.
+ */
+
+// Store original evaluateExpr function for fallback
+const originalEvaluateExpr = evaluateExpr;
+
+/**
+ * Enhanced domain evaluation that supports field-based domains
+ *
+ * @param {string|Object} expr - The expression to evaluate
+ * @param {Object} context - The evaluation context
+ * @returns {Array} The evaluated domain array
+ */
+function evaluateDomainWithFieldSupport(expr, context = {}) {
+ // If expr is a string and exists as a field in context, use its value
+ if (typeof expr === "string" && expr in context) {
+ try {
+ const fieldValue = context[expr];
+ if (typeof fieldValue === "string") {
+ // Try to parse as JSON domain
+ try {
+ return JSON.parse(fieldValue);
+ } catch (e) {
+ // If not valid JSON, treat as Python expression
+ return originalEvaluateExpr(fieldValue, context);
+ }
+ } else if (Array.isArray(fieldValue)) {
+ return fieldValue;
+ }
+ } catch (error) {
+ console.warn("Failed to evaluate field domain:", expr, error);
+ }
+ }
+
+ // Fallback to original evaluation
+ return originalEvaluateExpr(expr, context);
+}
+
+/**
+ * Patch the core domain evaluation system
+ * This allows domains to reference field values directly
+ */
+patch(evaluateExpr, {
+ /**
+ * Override the core evaluateExpr to support field-based domains
+ */
+ evaluateExpr(expr, context = {}) {
+ // Handle domain evaluation specifically
+ if (typeof expr === "object" && expr.__ref === "domain") {
+ return evaluateDomainWithFieldSupport(expr.__debug || expr.__value, context);
+ }
+
+ // For compound domains, process each part
+ if (typeof expr === "object" && expr.__ref === "compound_domain") {
+ const domains = expr.__domains || [];
+ const result = [];
+
+ for (const domain of domains) {
+ if (typeof domain === "string") {
+ // Check if this string references a field in context
+ const evaluated = evaluateDomainWithFieldSupport(domain, context);
+ result.push(...(Array.isArray(evaluated) ? evaluated : []));
+ } else {
+ // Process normally
+ const evaluated = this._super(domain, context);
+ result.push(...(Array.isArray(evaluated) ? evaluated : []));
+ }
+ }
+
+ return result;
+ }
+
+ // Default to original behavior for non-domain expressions
+ return this._super(expr, context);
+ }
+});
+
+/**
+ * Export the enhanced evaluation function for external use
+ */
+export { evaluateDomainWithFieldSupport };
\ No newline at end of file