Skip to main content
Many2x Widget Options — A build-to-order Odoo module that gives you fine-grained control over the create, edit, and search op — 1/1Illustrative preview

A build-to-order Odoo module that gives you fine-grained control over the create,

edit, and search options on many2one and many2many relational fields — configured per field, per view, without patching core.

ECOSIRE scopes, builds, installs, and supports it for your database.

What is Many2x Widget Options?

A build-to-order Odoo module that gives you fine-grained control over the create, edit, and search options on many2one and many2many relational fields — configured per field, per view, without patching core. ECOSIRE scopes, builds, installs, and supports it for your 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

Per-field toggles for create, "create and edit", inline edit, delete, and search-more (dialog) on many2one and many2many widgets
Uniform `options` contract in XML views honored identically by list, form, and kanban renderers
Optional admin-configurable model (linked to `ir.model.fields`) so functional admins govern behavior without editing views
OWL/JS extension of the web client relational components via the `web.assets_backend` bundle — no core fork, upgrade-safe
Support for many2one, many2one_avatar, many2many, many2many_tags, and many2many checkbox widget families
Role-aware behavior driven by security groups (`base.group_user` and custom groups) and record context
Domain-conditional options so a field can allow inline create in one state and lock to a picker in another
Optional server-side enforcement via `@api.constrains` and access rules so intent cannot be bypassed through XML-RPC/JSON-RPC
Configurable default `search_more` (Search dialog) limit and quick-create field mapping per relational field
`ir.model.access.csv` and record rules securing the configuration model itself
Consistent behavior across Community and Enterprise on Odoo 17.0, 18.0, and 19.0
Optional company-scoped configuration for multi-company databases
Clean uninstall path — removing the module restores stock widget behavior with no orphaned data
Automated-test coverage (Python + JS/tours) for the configured fields as part of UAT sign-off

Built to order, done for you

No DIY setup — a working app, built, installed and supported by ECOSIRE.

  1. 1

    You order

    Start with a one-time build price. We scope it with you at kickoff.

  2. 2

    We build & install

    ECOSIRE builds, configures and installs it on your Odoo.

  3. 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

Anyone who manages an Odoo relational field knows the friction. On a many2one like partner_id or product_id, the dropdown always offers "Create", "Create and edit…", and inline editing — even when your data-entry team should only ever pick from an approved, controlled list. Elsewhere it is the reverse: you want a fast create affordance on a many2many tags field, but the default widget behavior fights you. Out of the box, these behaviors are baked into the web client's relational widgets, and toggling them field by field means either living with the defaults or writing bespoke OWL/JS overrides for every view. That is exactly where Odoo native runs out of road: options="{'no_create': True}" and its siblings exist, but they are scattered, inconsistent across widget variants, ungoverned, and give administrators no coherent way to reason about which fields expose which actions.

This is a made-to-order module that ECOSIRE builds for your database. It introduces a consistent, declarative layer over the standard many2one and many2many widgets so that create, "create and edit", inline edit, delete, and search-more (dialog) options can be switched on or off precisely where you need them. We deliver two complementary control surfaces: a clean, uniform options contract your developers set in XML views (honored identically by the list, form, and kanban renderers), and an optional per-field administrative configuration model (ir.model.fields-linked records with ir.model.access.csv and record rules) so that functional admins can govern behavior without editing views. Technically, we extend the web client's relational field components (OWL/JS assets registered through the web.assets_backend bundle in __manifest__.py) rather than forking them, so upgrades stay clean and the standard field APIs continue to work underneath.

Behavior can be made conditional and data-aware. Because the configuration is model-backed, options can respond to the record context, the user's groups (base.group_user, custom security groups), or a domain — for example, allowing inline creation of a contact only for back-office roles while presenting a locked picker to portal or shop-floor users. Where you need server-side guarantees rather than UI hints, we pair the widget controls with ORM-level @api.constrains or access rules so that a determined user cannot bypass the intent through the XML-RPC/JSON-RPC API. The module targets the standard many2one, many2one_avatar, many2many, many2many_tags, and many2many-checkbox widget families, and is validated against Community and Enterprise on Odoo 17.0, 18.0, and 19.0.

Delivery is build-to-order. After a short scoping call we confirm the exact fields, views, roles, and behaviors in a written scope, then build against a copy of your database, run UAT on a staging instance, and deploy with a rollback plan. Typical delivery is one working week from confirmed scope, depending on how many fields and conditional rules are in play and whether Enterprise-only widgets are involved. Pricing starts from $999 (indicative, single-company base scope); wider field coverage, conditional/role-based rules, multi-company deployment, and server-side enforcement across custom models increase the quoted scope.

What you get

  • Installable source code for your version, pinned to your Odoo edition (Community/Enterprise) and 17.0/18.0/19.0 series
  • Installation and configuration on your staging instance, then production deployment
  • Technical documentation: module architecture, the `options` contract, and configuration model reference
  • End-user / admin guide plus a live training session for your team
  • UAT on a staging copy with a documented rollback plan before go-live
  • Post-go-live support window for defect fixes and configuration adjustments
  • Git repository handover with full commit history and tagged release
  • Automated test suite (Python unit tests + JS/tour tests) covering the configured fields

Who this is for

Odoo functional consultant / implementer

Configures many customer databases and is tired of hand-writing widget overrides per project. Wants a governed, reusable way to lock down or open up relational fields that survives upgrades across 17/18/19.

Internal Odoo administrator

Owns data quality for a live database and needs to stop staff from creating duplicate partners, products, or tags on the fly — while still allowing trusted back-office roles to create records inline where it speeds work.

ERP / operations manager

Cares about clean master data and controlled onboarding for shop-floor, portal, and junior users. Needs picker-only fields for some roles and full create/edit for others, enforced consistently.

In-house Odoo developer

Wants a clean `options` contract to declare relational-field behavior in XML instead of maintaining bespoke OWL patches, plus optional server-side guarantees against API bypass.

How Many2x Widget Options Compares

CriterionECOSIRECustom BuildCompetitorOdoo Native
Fit to your fields and rolesBuilt to your exact fields, views, and security groups after a scoping callFully bespoke but you specify and manage everythingGeneric toggles; you adapt your setup to its assumptionsOnly the scattered built-in `no_create` / `no_open` style options
Configuration modelXML `options` contract plus optional admin-governed, secured config modelWhatever your developer builds and documentsUsually view attributes only, no governed admin layerPer-view `options` in XML, edited by hand each time
Role / conditional behaviorGroup- and domain-aware rules, different behavior per user role or record statePossible, at bespoke build costTypically static, same behavior for all usersNot supported without custom code
Server-side enforcementOptional `@api.constrains` + access rules so API calls can't bypass intentOnly if you build and test itUI-only; API bypass remains possibleNone from the widget layer
Upgrade safety (17/18/19)Assets-bundle extension, no core fork; migration offeredDepends on how it was written; you own upgradesVaries; may lag new Odoo releasesMoves with core but gives you no added control
Testing & rollbackUAT on staging, automated tests, documented rollback planOnly what you scope inSelf-install; you test it yourselfNot applicable
Support & handoverPost-go-live window, docs, training, Git repo handoverInternal or your contractor's responsibilityVendor forum / ticket support of variable depthCommunity support only
Time to liveone working week from confirmed scope, done for youDepends on internal backlog and skillsFast install, but limited to its fixed feature setImmediate, but no added capability

Frequently Asked Questions about Many2x Widget Options

How long does delivery take?

This is a build-to-order module, not an instant download. After a scoping call we confirm the exact fields, views, and rules in writing, then build, test on staging, and deploy. Typical delivery is one working week from confirmed scope, depending on how many fields and conditional/role-based rules are involved.

How does pricing and scoping work?

Pricing starts from an indicative $999 for a single-company base scope. The final figure is a fixed quote issued after a short scoping call, once we know the number of fields, whether you need conditional or role-based rules, server-side enforcement, and multi-company support. You approve the fixed quote before we build.

What about support and updates?

Every build includes a post-go-live support window for defect fixes and configuration tweaks. Because we extend the web client rather than fork it, the module is upgrade-friendly; we also offer paid support and migration when you move between Odoo 17.0, 18.0, and 19.0 or between Community and Enterprise.

Can this stop users from bypassing the controls through the API?

The widget options govern the web UI. Where you need hard guarantees, we pair them with ORM-level `@api.constrains` and access/record rules so that create or edit intent cannot be bypassed through the XML-RPC/JSON-RPC API. That server-side enforcement is an explicit scope item we confirm during the scoping call.

Does it work on Community and Enterprise, and which Odoo versions?

Yes. We validate against both Community and Enterprise, and build for Odoo 17.0, 18.0, or 19.0 — you tell us your exact edition and series and we pin the delivered code to it. Enterprise-only widget variants are supported where your edition includes them.

Do we get the source code and can we maintain it ourselves?

Yes. You receive the full installable source and a Git repository handover with commit history and a tagged release. There is no license key or runtime lock — your team can read, extend, and maintain the module, and we hand over technical documentation to support that.

Will it interfere with our other custom modules or a future upgrade?

We extend the standard relational field components through the assets bundle rather than overriding core files, which keeps the module upgrade-safe and reduces conflict risk with other addons. Uninstalling cleanly restores stock widget behavior with no orphaned configuration data.

Request a quote

Many2x Widget Options

A build-to-order Odoo module that gives you fine-grained control over the create, edit, and search options on many2one and many2many relational fields — configured per field, per view, without patching core. ECOSIRE scopes, builds, installs, and supports it for your database.

  • Per-field toggles for create, "create and edit", inline edit, delete, and search-more (dialog) on many2one and many2many widgets
  • Uniform `options` contract in XML views honored identically by list, form, and kanban renderers
  • Optional admin-configurable model (linked to `ir.model.fields`) so functional admins govern behavior without editing views
  • OWL/JS extension of the web client relational components via the `web.assets_backend` bundle — no core fork, upgrade-safe

Request a Quotation

Tell us about your Many2x Widget Options requirements and we'll send pricing, licensing options and a tailored proposal — usually within one business day.

No payment now. This sends a quote request to our team — we'll follow up by email with pricing and next steps.