A build-to-order Odoo module that parses your form.io schema and materializes each form and component as a queryable database record. ECOSIRE scopes, builds, installs, and supports it for Odoo 17.0/18.0/19.0. Built to order by ECOSIRE for Odoo 17, 18, 19 — indicative price from $299.00 USD; request a quote for a scoped proposal.

A build-to-order Odoo module that parses your form.io schema and materializes each form and component as a queryable database record. ECOSIRE scopes, builds, installs, and supports it for Odoo 17.0/18.0/19.0.
ابھی کوئی ادائیگی نہیں۔ یہ ہماری ٹیم کو قیمت کی درخواست بھیجتا ہے — ہم قیمت اور اگلے اقدامات کے ساتھ ای میل کے ذریعے رابطہ کریں گے۔
Most teams that embed a form.io builder alongside Odoo hit the same wall: the form definition lives as one opaque JSON blob, either in a char/text field or in an external form.io project. That is fine for rendering, but useless the moment you need to report on it. You cannot ask "which forms contain a required IBAN field", enforce a record rule per component, drive an automated action off a specific input, or version a single question — because to Odoo the whole schema is one unreadable string. Odoo native gives you no ORM surface over the form's internal structure, so every analytics, governance, or integration request turns into brittle JSON parsing in a server action.
Recursive, type-aware schema walker that expands containers, panels, columns, edit-grids and data-grids while preserving parent/child component paths
Parent `forms.form` and child `forms.component` ORM models with One2many/Many2one links, so every component is individually queryable
Idempotent upsert keyed on `(form, component_key)` — re-syncs update changed rows, skip unchanged, and never duplicate
Removed components are archived (active=False) rather than hard-deleted, preserving history and inbound references
Per-component capture of `key`, `type`, `label`, `path`, `required`, `unique`, regex/validation and conditional-display logic
Trigger matrix: sync on write of the source form, on-demand via a header button, and optional scheduled `ir.cron` batch reconciliation
Forms • Components Synchronizer closes that gap by treating the form.io schema as data you own. We build a pair of models — a parent forms.form and a child forms.component (technical names finalized in scoping) — with a synchronizer that walks the schema tree (nested containers, panels, columns, edit-grids, data-grids) and upserts one record per component. Each component row carries its key, type, label, path, validation flags (required, unique, regex), conditional-display logic, and a stable external key so re-syncs are idempotent rather than duplicating. The sync runs on write of the source form (via @api.depends-style triggers or an ir.actions.server hook), on demand from a button, and optionally on a scheduled ir.cron. Because everything is real ORM, you immediately get search/read_group over components, ir.model.access.csv + record rules for who may see which forms, list/form/pivot views over the component catalog, QWeb reports, and full read access over the XML-RPC/JSON-RPC API for downstream systems.
Technically, the connector is defensive by design. Schema traversal is recursive and type-aware, so container-type components are expanded and their children linked back to the parent path — no flattening that loses hierarchy. Re-synchronization diffs against existing rows keyed by (form, component_key): unchanged rows are skipped, changed rows are updated, and removed components are archived (not hard-deleted) so historical records and their references survive. We wrap parsing in guarded error handling that logs malformed nodes to ir.logging instead of aborting the whole sync, and we keep the write path in a single transaction so a partial failure rolls back cleanly. Where you already store form.io JSON on an existing model, we point the synchronizer at that field; where you pull from a form.io API, we add a thin, credential-safe client. The module ships Community-compatible (no Enterprise-only dependencies) unless your scope specifically requires Enterprise widgets, in which case we flag that up front.
Because this is build-to-order, nothing is a shrink-wrapped download. After a short scoping call we confirm your form.io source of truth, the component attributes you actually need as columns, the security model, and any downstream sync targets — then we build against your Odoo version, deliver on staging for UAT, and cut over to production with a rollback plan. Typical delivery is 2-4 weeks from confirmed scope. Pricing starts from $299 (indicative, single-company base scope); multi-company setups, syncing from a live form.io API rather than a stored JSON field, deeper conditional-logic modeling, and historical schema data migration increase the quoted scope. You receive a fixed quote after the scoping call, never a surprise invoice.
A team already collecting data through embedded form.io forms that needs those form structures visible inside Odoo for reporting, access control and workflow — not locked away as JSON.
Owns the Odoo–form.io boundary and needs a reliable, idempotent sync that exposes each component over XML-RPC/JSON-RPC so downstream BI and middleware can consume field-level data.
Must enforce who can see which forms and prove which fields are required or validated; needs record rules and audit-ready pivot views over the component catalog, not a manual JSON review.
Wants a clean, documented model layer to build on instead of parsing schema blobs in ad-hoc server actions, with a Git handover so the team can maintain and extend it.
Buy the license on ecosire.com and download the Forms • Components Synchronizer module ZIP from your account dashboard.
Extract the ZIP into your Odoo custom addons folder on the server (or upload via Apps > Install from file on Odoo.sh / runbot).
Activate Developer Mode, open Apps, click Update Apps List, search for Forms • Components Synchronizer, and press Install.
Open the new menu, paste your ECOSIRE license key, connect any external credentials (Shopify, Amazon, Stripe, etc.), and save.
Run the built-in connection test, sync your first 10 records, and schedule the recurring cron. Contact support if anything fails.
| Criterion | ECOSIRE | Custom Build | Competitor | Odoo Native |
|---|---|---|---|---|
| Component-level data model | One ORM record per component, fully queryable | Possible, but you design and build the schema yourself | Usually stores the whole form as one JSON blob | |
| Re-sync behavior | Idempotent upsert; archives removed components | Depends entirely on your implementation quality | Often re-imports and risks duplicates | |
| Security granularity | `ir.model.access.csv` + record rules per form/component | You must implement and test all rules | Typically coarse, form-level at best | |
| Reporting & analytics | Pivot/`read_group` + QWeb over components | Requires custom views and report builds | Limited; JSON is hard to aggregate | |
| API exposure | Full XML-RPC/JSON-RPC on every component | Available if you model it as records first | Exposes the blob, not the fields | |
| Odoo version fit | Built for your 17.0 / 18.0 / 19.0, Community-safe | Whatever you target and maintain | Fixed to the vendor's supported versions | |
| Fit to your form.io source | Bound to your stored field or API in scope | Fully bespoke but slower and costlier | Generic; may not match your setup | |
| Ownership & handover | Git repo, docs, training, support window | You own it but carry all the build risk | Vendor-owned; limited source access |
No. This is a build-to-order module. ECOSIRE scopes, builds, installs and supports it against your specific form.io source and your Odoo version. There is no instant download — you receive tested, installable source code delivered for your environment.
Typical delivery is 2-4 weeks from confirmed scope. The clock starts once we have agreed your form.io source of truth, the component attributes to capture, the security model, and any downstream sync targets on the scoping call. Larger scope (multi-company, API sync, data migration) can extend that, and we tell you the timeline in your fixed quote.
Pricing starts from $299 as an indicative single-company base figure. After a short scoping call we send a fixed, written quote — no open-ended billing. Drivers that raise the quote include multi-company deployment, syncing from a live form.io API instead of a stored JSON field, deeper conditional-logic modeling, and migrating historical schema data.
Every build includes a post-go-live support window for defect fixes and configuration adjustments. You also receive the Git repository, so your own developers can maintain it. Version upgrades (for example carrying the module to a newer Odoo release) or new capabilities are quoted as a separate, small engagement.
No. The synchronizer upserts on a stable `(form, component_key)` key: unchanged components are skipped, changed ones are updated in place, and components removed from the schema are archived rather than deleted, so history and inbound references survive. Re-running the sync is safe and idempotent.
The base module is built to run on Odoo Community with no Enterprise-only dependencies, on Odoo 17.0, 18.0 or 19.0. If your scope specifically calls for an Enterprise-only widget or feature, we flag that during scoping so there are no surprises at install time.
Yes. Because every form and component is a native ORM record, they are fully available over Odoo's XML-RPC and JSON-RPC API, and through standard views, `read_group` pivots and QWeb reports — subject to the `ir.model.access.csv` rights and record rules we configure for your team.
A build-to-order Odoo module that parses your form.io schema and materializes each form and component as a queryable database record. ECOSIRE scopes, builds, installs, and supports it for Odoo 17.0/18.0/19.0.