Connecteur

class connector.connector.Binder(connector_env)

Bases : connector.connector.ConnectorUnit

Pour un enregistrement d’un modèle, capable de trouver un ID externe ou interne, ou crée la liaison entre eux

This is a default implementation that can be inherited or reimplemented in the connectors.

This implementation assumes that binding models are _inherits of the models they are binding.

bind(external_id, binding_id)

Crée le lien entre un ID externe et un ID OpenERP

Paramètres:

• external_id – ID externe à lier
• binding_id (int) – ID OpenERP à lier

to_backend(binding_id, wrap=False)

Give the external ID for an OpenERP binding ID

Paramètres:

• binding_id – ID de liaison OpenERP pour lequel on veut l’ID du backend
• wrap – si Faux, binding_id est l’ID de la liaison, si Vrai, binding_id est l’ID de l’enregistrement normal, la méthode va chercher la liaison correspondante et renvoyer l’ID de backend de la liaison.

Renvoie:

ID externe de l’enregistrement

to_openerp(external_id, unwrap=False)

Donne l’ID OpenERP pour un ID externe

Paramètres:

• external_id – ID externe pour lequel on veut l’ID OpenERP
• unwrap – if True, returns the normal record else return the binding record

Renvoie:

a recordset, depending on the value of unwrap, or an empty recordset if the external_id is not mapped

Type renvoyé:

recordset

unwrap_binding(binding_id, browse=False)

Pour un enregistrement de liaison, donne l’enregistrement normal

Exemple : si appelé avec un ID de magento.product.product, il va renvoyer l’ID correspondant du product.product.

Paramètres:browse – si Vrai, renvoie une instance de browse_record à la place d’un ID

unwrap_model()

Pour un modèle de liaison, donne le modèle normal.

Exemple : si appelé sur une binder pour magento.product.product, il va renvoyer product.product.

class connector.connector.ConnectorEnvironment(backend_record, session, model_name)

Bases : object

Environnement utilisé par les différentes unités pour la synchronisation.

backend

Backend en cours sur lesquels on travaille. Obtenu avec backend_record.get_backend().

Instance de : connector.backend.Backend

backend_record

Enregistrement de type browse pour le backend. Le backend est hérité du modèle connector.backend et a au moins un type et une version.

session

Session en cours sur laquelle on travaille. Elle contient les cr, uid et context d’OpenERP.

model_name

Nom du modèle OpenERP avec lequel travailler.

_propagate_kwargs

List of attributes that must be used by connector.connector.ConnectorEnvironment.create_environment() when a new connector environment is instantiated.

classmethod create_environment(backend_record, session, model, connector_env=None)

Create a new environment ConnectorEnvironment.

Paramètres:

• backend_record (openerp.models.Model) – browse record of the backend
• session (connector.session.ConnectorSession) – current session (cr, uid, context)
• model_name (str) – nom du modèle
• connector_env (connector.connector.ConnectorEnvironment) – an existing environment from which the kwargs will be propagated to the new one

env

get_connector_unit(base_class)

Recherche et renvoie une instance de ConnectorUnit pour le modèle en cours et étant une classe ou sous-classe de base_class.

L’instance renvoyée est construite avec self pour son environnement.

Paramètres:base_class (connector.connector.ConnectorUnit) – ConnectorUnit à rechercher (classe ou sous-classe)

model

pool

class connector.connector.ConnectorUnit(connector_env)

Bases : object

Classe abstraite pour chaque composant du connecteur :

Exemples :

• connector.connector.Binder
• connector.unit.mapper.Mapper
• connector.unit.synchronizer.Synchronizer
• connector.unit.backend_adapter.BackendAdapter

Ou en gros n’importe quelle classe destinée à être inscrite dans un Backend.

advisory_lock_or_retry(lock, retry_seconds=1)

Acquire a Postgres transactional advisory lock or retry job

When the lock cannot be acquired, it raises a RetryableJobError so the job is retried after n retry_seconds.

Usage example:

lock_name = 'import_record({}, {}, {}, {})'.format(
    self.backend_record._name,
    self.backend_record.id,
    self.model._name,
    self.external_id,
)
self.advisory_lock_or_retry(lock_name, retry_seconds=2)

See :func:openerp.addons.connector.connector.pg_try_advisory_lock for details.

Paramètres:

• lock – The lock name. Can be anything convertible to a string. It needs to represent what should not be synchronized concurrently, usually the string will contain at least: the action, the backend type, the backend id, the model name, the external id
• retry_seconds – number of seconds after which a job should be retried when the lock cannot be acquired.

binder_for(model=None)

Renvoie une nouvelle instance du bon Binder pour un modèle

env

Renvoie le openerp.api.environment

localcontext

Présent pour une question de compatibilité.

openerp.tools.translate._() recherche cet attribut dans les classes pour être capable de traduire les chaînes.

Il n’y a aucune raison d’utiliser cet attribut à d’autres fins.

classmethod match(session, model)

Renvoie True si la classe en cours correspond au modèle recherché

Paramètres:

• session (connector.session.ConnectorSession) – session en cours
• model (str or openerp.models.Model) – modèle à rechercher

model

unit_for(connector_unit_class, model=None)

Selon le ConnectorEnvironment en cours, recherche et renvoie une instance de ConnectorUnit pour le modèle actuel et étant une classe ou sous-classe de connector_unit_class.

If a different model is given, a new ConnectorEnvironment is built for this model. The class used for creating the new environment is the same class as in self.connector_env which must be ConnectorEnvironment or a subclass.

Paramètres:

• connector_unit_class (connector.                                               connector.ConnectorUnit) – ConnectorUnit à rechercher (classe ou sous-classe)
• model (str) – à donner si le ConnectorUnit est pour un autre modèle que le modèle actuel

class connector.connector.MetaConnectorUnit(name, bases, attrs)

Bases : type

Metaclass pour ConnectorUnit.

Conserve un attribut _module sur les classes, de la même façon qu’OpenERP pour les classes de modèles. Il est utilisé ensuite pour les filtrer en fonction de l’état du module (installé ou non).

for_model_names

Renvoie une liste de modèles sur lesquels une ConnectorUnit est utilisable

Utilisé dans match() lorsqu’on recherche la bonne ConnectorUnit pour un modèle.

connector.connector.get_openerp_module(cls_or_func)

Pour une fonction ou classe de niveau supérieur, renvoie le nom du module OpenERP où elle réside.

Ainsi nous serons capable de les filtrer en fonction de l’état d’installation des modules.

connector.connector.is_module_installed(env, module_name)

Check if an Odoo addon is installed.

Paramètres:module_name – name of the addon

connector.connector.pg_try_advisory_lock(env, lock)

Try to acquire a Postgres transactional advisory lock.

The function tries to acquire a lock, returns a boolean indicating if it could be obtained or not. An acquired lock is released at the end of the transaction.

A typical use is to acquire a lock at the beginning of an importer to prevent 2 jobs to do the same import at the same time. Since the record doesn’t exist yet, we can’t put a lock on a record, so we put an advisory lock.

Exemple :

• Job 1 imports Partner A
• Job 2 imports Partner B
• Partner A has a category X which happens not to exist yet
• Partner B has a category X which happens not to exist yet
• Job 1 import category X as a dependency
• Job 2 import category X as a dependency

Since both jobs are executed concurrently, they both create a record for category X so we have duplicated records. With this lock:

• Job 1 imports Partner A, it acquires a lock for this partner
• Job 2 imports Partner B, it acquires a lock for this partner
• Partner A has a category X which happens not to exist yet
• Partner B has a category X which happens not to exist yet
• Job 1 import category X as a dependency, it acquires a lock for this category
• Job 2 import category X as a dependency, try to acquire a lock but can’t, Job 2 is retried later, and when it is retried, it sees the category X created by Job 1.

The lock is acquired until the end of the transaction.

Usage example:

lock_name = 'import_record({}, {}, {}, {})'.format(
    self.backend_record._name,
    self.backend_record.id,
    self.model._name,
    self.external_id,
)
if pg_try_advisory_lock(lock_name):
    # do sync
else:
    raise RetryableJobError('Could not acquire advisory lock',
                            seconds=2,
                            ignore_retry=True)

Paramètres:

• env – the Odoo Environment
• lock – The lock name. Can be anything convertible to a string. It needs to represents what should not be synchronized concurrently so usually the string will contain at least: the action, the backend type, the backend id, the model name, the external id

:return True/False whether lock was acquired.