Amorcer la création un nouveau connecteur

Nous allons voir les étapes pour amorcer la création d’un nouveau connecteur

À côté de ça, vous devriez utiliser les connecteurs existants pour avoir des exemples réels d’implémentation:

Du code boilerplate est nécessaire, donc ce document va vous guider à travers différentes étapes. Consultez également les Conventions de nommage.

Pour cet exemple nous allons imaginer que nous devons synchroniser Odoo avec une machine à café.

Odoo Manifest

Comme nous voulons synchroniser Odoo avec une machine à café, nous allons nommer notre connecteur connector_coffee

Tout d’abord, nous devons créer le module Odoo lui-même, en modifiant le fichier connector_coffee/__openerp__.py.

 # -*- coding: utf-8 -*-
 {'name': 'Coffee Connector',
  'version': '1.0.0',
  'category': 'Connector',
  'depends': ['connector',
              ],
  'author': 'Myself',
  'license': 'AGPL-3',
  'description': """
 Coffee Connector
 ================

 Connect Odoo to my coffee machine.

 Features:

 * Poor a coffee when Odoo is busy for too long
 """,
  'data': [],
  'installable': True,
  'application': False,
 }

Il y a 2 points à noter :

  • Il dépend de connector.

  • La catégorie du module doit être Connector.

Bien sûr, nous devons aussi créer le fichier __init__.py où nous plaçons les imports de nos modules Python.

Déclaration des backends

Notre module est compatible avec les machines à café :

  • Coffee 1900
  • Coffee 2900

Donc nous allons déclarer un backend coffee, l’entité générique, et un backend différent par version.

Placez ceci dans connector_coffee/backend.py:

import openerp.addons.connector.backend as backend


coffee = backend.Backend('coffee')
coffee1900 = backend.Backend(parent=coffee, version='1900')
coffee2900 = backend.Backend(parent=coffee, version='2900')

Modèle du backend

Nous avons déclaré les backends, mais nous avons besoin d’un modèle pour les configurer.

Nous créons un modèle coffee.backend qui est un _inherit de connector.backend. Dans connector_coffee/coffee_model.py:

from openerp import fields, models, api


class CoffeeBackend(models.Model):
    _name = 'coffee.backend'
    _description = 'Coffee Backend'
    _inherit = 'connector.backend'

    _backend_type = 'coffee'

    @api.model
    def _select_versions(self):
        """ Available versions

        Can be inherited to add custom versions.
        """
        return [('1900', 'Version 1900'),
                ('2900', 'Version 2900')]

    version = fields.Selection(
        selection='_select_versions',
        string='Version',
        required=True,
    )
    location = fields.Char(string='Location')
    username = fields.Char(string='Username')
    password = fields.Char(string='Password')
    default_lang_id = fields.Many2one(
        comodel_name='res.lang',
        string='Default Language',
    )

Notes :

  • Le _backend_type doit être le même que le nom du backend dans Déclaration des backends.

  • les versions doivent être les mêmes que celles déclarées dans Déclaration des backends.

  • Nous pouvons ajouter dans ce modèle autant de champs que nous voulons pour configurer notre connexion ou configuration en rapport avec le backend.

Binding abstrait

Si nous avons de nombreux Bindings (Liaisons), nous pouvons créer un modèle abstrait pour eux.

Cela peut être comme suit (dans connector_coffee/connector.py):

from openerp import models, fields


class CoffeeBinding(models.AbstractModel):
    _name = 'coffee.binding'
    _inherit = 'external.binding'
    _description = 'Coffee Binding (abstract)'

    # 'openerp_id': openerp-side id must be declared in concrete model
    backend_id = fields.Many2one(
        comodel_name='coffee.backend',
        string='Coffee Backend',
        required=True,
        ondelete='restrict',
    )
    # fields.char because 0 is a valid coffee ID
    coffee_id = fields.Char(string='ID in the Coffee Machine',
                            select=True)

Environnement

Nous aurons souvent besoin de créer un nouvel environnement avec lequel travailler. Je propose de créer une méthode auxiliaire qui le construit (dans connector_coffee/connector.py:

from openerp.addons.connector.connector import Environment


def get_environment(session, model_name, backend_id):
    """ Create an environment to work with. """
    backend_record = session.env['coffee.backend'].browse(backend_id)
    env = Environment(backend_record, session, model_name)
    lang = backend_record.default_lang_id
    lang_code = lang.code if lang else 'en_US'
    if lang_code == session.context.get('lang'):
        return env
    else:
        with env.session.change_context(lang=lang_code):
            return env

Remarquez que la partie qui concerne la définition du langage est complètement optionnelle mais elle est conservée pour l’exemple.

Points de contrôle

Quand de nouveaux enregistrements sont importés et ont besoin de vérification, des Point de contrôle sont créés. Je propose de créer aussi un auxiliaire dans connector_coffee/connector.py:

from openerp.addons.connector.checkpoint import checkpoint


def add_checkpoint(session, model_name, record_id, backend_id):
    return checkpoint.add_checkpoint(session, model_name, record_id,
                                     'coffee.backend', backend_id)

Classes ConnectorUnit

Nous aurons probablement besoin de créer des synchroniseurs, des mappeurs, des adaptateurs de backend, des bindings, et peut-être nos propres types de classes ConnectorUnit

Leur implémentation peut varier énormément. Jetez un œil aux projets Connecteur Odoo Magento et Connecteur Odoo Prestashop.