- Home
- Apps
- SaaS Tools
- Sale Order Payment Status
Illustrative previewA made-to-order Odoo module that surfaces live payment status,
paid/due amounts, and linked transactions directly on the sale order — no digging through the accounting back office.
ECOSIRE builds, installs, and supports it for your Odoo 17/18/19.
What is Sale Order Payment Status?
A made-to-order Odoo module that surfaces live payment status, paid/due amounts, and linked transactions directly on the sale order — no digging through the accounting back office. ECOSIRE builds, installs, and supports it for your Odoo 17/18/19. 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
Sales reps and order-desk teams lose time every day answering one question: "has this order actually been paid?" In native Odoo the answer lives one or two clicks away — you open the sale order, jump to the related invoice, then to the payments, and reconcile in your head across down payments, partial settlements, and credit notes. The sale.order form exposes an invoice_status field ("to invoice", "invoiced", "nothing to invoice"), but that describes invoicing progress, not money received. There is no core field on the order that tells you at a glance that a customer paid 60% up front and still owes the balance. That gap is where goods get released against unpaid orders and where finance and sales end up maintaining two different versions of the truth.
We build a made-to-order module that pulls the payment picture back onto the sale order where the people who need it actually work. Technically it adds computed, stored fields to sale.order — for example payment_state (a Selection mirroring the standard not_paid / partial / in_payment / paid / reversed values), amount_paid, amount_residual (due), and a payment_percentage — driven by @api.depends compute methods that walk the order's invoice_ids, their own payment_state, and the reconciled account.payment / account.move.line records. Because the fields are stored, they are filterable and groupable in list views, usable in search domains, and available to reports and the XML-RPC/JSON-RPC API. Recomputation is triggered cleanly off invoice and payment changes so the status stays accurate without a manual refresh.
On the UI side we extend the sale order form (XML view inheritance, or an OWL widget where a richer visual is wanted) to show a colour-coded status badge in the header, a paid-versus-due summary, and an embedded list of the linked payments with date, journal, method, and amount. The order list view gets an optional payment_state column and a set of filters ("Fully Paid", "Partially Paid", "Unpaid") plus a group-by so a rep can slice their pipeline by cash position in one click. Access is governed by ir.model.access.csv and, where you need reps to see only their own teams' figures, record rules — so the payment data respects the same visibility model as the rest of your Odoo. Optional add-ons we scope on request include a QWeb payment-status stamp on the order/quotation PDF, an automated action or server action that flags orders unpaid past a threshold, and a colour decoration on the kanban card.
Because this is built to order, nothing ships until we agree the scope. After a short scoping call we confirm exactly which fields, filters, views, and any automation or reporting you need, then hand back an installable module targeting your specific Odoo edition and version (Community or Enterprise, 17.0 / 18.0 / 19.0), tested on a staging copy of your database before it touches production. Typical delivery is one working week from confirmed scope. Pricing starts from $999 (indicative, single-company base scope); multi-company payment consolidation, deeper multi-currency handling, extra automation or reporting, and integration with non-standard payment/reconciliation flows increase the quoted scope.
What you get
- Installable, version-pinned module source code for your Odoo edition and version (17.0 / 18.0 / 19.0)
- Installation and configuration on your environment, including access-rule and record-rule setup
- Technical documentation: model fields, compute dependencies, view inheritance points, and security rules
- End-user guide plus a live training session for your sales and finance teams
- UAT on a staging copy of your database with a documented rollback plan before production
- A defined post-go-live support window for fixes and questions
- Git repository handover with full commit history and tagged release
- Manifest (`__manifest__.py`) and dependency notes so future upgrades are traceable
Who this is for
Sales Manager / Order Desk Lead
Needs to see cash position across the pipeline without asking finance. Wants list filters and a group-by on payment state so the team can prioritise fulfilment and follow-ups by who has actually paid.
Finance / AR Controller
Owns the payment truth and wants sales looking at the same numbers. Values that the fields compute from real reconciled `account.payment` records rather than a manually maintained flag, keeping AR and sales aligned.
Odoo Administrator / Internal IT
Responsible for the instance and its upgrades. Wants a clean, version-pinned module with documented fields, proper `ir.model.access.csv` security, and a git handover — not a black-box customisation that breaks on the next migration.
Operations / Fulfilment Coordinator
Releases goods and schedules delivery. Needs an unambiguous unpaid/partially-paid signal on the order itself to avoid shipping against orders that are not yet settled.
How Sale Order Payment Status Compares
| Criterion | ECOSIRE | Custom Build | Competitor | Odoo Native |
|---|---|---|---|---|
| Fit to your workflow | Built to your confirmed scope, fields and filters match how your team works | Fully bespoke but you specify and manage everything | Generic feature set, take it as shipped | Payment lives in accounting, not on the order |
| Payment status on the sale order | Stored `payment_state` + paid/due badge directly on the order | Possible, depends on your developer's design | Usually a basic status field | Only `invoice_status` (invoicing, not money received) |
| Accuracy source | Computes from reconciled `account.payment` / move lines via `@api.depends` | However it is coded and maintained | Often a lighter compute, varies by vendor | Accurate in accounting, not surfaced on the order |
| Version & edition targeting | Pinned and tested for your 17/18/19, Community or Enterprise | Whatever you build for | Depends on the listing's supported versions | Built in, no targeting needed |
| Security model | `ir.model.access.csv` + optional record rules for team-scoped visibility | Only if you build it in | Baseline access rules, rarely team-scoped | Standard Odoo access rules |
| Delivery time | one working week from confirmed scope | Weeks to months depending on hiring and specs | Instant install, but generic | Already present, but not on the order |
| Support & handover | Support window, docs, training, full git repo handover | Depends on your team's retention | Vendor support tickets, no source ownership | Covered by your Odoo support/partner |
| Cost model | Indicative from $999, fixed quote after scoping | Developer time, often the most expensive | Low per-listing licence fee | No extra cost, but the gap remains |
Frequently Asked Questions about Sale Order Payment Status
Is this a ready-made module I can download and install today?
No. This is a build-to-order productized service. We build the module to your confirmed scope and target it precisely to your Odoo edition and version, then install and support it. There is no instant download — the value is that it fits your data model, security rules, and workflow rather than being a generic drop-in.
How long does delivery take?
Typical delivery is one working week from confirmed scope. After the scoping call we agree the fields, views, filters, and any automation or reporting, then build and test on a staging copy of your database before go-live. Tight, single-company base scopes land at the shorter end; multi-company or heavier automation extends it.
How does pricing and scoping work?
Pricing starts from $999 as an indicative from-price for a single-company base scope. We confirm requirements on a short scoping call and then send a fixed written quote — no surprises. Drivers such as multi-company consolidation, deeper multi-currency handling, extra automation, custom reporting, or unusual payment/reconciliation flows increase the quoted scope.
Which Odoo versions and editions do you support?
We build for Odoo 17.0, 18.0, and 19.0, on both Community and Enterprise. The module is pinned to your specific version in its `__manifest__.py` and tested against that target. If you run a customised or hosted instance (Odoo.sh, on-prem, or a partner host), we account for that during scoping.
What about support and future updates?
Every engagement includes a defined post-go-live support window for fixes and questions. Because you receive the full git repository and technical docs, your own team can maintain it too. When you upgrade Odoo to a new major version, we can quote a migration pass to re-target and re-test the module against the new release.
Will it stay accurate as invoices and payments change?
Yes. The status fields are computed with `@api.depends` off the order's invoices and their reconciled payments, and recomputation is triggered when those records change — so a partial payment, a new down payment, or a credit note updates the sale order's paid/due figures without any manual refresh.
Can we get payment status on the order PDF or trigger alerts?
Both are optional add-ons we scope on request. We can extend the QWeb quotation/order report to stamp payment status and paid/due totals, and add an automated action or server action to flag or notify on orders left unpaid past a threshold you define. These affect the quoted scope but are common requests.
Related Modules

Sale Invoice – Exclude Salesperson
A build-to-order Odoo module that prevents the salesperson linked to a sales order or customer from being automatically subscribed as a follower on the resulting invoice. ECOSIRE scopes, builds, installs, and supports it for your Odoo 17.0, 18.0, or 19.0 instance.

Sale Order Automation
A build-to-order Odoo module that turns order confirmation into a fully automated hand-off: it auto-creates the customer invoice, validates it, and processes the delivery transfer. ECOSIRE scopes, builds, installs, and supports it for your specific sales flow.

Sales Contract and Recurring Invoices
A build-to-order Odoo module that turns signed sales contracts into automatically generated recurring invoices on the billing cadence and terms each agreement defines. ECOSIRE designs, builds, installs, and supports it for your Odoo 17/18/19 instance.

Salesforce CRM Connector for Odoo
Build-to-order Odoo module to migrate and two-way sync Salesforce leads, accounts and opportunities with Odoo CRM.
Sale Order Payment Status
A made-to-order Odoo module that surfaces live payment status, paid/due amounts, and linked transactions directly on the sale order — no digging through the accounting back office. ECOSIRE builds, installs, and supports it for your Odoo 17/18/19.
- Adds a stored, computed `payment_state` Selection field on `sale.order` mirroring Odoo's `not_paid` / `partial` / `in_payment` / `paid` / `reversed` states
- Computes `amount_paid`, `amount_residual` (due), and `payment_percentage` via `@api.depends` methods walking `invoice_ids` and their reconciled `account.payment` / `account.move.line` records
- Correct handling of down payments, partial settlements, and credit notes so the paid/due figures reconcile to the accounting truth
- Colour-coded payment status badge rendered in the sale order form header via XML view inheritance (or an OWL widget for a richer visual)