connector.connector.
Binder
(connector_env)[source]¶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)[source]¶Crée le lien entre un ID externe et un ID OpenERP
Paramètres: |
|
---|
to_backend
(binding_id, wrap=False)[source]¶Give the external ID for an OpenERP binding ID
Paramètres: |
|
---|---|
Retourne: | ID externe de l’enregistrement |
to_openerp
(external_id, unwrap=False)[source]¶Donne l’ID OpenERP pour un ID externe
Paramètres: |
|
---|---|
Retourne: | a recordset, depending on the value of unwrap, or an empty recordset if the external_id is not mapped |
Type retourné: | recordset |
unwrap_binding
(binding_id, browse=False)[source]¶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 |
---|
connector.connector.
ConnectorEnvironment
(backend_record, session, model_name)[source]¶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.
create_environment
(backend_record, session, model, connector_env=None)[source]¶Create a new environment ConnectorEnvironment.
Paramètres: |
|
---|
env
¶get_connector_unit
(base_class)[source]¶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
¶connector.connector.
ConnectorUnit
(connector_env)[source]¶Bases : object
Classe abstraite pour chaque composant du connecteur :
Ou en gros n’importe quelle classe destinée à être inscrite dans un Backend
.
advisory_lock_or_retry
(lock, retry_seconds=1)[source]¶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: |
|
---|
env
¶Renvoie le openerp.api.environment
environment
¶get_binder_for_model
(model=None)[source]¶Renvoie une nouvelle instance du bon Binder
pour un modèle
Déprécié, utilisez maintenant binder_for
.
get_connector_unit_for_model
(connector_unit_class, model=None)[source]¶Déprécié en faveur de unit_for()
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.
match
(session, model)[source]¶Renvoie True si la classe en cours correspond au modèle recherché
Paramètres: |
|
---|
model
¶unit_for
(connector_unit_class, model=None)[source]¶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.connector.
MetaConnectorUnit
(name, bases, attrs)[source]¶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.
model_name
¶connector.connector.
get_openerp_module
(cls_or_func)[source]¶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)[source]¶Check if an Odoo addon is installed.
Paramètres: | module_name – name of the addon |
---|
connector.connector.
pg_try_advisory_lock
(env, lock)[source]¶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.
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: |
|
---|
:return True/False whether lock was acquired.