A build-to-order Odoo module that turns rejects, returns, and rework into structured unbuild/disassembly orders — recovering components back to stock with defined salvage yields, preserved lot/serial traceability, and correct recovered-component valuation. ECOSIRE scopes, builds, installs, and supports it on your Odoo 17/18/19. Built to order by ECOSIRE for Odoo 17, 18, 19 — indicative price from $99.00 USD; request a quote for a scoped proposal.

A build-to-order Odoo module that turns rejects, returns, and rework into structured unbuild/disassembly orders — recovering components back to stock with defined salvage yields, preserved lot/serial traceability, and correct recovered-component valuation. ECOSIRE scopes, builds, installs, and supports it on your Odoo 17/18/19.
现在无需付款。此操作会向我们的团队发送报价请求——我们会通过邮件跟进价格和后续步骤。
Every plant accumulates value it can't sell: quality-failed finished goods, customer returns, superseded assemblies, and rework candidates sitting in a quarantine bin. Odoo's native mrp.unbuild order does exist, but it is deliberately simple — it consumes one finished product and returns the exact BOM component quantities to stock, with no concept of partial recovery, scrap-versus-salvage split, per-component yield, condition grading, or the fact that a disassembled unit rarely gives back 100% of its bill of materials. Teams end up doing the recovery math in spreadsheets, manually creating inventory adjustments, and losing the lot/serial thread between the parent unit and the parts pulled out of it. That breaks traceability and quietly distorts inventory valuation.
Extends Odoo's native `mrp.unbuild` (or a governed `ecosire.salvage.order` model) to support partial and graded recovery instead of a fixed BOM explosion
Per-BOM-line salvage yield definition — declare expected recovery percentage and quantity for each component of the parent unit
Condition/disposition routing per component: reuse-to-stock, send-to-rework, scrap, or warranty-return, each with its own destination `stock.location`
Recovered-component valuation via `compute`/`@api.depends` from the parent's inventory cost, posting through standard or AVCO valuation so stock and COGS stay accurate
Lot/serial preservation — disassembly `stock.move.line` records link each recovered part's lot/serial back to the parent unit's serial for intact upstream/downstream traceability
Rework-loop integration: a failed unit's salvage order can spawn a manufacturing or repair order that consumes the recovered components
ECOSIRE builds a dedicated Unbuild, Disassembly & Salvage layer on top of Odoo's manufacturing core. We extend mrp.unbuild (or introduce a governed ecosire.salvage.order model where a cleaner separation is warranted) with per-BOM-line salvage definitions: for each component you declare an expected recovery yield, a condition/disposition (reuse, rework, scrap, warranty-return), and a destination location. A compute/@api.depends layer derives recoverable quantities and recovered value from the parent unit's inventory cost and your yield rules, so the stock moves that get generated reflect what actually came off the line — not an idealized BOM explosion. Lot and serial numbers are preserved on disassembly: the module writes stock-move lines that link each recovered component's lot/serial back to the parent's serial, so stock.lot traceability (upstream and downstream) stays intact and auditable. When a unit fails quality, the order can spawn a rework loop that feeds the salvaged components straight into a new manufacturing or repair order rather than back to raw stock.
Technically, the module ships as a proper Odoo addon: a versioned __manifest__.py declaring dependencies on mrp, stock, and quality (Enterprise) or a Community-safe fallback; new models.Model classes with fields, compute methods, and constraints; access control via ir.model.access.csv plus record rules for multi-company and warehouse-level isolation; backend list/form/kanban views in XML with OWL components for the salvage-yield editor; a QWeb "Disassembly & Recovery" report showing recovered components, condition, and revalued cost; and optional automated actions (e.g., auto-create a salvage order when a quality.check fails). Everything is reachable over the standard XML-RPC / JSON-RPC API, so WMS, PLM, or reverse-logistics systems can create and read salvage orders programmatically. Recovered-component valuation posts correctly through Odoo's inventory valuation (standard or AVCO), so your stock and COGS reflect reclaimed value.
Because this is build-to-order, nothing is a shrink-wrapped download. We start with a short scoping call, confirm your BOM structure, valuation method (Community vs Enterprise differences matter here), quality workflow, and Odoo version (17.0, 18.0, or 19.0), then write a fixed-scope specification. We build against a copy of your configuration, run UAT on a staging database, and hand over installable source, documentation, and a git repository. Typical delivery is 2–4 weeks from confirmed scope, followed by a post-go-live support window. You own the code.
Runs the reject/rework floor and needs failed and returned units turned into structured disassembly orders so recovered components flow back to stock predictably instead of via spreadsheets and manual inventory adjustments.
Wants a quality failure to automatically trigger a salvage/disassembly decision, with each recovered component graded for reuse, rework, or scrap, and full lot/serial traceability preserved for audits and warranty claims.
Needs recovered components to post at correct value through Odoo's inventory valuation so reclaimed stock and COGS are accurate, and needs the disassembly report to reconcile what was consumed against what was recovered.
Handles customer returns and superseded assemblies and needs to create and query salvage orders over the XML-RPC/JSON-RPC API from the returns or WMS system, routing parts to reuse, rework, or warranty-return locations.
在 ecosire.com 上购买许可证并从您的帐户仪表板下载 Unbuild, Disassembly & Salvage Orders 模块 ZIP。
将 ZIP 解压到服务器上的 Odoo 自定义插件文件夹中(或通过“应用程序”>“从 Odoo.sh / runbot 上的文件安装”上传)。
激活开发者模式,打开应用程序,单击更新应用程序列表,搜索 Unbuild, Disassembly & Salvage Orders,然后按安装。
打开新菜单,粘贴您的 ECOSIRE 许可证密钥,连接任何外部凭据(Shopify、Amazon、Stripe 等),然后保存。
运行内置连接测试,同步前 10 条记录,并安排定期 cron。如果出现任何问题,请联系支持人员。
| 标准 | 伊科西尔 | 定制建造 | 竞争对手 | 奥杜本机 |
|---|---|---|---|---|
| Partial / graded recovery | Per-BOM-line yield %, condition and disposition per component | Whatever you spec and can build in-house | Rarely — most stop at fixed BOM return | |
| Lot/serial preservation on disassembly | Recovered parts linked back to parent serial, traceability intact | Possible but easy to get wrong without deep MRP knowledge | Inconsistent; often breaks the parent link | |
| Recovered-component valuation | Revalued via `compute` through standard/AVCO, posts to COGS/stock | Depends on your accounting expertise | Usually returns at BOM cost, not recovered value | |
| Rework-loop / quality integration | Auto-trigger from failed `quality.check`, spawn rework/repair order | Buildable but significant effort | Seldom integrated with Quality | |
| Fit to your BOMs & process | Scoped to your BOM structure, valuation and workflow | Fully tailored — you own the effort | Generic; you adapt to its assumptions | |
| Delivery model | Build-to-order, 2–4 weeks, UAT on staging + rollback | Your timeline and internal capacity | Instant install, then you fill the gaps | |
| Source & ownership | Full source + git repo handover, you own it | You own it | Vendor-locked, encrypted or licensed | |
| Support & upgrades | Post-go-live window + optional version-upgrade retainer | Your team maintains it | Vendor SLA varies; upgrades often paid |
Native `mrp.unbuild` returns the exact BOM component quantities to stock and nothing more — no partial recovery, no per-component yield, no condition grading, no scrap-vs-salvage split, and no linkage from a quality failure. We add all of that: declared recovery yields per BOM line, disposition routing, preserved lot/serial linkage to the parent unit, recovered-component revaluation, and rework-loop integration.
This is a build-to-order module, not an instant download. Typical delivery is 2–4 weeks from confirmed scope. After a short scoping call we write a fixed-scope specification; once you sign off, we build against a copy of your configuration, run UAT on staging, and hand over the installable source and git repository.
Every engagement includes a post-go-live support window for defect fixes and configuration questions. Because you receive the full source and git repository, you own the code outright. We offer version-upgrade work (e.g., 18.0 to 19.0) and ongoing support as a separate, optional retainer.
Both. The core unbuild/salvage/valuation logic runs on Community. Some features — notably auto-creating a salvage order from a failed `quality.check` — depend on the Enterprise Quality app, so we confirm your edition during scoping and provide a Community-safe fallback (e.g., manual or server-action trigger) where a feature relies on Enterprise-only modules.
Yes. The disassembly stock moves write `stock.move.line` records that link each recovered component's lot/serial back to the parent unit's serial, so Odoo's upstream/downstream traceability on `stock.lot` remains intact and auditable for warranty and compliance.
Yes. The models are exposed over the standard XML-RPC and JSON-RPC API, so your WMS, returns portal, or PLM can create, read, and update salvage/disassembly orders programmatically — for example creating a salvage order the moment a return is booked.
We build and test against Odoo 17.0, 18.0, and 19.0, respecting each release's `mrp` and `stock` API differences. You tell us your target version during scoping and we deliver a version-matched build.
A build-to-order Odoo module that turns rejects, returns, and rework into structured unbuild/disassembly orders — recovering components back to stock with defined salvage yields, preserved lot/serial traceability, and correct recovered-component valuation. ECOSIRE scopes, builds, installs, and supports it on your Odoo 17/18/19.