Description

The module you’ve developed for Odoo 17 is an extension of the OCA/connector framework, designed to provide a clean and standardized foundation for integrating Odoo with external systems. Instead of repeatedly implementing boilerplate logic for every new connector, this module introduces a reusable architecture that simplifies integration development and makes connectors easier to maintain over time.

A key goal of this project is to bring Aspect-Oriented Programming (AOP) principles into Odoo’s connector development. By using a declarative API with decorators such as @importer and @collection, defining an importer for a third-party platform—like Shopify—becomes straightforward and expressive. Developers can focus on the behavior of the integration itself, while the module handles the underlying workflow, registration, and lifecycle of each connector component.

Long-term consistency is also a priority: the design ensures that the same connector structure can be adopted across multiple Odoo versions, enabling better code reusability and future compatibility. Additionally, the framework is built with testing in mind, ensuring that automated tests can be written easily and that integrations remain stable and reliable, even when interacting with external systems.

Overall, this project significantly reduces development complexity, improves maintainability, and provides a solid foundation for scalable and well-tested Odoo integrations with other platforms—all while minimizing the amount of code developers need to write.

Usecase

The primary purpose of this system is to synchronize data between two tables: one in Odoo, and one in an external system. It builds on the OCA Connector framework and introduces an AOP-style (Aspect-Oriented Programming) structure to minimize the amount of code required to create and manage connectors.

The module provides a clean and declarative API. For example, implementing an importer for Shopify products can be done as simply as:

@importer("shopify.import.product")
@collection("shopify")
class ShopifyProductImporter:
   """Implement an importer"""

Each connector follows the same architectural pattern across all supported Odoo versions, ensuring consistency and easier long-term maintenance. The system supports two core synchronization operations: importing data from the external system into Odoo, and exporting Odoo records to the external system.

When both sides provide timestamps for record updates, the module can automatically detect changes and perform continuous synchronization, ensuring both systems stay aligned without manual intervention.

Automated testing is also a key design objective, enabling developers to validate their connectors efficiently and maintain reliability as their integration evolves.

Installation

• Clone the project: First, clone the repository and place it inside your Odoo addons directory.
• Configure the addons path: Ensure that the connector module’s path is added to Odoo’s addons configuration so that Odoo can detect the module.
• Install the module: When developing or using a new connector, make sure this module is installed. Search for it in the Apps menu and install it just like any other Odoo module.
• Verify installation: Once installed, the Connector module will appear in your list of installed applications, enabling you to build and manage integrations with external systems.

Configuration

All global configuration options for the Connector system are available within the general Odoo settings.

To access them, navigate to Settings → Connector.

This section contains all the framework-level configuration parameters for the connector module.

In addition to the global settings, each external system connection also provides its own specific configuration options. To access and configure these:

Go to Connector → Configuration.

Within this section, you will find a list of available connector instances. Each connector can be configured independently, allowing you to tailor credentials, behavior, and synchronization rules for each external system.

This configuration guide applies to the Odoo 17 module designed for managing integrations between Odoo and external platforms.

Usage

The core principle behind this module is the adoption of Aspect-Oriented Programming (AOP) to simplify and standardize the implementation of Odoo connectors. By introducing decorators and a structured component model, integrations become easier to define, maintain, and scale. The developer only needs to focus on the logic specific to each external system, while the framework handles the common connector behavior.

class KoganBackend(models.Model):
   _name = "connector.kogan.backend"
   _inherit = [
      "connector.backend",
      "connector.backend.crud.mixin",
      "connector.backend.http.mixin",
   ]
   _description = "Backends for Kogan Connector"

@import_mapper("kogan.import.mapper")
@apply_on("product.product")
@collection("connector.kogan.backend")
class ProductImportMapper:
   direct = [
      ("Title", "name"),
      ("sku", "default_code"),
   ]

@importer("kogan.importer")
@apply_on("product.product")
@collection("connector.kogan.backend")
class ProductImporter:

   @process(description="Import product from Kogan")
   def create(self, *args, **kwargs):
      return super().create(*args, **kwargs)

@export_mapper("kogan.export.mapper")
@apply_on("product.product")
@collection("connector.kogan.backend")
class ProductExportMapper:
   direct = [
      ("name", "Title"),
      ("default_code", "sku"),
   ]

@exporter("kogan.exporter")
@apply_on("product.product")
@collection("connector.kogan.backend")
class ProductExporter:

   @process(description="Export product to Kogan")
   def create(self, *args, **kwargs):
      return super().create(*args, **kwargs)

@adapter("kogan.adapter")
@apply_on("product.product")
class ProductAdapter:

   def get_records(self, *args, **kwargs):
      pass

   def get_record(self, *args, **kwargs):
      pass

   def create_record(self, *args, **kwargs):
      pass

   def update_record(self, *args, **kwargs):
      pass

Contributer

Credits

History

Development