- Home
- Apps
- SaaS Tools
- Advanced Web Domain Widget
Illustrative previewA build-to-order Odoo widget that lets non-technical users compose dynamic filters across relational
(`Many2one`/`Many2many`) fields using simplified, human-readable operators.
ECOSIRE scopes, builds, installs, and supports it for your Odoo 17/18/19 database.
What is Advanced Web Domain Widget?
A build-to-order Odoo widget that lets non-technical users compose dynamic filters across relational (`Many2one`/`Many2many`) fields using simplified, human-readable operators. ECOSIRE scopes, builds, installs, and supports it for your Odoo 17/18/19 database. Built to order by ECOSIRE for Odoo 17, 18, 19 — indicative price from $999.00 USD; request a quote for a scoped proposal.
Key Features
Built to order, done for you
No DIY setup — a working app, built, installed and supported by ECOSIRE.
- 1
You order
Start with a one-time build price. We scope it with you at kickoff.
- 2
We build & install
ECOSIRE builds, configures and installs it on your Odoo.
- 3
Go live + support
You go live in about one working week, with two weeks of go-live support. Defects in the code we deliver are fixed free of charge.
Technical Specifications
- Odoo Compatibility
- Odoo 17, Odoo 18, Odoo 19
- Editions
- Enterprise & Community
- License
- Licence confirmation required
- Python Requirement
- Python 3.10+
- Database
- PostgreSQL 12+
About this Product
Every Odoo administrator eventually hits the wall of the native domain editor. Building a filter that spans relational fields — "show partners whose sales orders contain products in these categories" — means hand-writing a Polish-notation domain like ['&', ('order_line.product_id.categ_id', 'in', ids), ...] inside a Developer-mode text box, where one misplaced bracket or '|' silently breaks the record set. Business users can't touch it, functional consultants dread it, and dynamic filters that should adapt to the logged-in user, the current company, or a related record simply aren't expressible through the standard UI. The result is a proliferation of hard-coded server actions and one-off ir.filters that nobody dares to edit.
The Advanced Web Domain Widget is a made-to-order OWL field widget and Python domain-compiler that ECOSIRE builds for your database. It replaces the raw domain textarea with a guided, condition-by-condition builder that walks relational paths — following Many2one and Many2many chains as far as you configure — and exposes simplified operators (contains, is any of, is empty, in the last N days, is set by current user) that compile down to valid, safe Odoo domain tuples. Under the hood it is a proper Odoo module: a models.Model mixin that stores and validates domains, a fields.Char/fields.Json domain column with an @api.constrains guard that rejects malformed expressions before they ever reach the ORM, an OWL component registered in the web assets bundle, and server-side evaluation that honours record rules and ir.model.access.csv so a user can never craft a filter that leaks records they aren't entitled to see. Dynamic context values (uid, company_id, context_today) are injected at evaluation time rather than baked into the stored domain, so one saved filter behaves correctly for every user and every company.
Because it is your module, we shape it to your models and your workflows. We can wire the widget into any view (search panels, wizard fields, automated-action trigger conditions, report filters), cap relational traversal depth for performance, expose or hide operators per user group, and add domain presets that map to your business vocabulary. It works identically across Community and Enterprise — no Enterprise-only dependency — and is delivered targeting your exact Odoo series (17.0, 18.0, or 19.0) with the OWL and asset-bundle conventions of that version. Optionally we expose the compiled domains over the XML-RPC/JSON-RPC API so external tools and integrations can reuse the same saved filters rather than re-implementing your filtering logic.
Delivery is build-to-order: nothing ships until we agree on scope. We start with a short scoping call, produce a fixed written specification and quote, build against a copy of your database, run UAT on a staging instance, and only then install on production with a documented rollback path. Typical delivery is one working week from confirmed scope, depending on how many models and views the widget must cover. Pricing starts from $999 (indicative, single-company base scope); additional target models, deeper relational traversal, multi-company evaluation rules, or integration of the compiled domains into external systems via the API increase the quoted scope.
What you get
- Installable source code for your version of the module (`__manifest__.py`, models, OWL components, security, views)
- Installation and configuration on your target Odoo 17/18/19 instance
- Technical documentation covering models, the domain-compiler API, and extension points
- End-user guide plus a live training session for your team
- Post-go-live support window for defect fixes and questions
- UAT on a staging copy of your database with a documented rollback plan
- Git repository handover with full commit history and tagged release
- Security review notes covering record-rule and access-rights interaction
Who this is for
Odoo functional consultant
Configures filters, automated actions, and reports for clients and is tired of hand-writing brittle Polish-notation domains. Wants a guided builder they can hand to business users without exposing Developer mode.
In-house Odoo administrator
Maintains a live database for their company and needs dynamic, user- and company-aware filters that behave correctly for everyone from one saved definition, without cloning server actions per team.
Operations or sales manager
A power user who needs to build cross-relational segments (partners by order history, products by category chains) themselves, using plain-language operators rather than technical domain syntax.
Systems integrator / developer
Wants compiled, validated domains exposed over XML-RPC/JSON-RPC so external tools reuse the same filtering logic instead of re-implementing it, with a clean extension point in a version-correct module.
How Advanced Web Domain Widget Compares
| Criterion | ECOSIRE | Custom Build | Competitor | Odoo Native |
|---|---|---|---|---|
| Delivery model | Built, installed, and supported for your database in one working week | You hire and manage developers; timeline and quality vary | Instant download, but generic and unsupported for your models | Available today, but only the raw domain textarea |
| Filter building experience | Guided visual builder with plain-language operators | Whatever your team has time to build | Usually a partial UI over standard domains | Hand-written Polish-notation in Developer mode |
| Relational path traversal | Configurable `Many2one`/`Many2many` chains with depth caps | Depends on developer effort and testing | Often limited to one or two relation levels | Manual dotted paths, no guidance or validation |
| Dynamic context (user/company/date) | Injected at evaluation time from one saved filter | Custom code per case, easy to get wrong | Rarely supported cleanly | Not expressible without server actions |
| Security awareness | Honours record rules and `ir.model.access.csv`; per-group operators | Only as safe as your review process | Generic; may bypass your access model | Enforced by ORM but no guardrails in the editor |
| Fit to your models | Scoped to your exact models, views, and vocabulary | Fully custom but you own all the risk | One-size-fits-all, not tailored | None — you adapt to Odoo, not the reverse |
| Odoo version targeting | Built for your 17.0 / 18.0 / 19.0, Community or Enterprise | Depends on developer familiarity with the series | May lag new releases or need paid upgrades | Ships with core; behaviour varies by version |
| Ownership and support | Full source, git handover, defined support window | You own it and all its maintenance | Vendor-controlled; support quality varies | Community/Enterprise support, no customization |
Frequently Asked Questions about Advanced Web Domain Widget
Is this an existing app I can download and install right now?
No. This is a build-to-order module. ECOSIRE builds, installs, and supports it for your specific database after we agree on scope — there is no instant download. You receive installable source code for your version once it is built and tested.
How long does delivery take?
Typically one working week from confirmed scope. The timeline depends on how many models and views the widget must cover and the depth of relational traversal you need. We give you a firm delivery date in the written quote after the scoping call.
How does pricing and scoping work?
Pricing starts from $999 as an indicative single-company base scope. After a short scoping call we produce a fixed written specification and a firm quote. Additional target models, deeper relational traversal, multi-company evaluation, or API integration increase the quoted scope — but the price you approve is fixed before we build.
What about support and future updates?
Every build includes a post-go-live support window for defect fixes and questions. Because you receive the full source and git repository, you can maintain it yourself or engage us for version upgrades and enhancements. We can quote a migration when you move to a newer Odoo series.
Does it work on Odoo Community, or only Enterprise?
Both. The widget has no Enterprise-only dependency — it is a standard OWL widget plus a Python domain-compiler that works identically on Community and Enterprise, targeting Odoo 17.0, 18.0, or 19.0.
Can business users build filters without breaking security?
Yes. Evaluation runs through the standard ORM, so record rules and `ir.model.access.csv` still apply — a user can never craft a filter that returns records they aren't allowed to see. You also control which operators and target models each `res.groups` group can use.
Can the filters be reused by external systems?
Optionally, yes. We can expose the compiled, validated domains over the XML-RPC/JSON-RPC API so integrations and external tools reuse your saved filters instead of re-implementing the logic. This is an add-on scope item quoted after the scoping call.
Related Modules

Advanced Sales Reports
A build-to-order Odoo sales reporting engine that ECOSIRE designs, builds, installs, and supports for you — going beyond the standard pivot views with the metrics, groupings, and export formats your team actually reports on. Request a quotation and we build it to your confirmed scope.

Advance Salary Management for Odoo HR
A build-to-order Odoo module that lets employees request salary advances, routes them through a configurable approval chain, and recovers the balance automatically through payslip deductions. ECOSIRE designs, builds, installs, and supports it around your policy — it is not an off-the-shelf download.

Adyen Unified Gateway for Odoo
Enterprise Adyen acquiring for Odoo 17/18/19: cards, 100+ local methods, 3DS2/SCA, HMAC webhook reconciliation. Built to order by ECOSIRE.
Advanced Web Domain Widget
A build-to-order Odoo widget that lets non-technical users compose dynamic filters across relational (`Many2one`/`Many2many`) fields using simplified, human-readable operators. ECOSIRE scopes, builds, installs, and supports it for your Odoo 17/18/19 database.
- OWL field widget that replaces the raw domain textarea with a condition-by-condition visual builder registered in the `web` assets bundle
- Relational path navigation that follows `Many2one` and `Many2many` chains (e.g. `order_line.product_id.categ_id`) with configurable maximum traversal depth
- Simplified human-readable operators (`contains`, `is any of`, `is empty`, `in the last N days`, `is set by current user`) that compile to valid Odoo domain tuples
- Server-side `@api.constrains` validator that rejects malformed or unbalanced domains before they reach the ORM
