BambooForge Shopware Connector
A real connector between Odoo 19 and Shopware 6 — the open-source PHP/Symfony commerce platform. A single OAuth Integration lets you sync products (with categories & images), customers and orders over the Shopware Admin API — with a resilient queue, signed webhook handling, dry-run safety and full source you can audit.
Verified live against a running Shopware
We don't just claim a vague version range. The connector was installed on Odoo 19, pointed at a live, locally-run Shopware 6.6, and run through a full product / customer / order import — 0 errors.
| Shopware version | API | Live result |
|---|---|---|
| 6.6 | Admin API (OAuth client-credentials) | ✔ Live-tested — 12 products / 6 customers / 5 orders, 0 errors |
| 6.5 | Admin API | ✔ Compatible (same Admin API endpoints) — validate on your build |
| 6.x line | Admin API | ✔ Supported via the same /api/search endpoints |
The live test imported 12 products, 6 customers and 5 orders with no errors. Orders resolved to their customers by email and carried 4–7 line items each with real gross totals — for example the product “Sleek Silk Phuel” at €148.33. Prices are taken verbatim from the Shopware price array, so totals land correctly with no minor-unit conversion.
Built to actually sync — not to look busy
The Shopware Admin API returns clean JSON, and this connector treats it that way: a single /api/search request returns a product with its categories, cover media and images resolved inline through associations. Every model ships with verifiable sync logic, covered by tests — no fake dashboards, no “readiness score” with nothing behind it.
What you actually get
Everything below ships in the box — including a bundled mock Shopware Admin API so you can demo the full flow without a live store.
Products with categories & media
Shopware products import with their categories, cover and media images, product number → SKU, stock and gross price. childCount is recorded as the combination count and the variant payload is stored for later expansion.
Customers & addresses
Each Shopware customer becomes a res.partner — first / last name, email, customer group — with the default billing address, phone and company captured as well.
Orders with state machine
Orders import with their order number, line items, order customer, shipping and tax totals, and payment method. The Shopware state-machine state maps to the Odoo order state through an editable mapping table per instance.
Refunds & credit notes
Refund / credit-note import is on the roadmap — this version focuses on a clean, verified product / customer / order import. We frame scope honestly rather than ship a half-working claim.
Signed webhook handling
The connector verifies HMAC-signed webhook events from Shopware on product / customer / order changes, so updates can flow in without a polling cron.
OAuth Admin API client
One client authenticates via the Shopware Integration (client-credentials), caches the bearer token and refreshes it on 401. Lists use POST /api/search/<entity> with associations resolved inline; retry with backoff and 429 handling built in.
Two-way stock sync
A cron delta-reconcile pushes Odoo on-hand for every bound product to Shopware via the native Admin API — a partial PATCH /api/product/{id} carrying only the stock field (returns 204). A 3-layer oversell guard (instance clamp + safety buffer + a final ≥0 clamp) means the store never oversells, and only changed quantities are pushed. An opt-in guarded import can also write platform stock back into real Odoo inventory as an actual adjustment — never in dry-run.
Sync Control Tower
A live operations dashboard: a kanban of instances surfacing per-instance health, circuit-breaker state, backlog/queue depth, dead-letter and conflict counts, 24h throughput and 24h failure rate — as clickable stat cards that drill into the queue, dead-letter and conflict views, with at-risk instances coloured.
Bulk dead-letter console
A dedicated view of exhausted-retry jobs grouped by error type, with bulk requeue or discard actions — clear a whole class of failures in one pass instead of clicking job by job.
Conflict-resolution workbench
A triage list with a side-by-side Odoo-vs-remote snapshot diff, plus bulk resolve — Odoo-wins, remote-wins or mark-reviewed — so two-way changes never silently clobber each other.
Conditional branching in flows
The multi-step flow engine walks true/false branches from a condition step's boolean result (true_step_id / false_step_id), with a loop guard against cyclic links. Flows with no branch links simply fall through to the next step in sequence — fully backward-compatible. Real branching on real conditions, not a visual designer.
Field-Mapping Studio
A payload-test wizard: paste a sample JSON payload and see exactly how each field mapping transforms it, in one consolidated mapping-studio view — plus one-click mapping suggestions.
A live walkthrough inside Odoo 19
Recorded in a real Odoo 19 connected to a live Shopware 6.6 — the connection cockpit, a synced product and order, the state mapping and the flow engine, all on real data.
Every screen, from a live install
Captured from a running Odoo 19 connected to a live Shopware 6.6 — real data synced through the connector, not mockups.
Run every Shopware store from one Control Tower
A short walkthrough of the operations tooling on real data: the Control Tower board, the side-by-side conflict workbench and the bulk dead-letter console.
Production safety, by default
Resilient queue
Retry with exponential backoff, rate-limit awareness, dead-letter handling and conflict capture for every job.
Circuit breaker
Auto-pauses sync after N consecutive failures so a broken endpoint can never flood your data.
Dry-run mode
Default-ON for every new instance — preview the exact write before anything touches live records.
Pre-flight validation
Blocking and warning findings surfaced before go-live, with auto-fix suggestions.
Rollback snapshots
Capture record state before risky writes and roll back cleanly when needed.
SSRF-safe by default
Internal / loopback hosts are blocked unless you explicitly opt in for a trusted self-hosted Shopware.
Honest feature matrix
No asterisks, no fake checkmarks. Here is exactly what this version does — and what is on the roadmap.
| Capability | Status |
|---|---|
| Product import (name, description, product number → SKU, stock) | ✔ Included |
Gross / net price from the Shopware price array (taken verbatim) | ✔ Included |
| Cover + media images captured | ✔ Included |
| Categories → Odoo product category | ✔ Included |
Variant combinations: childCount + payload recorded | ✔ Included |
| Customers (name, email, customer group) + default billing address | ✔ Included |
| Orders + line items + totals + state-machine state mapping | ✔ Included |
| Auth: OAuth client-credentials via a Shopware Integration | ✔ Included |
| Signed webhook handling (HMAC verified) | ✔ Included |
| Queue: retry · backoff · dead-letter · circuit breaker | ✔ Included |
| Pre-flight validation · rollback snapshots · dry-run | ✔ Included |
| Bundled mock Shopware Admin API for demos (no server needed) | ✔ Included |
Two-way stock sync: cron delta push via native PATCH /api/product/{id} + 3-layer oversell guard | ✔ Included |
| Guarded opt-in import of platform stock into real Odoo inventory (never in dry-run) | ✔ Included |
| Sync Control Tower — live instance kanban with health, queue/dead-letter/conflict stat cards | ✔ Included |
| Bulk dead-letter console (grouped by error, bulk requeue / discard) | ✔ Included |
| Conflict-resolution workbench (side-by-side diff, bulk Odoo-wins / remote-wins / reviewed) | ✔ Included |
| Conditional true/false branching in the multi-step flow engine (loop-guarded) | ✔ Included |
| Field-Mapping Studio — payload-test wizard + one-click mapping suggestions | ✔ Included |
| Full variant-matrix expansion into Odoo attribute lines | Roadmap |
| Refunds / credit notes import | Roadmap |
| Product export Odoo → Shopware (create / update) | Roadmap |
Live in four steps
A guided quick-setup wizard and onboarding checklist walk you from Integration keys to first safe sync.
Connect
Enter your Shopware URL plus the Integration's Access Key ID + Secret Access Key. One click exchanges them for a token and tests reachability.
Map
Run schema introspection and generate suggested field mappings automatically.
Dry-run
Preview exact writes with dry-run + validation on. Clear any blocking findings.
Go live
Enable signed webhook handling and let the resilient queue keep Odoo in sync with Shopware.
Buy with full clarity
In the box today
- Import: products (categories + media), customers + addresses, orders
- Two-way stock sync — cron delta push to Shopware via native
PATCH /api/product/{id}, 3-layer oversell guard, opt-in stock import into real Odoo inventory - Sync Control Tower — live instance kanban with health, queue, dead-letter and conflict stat cards
- Bulk dead-letter console + conflict-resolution workbench (side-by-side diff, bulk resolve)
- Conditional true/false branching in the flow engine + Field-Mapping Studio payload-test wizard
- Signed webhook handling — included, not sold separately
- Bundled mock Shopware Admin API — demo without a live store
- 38 automated tests (unit + HttpCase, all green)
- Full source included — audit and extend every line for your own use
Roadmap
- Full variant-matrix expansion into Odoo attribute lines (count + payload recorded today)
- Refunds / credit notes import
- Full product export Odoo → Shopware (create / update — stock is already pushed two-way today)
- Image binary upload Odoo → Shopware (image import is read-only today)
Frequently asked
Which versions are supported?
Odoo 19.0 on the Odoo side. On the store side, the connector was live-tested on Shopware 6.6 (Admin API) and targets the Shopware 6.x line — 6.5 and later use the same /api/search Admin API endpoints. Validate on your specific build.
Do I need to install Shopware to evaluate it?
No. A mock Shopware Admin API ships inside the module, so you can install, explore and demo the full OAuth + import flow before connecting a real store.
How does authentication work?
One mode: OAuth2 client-credentials. You create an Integration in the Shopware admin, which gives you an Access Key ID and a Secret Access Key. The connector exchanges those at POST /api/oauth/token for a short-lived bearer token, which it caches and refreshes automatically on a 401.
Is the webhook handling extra?
No. HMAC-signed webhook handling for product / customer / order changes ships inside this package, with setup instructions.
Is it safe to run against production data?
Dry-run mode is ON by default for new instances, validation blocks risky writes, and rollback snapshots let you undo. You decide when to go live.
What support and refund policy do I get?
Every request is answered within 24 hours, setup help included. If you report a bug within 2 months of purchase and it isn't resolved within 15 days, you're entitled to a full money-back refund.
Connect Odoo and Shopware the honest way
24-hour support · Report a bug within 2 months — unresolved in 15 days = full refund · Full source included
bambooforge.labs@gmail.comMore from BambooForge Labs — one vendor, the same standard: tested, source included, supported.
BambooForge Shopware Connector
A two-way bridge between Odoo 19 and your Shopware 6 store: import products, customers and orders, push product changes back, and reconcile refunds — with a resilient job queue, dry-run safety, validation and rollback so you stay in control.
This page is the complete manual. If you follow it top to bottom you can install, connect, run your first sync, automate it, and fix the common issues without contacting support.
- Overview
- Requirements
- Installation
- Step 1 — Create an Admin API integration in Shopware
- Step 2 — Create the connection in Odoo
- Step 3 — First sync (dry-run, then live)
- Order status mapping
- Field mapping & customization
- Automation (scheduled actions & webhooks)
- Safety features
- Troubleshooting
- Frequently asked questions
- Data, privacy & limits
- Support & updates
- Upgrading & version compatibility
- Uninstallation
- Changelog
Overview
The connector keeps Odoo and Shopware in sync over the official Shopware 6 Admin API. It covers:
- Products — import Shopware products (with variants, options and images) into Odoo product templates (optionally with stock, images and tax class), and export Odoo product changes back to the store.
- Customers — import Shopware customers (and their billing/shipping addresses) into Odoo contacts.
- Orders — import Shopware orders into Odoo sale orders, mapping each order's Shopware state-machine state to a sale-order action (keep draft, confirm, cancel, or ignore).
- Refunds — optionally discover Shopware order credit notes (order_slip) and create matching draft customer credit notes in Odoo.
Direction of sync: Odoo ↔ Shopware (import is the primary flow; product export and webhook-driven updates are supported).
Every remote call goes through a queue: nothing is written to Odoo until a job runs, jobs retry with back-off on transient failures, and a circuit breaker pauses an instance that keeps failing.
Requirements
- Odoo: 19.0, Community or Enterprise.
- Shopware: a Shopware 6 store exposing the Admin API (OAuth2 client-credentials). Shopware must be reachable from the Odoo server.
- Python: no extra libraries beyond a standard Odoo 19 install.
- Odoo access: any internal user can use the connector screens. Shopware credentials are stored in system-only fields, so only the Settings / Administration user can read or change the Access Key ID and Secret Access Key.
- Network: outbound HTTPS from Odoo to your store. By default the connector refuses internal/loopback/private hosts as an SSRF safeguard (see Safety features).
Installation
- Copy bambooforge_shopware_connector into your Odoo addons path.
- Restart the Odoo service.
- Open Apps, click Update Apps List, search for Shopware, and press Activate / Install. Dependencies (Sales, Contacts, Invoicing) install automatically.
No Shopware store is required to evaluate the connector: a mock Shopware Admin API ships inside the module, so you can install, explore and run the full import flow against sample data before pointing it at a real store. Point an instance's Base URL at <your-odoo-domain>/shopware/mock_api (auth type Integration, any access key and secret) to exercise the full flow without a live store.
Step 1 — Create an Admin API integration in Shopware
The connector authenticates as a Shopware Integration (OAuth2 client-credentials). In your Shopware 6 administration:
- Go to Settings ▸ System ▸ Integrations.
- Click Add integration.
- Give it a Name such as Odoo, and grant it the access it needs (administrator access, or read/write on Products, Customers and Orders).
- Save. Shopware shows the Access key ID and the Secret access key once.
- Copy both values now — the secret is shown only at creation time.
Optional, for real-time updates, you will also configure a webhook later (see Automation).
Step 2 — Create the connection in Odoo
Open Shopware Connector ▸ Configuration ▸ Instances and create a record.
Key fields:
| Field | What to enter |
|---|---|
| Name | A label for this store, e.g. My Live Store. |
| Base URL | Your Shopware server root, e.g. https://store.example.com. |
| Authentication | Integration (Access Key + Secret) — Shopware Admin API OAuth2 client-credentials. |
| Access Key ID | The integration's access key id (client_id) from Step 1 (admin-only). |
| Secret Access Key | The integration's secret access key (client_secret) from Step 1 (admin-only). |
| API Path | Leave the default api unless your store differs. |
| Verify SSL | Keep on for production. Turn off only for self-signed test certificates. |
| Allow internal host | Off by default. Turn on only to reach a store on localhost or a private network (lowers the SSRF guard — see Safety features). |
Then click Test Connection. A green Connected state means the credentials and URL are correct, and the default order-state mapping is seeded automatically on first successful connect. If it fails, the exact error is shown on the form and recorded in Logs (see Troubleshooting).
Tip: use Quick Setup (button on the instance) to pick a solution pack (catalog only, B2C full sync, …), seed default field mappings and order-state rules, and apply a recommended schedule in one step.
Step 3 — First sync (dry-run, then live)
New instances start with Dry-run ON. In dry-run, import and delete jobs simulate writes: instead of changing data they produce Validation Results you can review under Shopware Connector ▸ Operations ▸ Validation Results. This lets you confirm what would happen before anything is written.
To run a first import:
- On the instance, click Import Products (and/or Import Customers, Import Orders). This enqueues jobs; it does not block the UI.
- Jobs are processed by the Shopware Queue Processor scheduled action (every minute), or immediately if you run it manually from Operations ▸ Queue Jobs.
- Review Validation Results while still in dry-run.
- When satisfied, open the instance, turn Dry-run OFF, and run the imports again to write the records for real.
Imported records land in the standard Odoo apps: Sales ▸ Products, Contacts, and Sales ▸ Orders. Each carries its Shopware reference so re-imports update the same record instead of duplicating it.
Order status mapping
Shopware drives each order through a state machine; an order carries a stateMachineState whose technicalName (e.g. open, in_progress, completed, cancelled) identifies its current state. Under Configuration ▸ Order State Mappings each instance gets a default table that decides what happens to the Odoo sale order when an order reaches a given state:
| Shopware state | Default Odoo action |
|---|---|
| open | Keep draft |
| in_progress | Confirm sale order |
| completed | Confirm sale order |
| cancelled | Cancel sale order |
Change any row to Ignore (do nothing), Keep draft, Confirm sale order or Cancel sale order. Unknown/custom states default to Ignore, so a state you have not mapped never triggers a destructive transition. Add a row for any custom state your store introduces (use the exact technicalName).
Field mapping & customization
- Field Mappings (Configuration) map Shopware fields to Odoo fields per model. Use Generate suggested mappings on the instance to seed the business-critical ones, then adjust. The mapping board flags fields that need attention.
- Schema Fields lists the discovered Shopware fields per resource. Run Schema Introspection on the instance to refresh it from your live store.
- Stock / images / tax are opt-in toggles on the instance: Sync stock, Sync images (and max images), Upload images on export, Sync taxes (and auto-match taxes on import). They are off by default; turn on only what you need. Tax auto-match never auto-creates taxes — it only links to an existing Odoo sale tax by name.
- Refunds: Sync refunds discovers Shopware order_slip credit notes during order import and creates draft Odoo credit notes; Auto-post refund (off by default) posts them automatically so accountants can review first.
Automation (scheduled actions & webhooks)
The module ships these scheduled actions (Settings ▸ Technical ▸ Scheduled Actions):
| Scheduled action | Default | Purpose |
|---|---|---|
| Shopware Queue Processor | every 1 min | Processes queued import/export/delete jobs. |
| Shopware Reconciliation | every 15 min | Pulls recent remote changes for enabled models. |
| Shopware Maintenance | every 1 hr | Recovers stale/locked jobs and trims old logs. |
| Shopware Flow Scheduler | every 5 min | Runs scheduled sync flows. |
| Shopware Flow Metrics | every 1 hr | Aggregates flow-run metrics. |
| Shopware Auto Recover | every 15 min | Reopens a tripped circuit breaker once the store is healthy. |
Turn on Auto import / Auto reconcile per model on the instance to let the scheduled actions keep things in sync hands-free.
Real-time webhooks (optional): point a Shopware webhook subscriber at the connector's delivery URL so order, product and customer changes are pushed to Odoo as they happen:
- Delivery URL: https://<your-odoo-domain>/shopware/webhook
- Signature: each delivery must carry an X-Shopware-Signature header — the HMAC-SHA256 of the raw request body keyed with the instance Webhook Secret (admin-only field on the instance). The signed body must include an emitted_at timestamp for replay protection.
Odoo verifies the HMAC-SHA256 signature on each delivery, rejects stale or duplicate deliveries, and enqueues a safe import. Without webhooks the scheduled reconciliation still keeps data current.
Safety features
- Dry-run mode — simulate writes and review Validation Results before going live.
- Business validation profiles — Minimal / Standard / Strict gate risky writes.
- Resilient queue — every remote action is a job with retry and configurable fixed/exponential back-off, plus a dead-letter state for jobs that keep failing.
- Circuit breaker — after repeated failures an instance auto-pauses (Tripped); the Auto Recover action reopens it once the store responds again, or click Resume.
- Rollback snapshots — when enabled, imports capture a snapshot so you can undo a batch from Operations ▸ Rollback Snapshots.
- SSRF guard — the connector refuses internal/loopback/private hosts unless Allow internal host is explicitly enabled.
- Signed webhooks — public webhook route fails closed: a delivery is accepted only with a matching HMAC-SHA256 signature and a fresh, non-replayed emitted_at.
Troubleshooting
| Symptom | Cause and fix |
|---|---|
| Test Connection fails with 401 | Wrong Access Key ID / Secret Access Key, or the integration lacks access. Re-check Step 1 and recreate the integration if you lost the secret (it is shown only once). |
| "Base URL is not allowed / non-public host" | Base URL points at localhost/private IP. Enable Allow internal host on the instance (test/self-hosted only). |
| SSL errors on Test Connection | Self-signed certificate. Use a valid cert, or turn off Verify SSL for testing only. |
| Orders import but never confirm | The order's Shopware state is mapped to Keep draft or Ignore. Adjust Order State Mappings. |
| Jobs stay in Pending | The Queue Processor is off or the instance is paused. Check Scheduled Actions is active and the instance is not Paused. |
| Instance shows Tripped | Circuit breaker tripped after repeated failures. Fix the store/credentials; Auto Recover reopens it after the cooldown, or click Resume. |
| Webhook returns 401 Invalid signature | The X-Shopware-Signature HMAC does not match. Confirm the subscriber signs the raw body with the instance Webhook Secret using HMAC-SHA256. |
| Webhook returns 400 stale / 409 duplicate | The signed emitted_at is missing/too old/in the future, or the same signature was already delivered. Sync the clocks on both hosts and do not resend captured deliveries. |
| Records imported twice | Imports are keyed by the Shopware reference, so this should not happen. If it does, check that two instances do not point at the same store. |
| Nothing happens after Import | You are in Dry-run. Review Validation Results, then turn dry-run off and re-run. |
For anything else, Operations ▸ Logs records every API call, payload and error with a timestamp.
Frequently asked questions
Which versions are supported? Odoo 19.0 on the Odoo side. On the store side the connector targets the Shopware 6 Admin API (OAuth2 client-credentials). Validate your exact build with the bundled mock first.
Do I need Shopware installed to evaluate it? No. A mock Shopware Admin API ships inside, so you can install, explore and demo the full import flow before connecting a real store — point the Base URL at <your-odoo-domain>/shopware/mock_api.
How does authentication work? Create a Shopware Integration under Settings ▸ System ▸ Integrations to get an Access Key ID and Secret Access Key. The connector exchanges them for a short-lived bearer token via OAuth2 client-credentials and refreshes it automatically.
How does real-time sync work? Point a Shopware webhook subscriber at /shopware/webhook and sign each delivery with the shared Webhook Secret (HMAC-SHA256 over the raw body, with an emitted_at timestamp). Odoo verifies the signature, rejects replays, and enqueues a safe import. Without it, scheduled reconciliation keeps things in sync.
Is it safe to run against production data? Dry-run is ON by default, validation blocks risky writes, and rollback snapshots let you undo. You decide when to go live.
What support and refund policy do I get? Every request is answered within 24 hours, setup help included. If you report a bug within 2 months of purchase and it is not resolved within 15 days, you are entitled to a full money-back refund.
Data, privacy & limits
- The connector reads products, customers, orders and order credit notes from your store and writes the corresponding Odoo records. Credentials are stored in admin-only fields.
- In scope today: product/customer/order import, product export, order-state mapping, refund (order_slip) discovery, scheduled sync, signed webhooks.
- Out of scope / best-effort: tax auto-matching (off by default, name-based, never auto-creates taxes); multi-warehouse stock routing; subscription/booking order types.
Support & updates
- Support: bambooforge.labs@gmail.com — answered within 24 hours, setup help included.
- Refund: report a bug within 2 months of purchase; if unresolved within 15 days, full refund.
- Full source is included. Updates track the supported Odoo 19 / Shopware 6 Admin API line.
Upgrading & version compatibility
This build targets Odoo 19.0. Each Odoo major series (17.0, 18.0, 19.0) has its own dedicated build of this module — always install the build that matches your Odoo version. Mixing a build with a different Odoo series is not supported.
Patch upgrades (same series, e.g. 19.0.1.0.0 → later)
Back up your database and filestore first.
Replace the module folder with the newer build.
Restart Odoo with the module updated:
./odoo-bin -c your.conf -u bambooforge_shopware_connector -d your_db
Odoo applies any schema/data changes automatically. Your existing records and configuration are preserved.
Cross-version migration (e.g. Odoo 17 → 18)
Upgrading Odoo itself is a database migration handled by Odoo's standard upgrade tooling. When you migrate the database to the next Odoo series, install the matching build of this module for that series. Data created by this module carries over with the database migration.
After any upgrade the module's scheduled actions resume on their normal cadence — no manual re-activation is required.
Uninstallation
You can remove this module at any time from Apps → (this module) → Uninstall, or from the command line. Uninstalling is clean and reversible by reinstalling — but note what is and is not deleted.
What is removed
- The module's own tables and every record in them (20 models, prefixed shopware.*) — this is the data this module created.
- The menus, actions, views and reports this module installed.
- Its scheduled actions (cron jobs) — they stop immediately on uninstall.
- Connection records, credentials, field mappings, queue jobs and sync logs stored in Odoo.
What is preserved
- Your remote platform is never touched. Uninstalling only removes the Odoo-side connector; products, customers and orders on the external store/service are untouched.
- Records already imported into standard Odoo models (e.g. contacts, products, sales orders) remain — they are ordinary Odoo records once created.
- Attachments and chatter messages on standard records are kept.
As always, take a database backup before uninstalling in production.
Changelog
19.0.1.0.0
Current release for Odoo 19.0. This build includes:
- Odoo 19 <-> Shopware 6 connector over the Shopware Admin API (OAuth2 Integration): products, customers, orders and refunds.
- JSON REST client, HMAC-signed webhook handling, two-way stock sync, live Sync Control Tower, resilient queue and dry-run safety.
Feature additions and fixes ship as new builds on the Odoo Apps store; this page and the module's version reflect the current published release. Always keep the build matched to your Odoo series (see Upgrading & version compatibility).
Odoo Proprietary License v1.0 This software and associated files (the "Software") may only be used (executed, modified, executed after modifications) if you have purchased a valid license from the authors, typically via Odoo Apps, or if you have received a written agreement from the authors of the Software (see the COPYRIGHT file). You may develop Odoo modules that use the Software as a library (typically by depending on it, importing it and using its resources), but without copying any source code or material from the Software. You may distribute those modules under the license of your choice, provided that this license is compatible with the terms of the Odoo Proprietary License (For example: LGPL, MIT, or proprietary licenses similar to this one). It is forbidden to publish, distribute, sublicense, or sell copies of the Software or modified copies of the Software. The above copyright notice and this permission notice must be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Please log in to comment on this module