much. ChannelEngine Integration for Odoo : Product Description
The much. ChannelEngine Integration is a proprietary Odoo module suite developed by much. GmbH that connects Odoo to ChannelEngine — the multichannel commerce platform that centralises sales across marketplaces such as Amazon, Decathlon, Zalando, and others.
The integration handles the full order-to-cash cycle bidirectionally: orders, cancellations, returns, products, stock levels, shipments, and invoices all flow between Odoo and ChannelEngine without manual intervention. It is built on top of the much_order_base_integration framework and follows the same connector-based architecture used across much.'s shop integrations.
Module Overview
The integration is distributed as a set of eight composable modules. Each module is independently installable; only install those that match the required business flows.
| Module | Technical Name | Purpose |
|---|---|---|
| Base Integration | much_order_channelengine_integration | Core connector, API communication, channel & location management, invoice export |
| Order Import | much_order_channelengine_order_import | Pull orders from ChannelEngine into Odoo |
| Order Cancellation Import | much_order_channelengine_order_cancellation_import | Pull cancellation requests from ChannelEngine |
| Order Cancellation Export | much_order_channelengine_order_cancellation_export | Push cancellations from Odoo back to ChannelEngine |
| Order Return Import | much_order_channelengine_order_return_import | Pull return requests from ChannelEngine |
| Product Export | much_order_channelengine_product_export | Push products and their lifecycle changes to ChannelEngine |
| Product Import | much_order_channelengine_product_import | Pull product catalogue from ChannelEngine into Odoo |
| Stock Quant Export | much_order_channelengine_stock_quant_export | Push real-time stock levels and prices to ChannelEngine |
| Shipment Export | much_order_channelengine_stock_picking_export | Notify ChannelEngine of shipments and return receipts |
Key Features
1. Connector & API Communication
The connector (shop.connector) is extended with ChannelEngine-specific fields and behaviour:
- API Key management — separate keys for production and development environments
- Rate-limit handling — the integration reads CE's x-rate-limit-remaining header and automatically pauses calls when the quota is exhausted, resuming after the reset window
- User-Agent identification — all requests identify themselves as CEP/Much/Odoo; as required by ChannelEngine
- Connection test — validates credentials, then immediately imports active channels and stock locations
2. Channel Management
ChannelEngine organises sales into channels (e.g. "Amazon DE", "Zalando FR"). The integration mirrors this structure in Odoo:
- Channels are imported automatically on connection test, or manually via the Import Channels button on the connector form
- Each channel record stores: name, Channel ID, Global Channel ID, country/language, and optionally a dedicated warehouse, accounting journal, sales team, and salesperson
- Channels are also importable system-wide via a scheduled action that polls all active CE connectors
Per-channel configuration:
| Field | Purpose |
|---|---|
| Channel Warehouse | Override the default connector warehouse for orders from this channel |
| Journal | Accounting journal used when invoicing orders from this channel |
| Sales Team / Salesperson | Assign all imported orders from this channel to a specific team |
| API Key | Channel-specific API key (used for channel-fulfillment return exports) |
| Allow Partial Shipment | Whether partial shipments are permitted for this channel |
| Allow Partial Return | Whether partial returns are permitted |
| Allow Partial Cancellation | Whether partial cancellations are permitted |
3. Stock Location Management
ChannelEngine maintains its own stock location model. The integration can:
- Import CE stock locations (done automatically during connection test)
- Map CE locations to fiscal position overrides — when a channel-fulfilled order comes from a specific CE location and the computed Odoo fiscal position matches a configured mapping, the integration applies a replacement fiscal position instead
This is essential for cross-border FBA-like scenarios where the shipping origin affects the VAT treatment.
4. Order Import
Orders are fetched from ChannelEngine and converted into Odoo sale orders. The import handles:
Order Acknowledgement
New CE orders (those without a MerchantOrderNo) are acknowledged via the CE API before processing. This tells ChannelEngine that Odoo has accepted the order. FBA/FBM orders where all lines are fulfilled by the marketplace skip acknowledgement (CE moves them automatically).
Order Status Mapping
| CE Status | Odoo Order State |
|---|---|
| NEW, IN_PROGRESS, IN_COMBI, CLOSED | Sale (confirmed) |
| SHIPPED, IN_BACKORDER, AWAITING_PAYMENT, REQUIRES_CORRECTION | Sale-only (no stock picking) |
| MANCO, RETURNED | Cancelled |
Sub-order Splitting
When a single CE order contains lines from mixed fulfillment types (merchant vs. channel/marketplace) or from multiple CE stock locations, the integration automatically splits it into separate Odoo sale orders. Each sub-order handles its own warehouse, fiscal position, and acknowledgement.
Channel Fulfillment (FBA-style)
Orders where the marketplace handles fulfillment (IsFulfillmentByMarketplace = true) are created as sale-only (no delivery order is generated). The integration then automatically:
- Creates stock moves to account for the consumed inventory
- Creates and validates an invoice
Fiscal Position Resolution
The integration follows Odoo's standard fiscal position logic but extends it with the CE stock location dimension. For channel-fulfilled orders, it checks whether the (CE location, standard fiscal position) combination has a configured override and applies it if found.
Import Wizard
The import wizard (chengine.resource.import) supports filtering by:
- Resource type: Orders, Returns, Cancellations, Products
- Date range: from / to date
- New orders only toggle
- Fulfillment type: ALL, ONLY_MERCHANT, ONLY_CHANNEL, MIXED, INCLUDES_MERCHANT
- Channel order IDs or Merchant order IDs (comma-separated for targeted re-imports)
Pagination is handled automatically — all CE pages are fetched sequentially and committed to the database after each page.
5. Order Cancellation
Export (Odoo → ChannelEngine)
A Cancel Order in ChannelEngine wizard is accessible from the sale order form. It:
- Lists all non-service order lines with their ordered and already-delivered quantities
- Allows entering a cancelled quantity per line (validated not to exceed the ordered quantity)
- Sends the cancellation payload to CE
- Reduces the sale order line quantities in Odoo accordingly
- Cancels the entire sale order in Odoo if no remaining delivery quantity exists
The standard Odoo cancel button is hidden for CE orders that allow partial cancellation, directing users to the wizard instead.
Import (ChannelEngine → Odoo)
Cancellation requests initiated from the marketplace side are pulled from the CE API and converted into shop.order.cancellation records. Each record holds the reason, lines, and quantities requested for cancellation.
6. Order Returns
Import (ChannelEngine → Odoo)
Returns are fetched from CE with flexible filtering:
| Filter | Options |
|---|---|
| Creator type | ONLY_FROM_MERCHANT, ONLY_FROM_CHANNEL (FBA), MIXED |
| Fulfillment type | ALL, ONLY_MERCHANT, ONLY_CHANNEL, MIXED |
| Date range | from_date / to_date |
| Acknowledged | Boolean filter for channel-type returns |
Targeted re-imports by merchant or channel order number are also supported.
Export (Odoo → ChannelEngine)
When a return picking is validated in Odoo, the integration automatically notifies CE:
- For merchant-fulfilled returns: creates a return via POST /returns/merchant
- For channel-fulfilled returns: creates a return via POST /returns/channel using the channel-specific API key
- For confirmed CE return records: marks the return as received via PUT /returns with accepted/rejected line quantities
After any return export, stock levels for the affected products are pushed to CE automatically.
7. Product Export
Products are exported to ChannelEngine in CE's product format. The export:
- Batches all selected product variants into a single CE API request
- Parses the response for accepted/rejected counts and logs any validation errors via iHub
- Automatically triggers a stock and price push for the exported variants after a successful product export
Lifecycle management:
- When a product template is archived in Odoo, the corresponding CE product is archived via DELETE /products/{merchantProductNo}
- When a product template is deleted in Odoo, the CE product is archived before deletion
- When an archived product is restored, it is re-exported to CE
8. Product Import
Products are pulled from CE and created as shop.product.template records in Odoo. The import supports:
- Date-range filtering (created_at_min / created_at_max)
- Free-text search (name, MerchantProductNo, EAN, or brand)
- EAN list filtering
- MerchantProductNo list filtering
- Pagination (all pages are fetched automatically)
The standalone product sync wizard provides a UI for targeted product pulls from the connector form.
9. Stock & Price Export
Stock quantities and prices are pushed to the CE offer endpoint (PUT /offer) for a list of product variants. For each product:
- Stock: computed from the connector's configured source locations using Odoo's standard quant logic
- Price: computed from the connector's configured pricelist
This push is triggered automatically:
- After every order import
- After every product export
- After every validated shipment
- After every exported return
If no source locations are configured on the connector, the export logs an iHub error rather than pushing empty data.
10. Shipment Export
When a delivery order (stock.picking) is validated in Odoo, the integration automatically notifies ChannelEngine:
- Shipment payload includes: merchant shipment number, merchant order number, carrier tracking reference, return tracking reference, carrier name, and line-level quantities
- Only lines with a quantity > 0 are included
The hook is on button_validate — no manual action is required. After a successful shipment export, stock levels are refreshed in CE.
11. Invoice Export
Invoices are pushed to ChannelEngine as PDF attachments via POST /orders/{merchantOrderNo}/invoice. The cron runs once per day and processes all uninvoiced shop orders:
- Renders the standard Odoo invoice PDF (without payment stamp)
- For PDFs over 1 MB, rebuilds the file page-by-page using PyPDF2 to reduce size
- Sets invoice_sent_to_ce = True on success, preventing duplicate sends
- Logs success/failure per invoice to iHub
12. Sales Reporting
The CE channel dimension is added to Odoo's built-in Sales Analysis report (sale.report), allowing grouping and filtering of sales data by ChannelEngine channel.