Skip to content
For AI agents: the complete documentation index is available at llms.txt; this page is also available as Markdown at index.md.
  • Documentation >
  • Product catalog >
  • Quable integration >
  • Set up Quable synchronization

Set up Quable synchronization

To integrate Cohesivo with Quable, you need to configure the connection and set up synchronization.

Create Quable instance

Before configuring the Quable connector, ensure you have access to a Quable instance.

Get API credentials

To connect to Quable, you need an API token:

  1. Log in to your Quable instance, for example, https://example.quable.com.
  2. Navigate to the API Tokens section.
  3. Create a new Read Access Token for use in the configuration.

Configure Quable connector

Specify the configuration for the Quable connector:

1
2
3
4
ibexa_connector_quable:
    instance_url: 'https://example.quable.com'
    api_token: '<your_api_token>'
    channel_code: '<channel_code>'

Replace <your_api_token> with the Read Access API token you obtained from Quable in the previous step.

Quable's channels allow you to distribute your product information to defined recipients, for example e-commerce platforms. Select the Quable channel that you want to integrate within Cohesivo.

For all available configuration options, see Configure Quable.

Configure product catalog engine

To use Quable as a product data source, configure Cohesivo's product catalog to use the Quable engine.

Define Quable engine

Add a new engine configuration:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
ibexa_product_catalog:
    engines:
        local:
            type: local
            options:
                root_location_remote_id: ibexa_product_catalog_root
                product_type_group_identifier: product
        quable:
            type: quable
            options:
                taxonomy: quable
                root_location_remote_id: ibexa_product_catalog_root
                product_type_group_identifier: product

This configuration defines two engines: the default local engine and the new quable engine, allowing you to work with products defined within Quable.

To learn more about product catalog configuration, see Product catalog configuration.

The Quable integration add-on comes with a new taxonomy called quable. By setting the ibexa_product_catalog.engines.quable.options.taxonomy key to quable, you configure the engine to use it for storing product categories.

Set Quable as default engine

In your repository configuration, configure the product catalog to use the Quable engine as the product data source:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
ibexa:
    repositories:
        default:
            storage: ~
            search:
                engine: '%search_engine%'
                connection: default
            product_catalog:
                engine: quable
                regions:
                    default: ~

Set up languages

To use the products from Quable within Cohesivo content, make sure the data languages in Quable have corresponding languages in Cohesivo.

Configure the language_map setting, mapping each Cohesivo language code to its Quable locale code as in the following example:

1
2
3
4
5
ibexa_connector_quable:
    # ...
    language_map:
        eng-GB: en_GB
        fre-FR: fr_FR

The system uses the language map to retrieve data in the correct language from Quable.

Set up real-time synchronization

Quable can notify Cohesivo about product data and classification changes in real-time by using webhooks. This invalidates the cache kept in Cohesivo, ensuring that product information stays up to date.

Webhook configuration must be set up in both Quable and Cohesivo.

Create webhook in Quable

  1. Create a new webhook in Quable.
  2. Set the webhook code (used as the webhook name).
  3. Provide the URL to your Cohesivo instance suffixed by /webhook/quable, for example: https://example.com/webhook/quable.
  4. Mark it as Activated.
  5. Enter a secret value for the Authorization Header.

  6. Choose the following scopes:

    • Products: created, updated, deleted
    • Classifications: created, updated, deleted

The Authorization Header value is a secret that must be kept secure.

Note

For local development and testing, you can consider using one of the available tunnel providers to make your local instance accessible from the internet.

Configure webhook in Cohesivo

Specify the configuration for the Quable connector:

1
2
3
4
ibexa_connector_quable:

    # ...
    webhook_secret: '<webhook authorization header>'

Caution

Quable uses dynamic IP addresses to connect to Cohesivo. If your Cohesivo instance is protected by a firewall, make sure your configuration allows connections from changing IP addresses.

Cohesivo webhook processes Quable's classification change events and queues them to be processed asynchronously in the background.

View as Markdown View on GitHub