Synchronisation bidirectionnelle avec le système ERP Axelor et gestion des entités métier.

Synchronisation des Données

Company Manager assure une synchronisation bidirectionnelle robuste avec le système ERP Axelor, permettant une gestion cohérente des données entre les systèmes.

Entités Synchronisées

Sociétés et Contacts

Mapping avec base_partner et base_partner_address
Synchronisation des informations légales
Gestion des adresses multiples
Historique des modifications

// Exemple de synchronisation société
const syncCompany = async (company: Company) => {
  const partner = await axelor.query('com.axelor.apps.base.db.Partner')
    .filter('self.code = :code')
    .bind('code', company.code)
    .fetch();
  
  if (partner) {
    await axelor.update('com.axelor.apps.base.db.Partner', {
      id: partner.id,
      name: company.name,
      email: company.email,
      // ... autres champs
    });
  } else {
    await axelor.create('com.axelor.apps.base.db.Partner', {
      code: company.code,
      name: company.name,
      // ... autres champs
    });
  }
};

Documents et Fichiers

Synchronisation des documents comptables
Gestion des versions
Stockage sécurisé
Métadonnées et indexation

Factures et Commandes

Synchronisation des données financières
Gestion des codes comptables (411)
Statuts et workflow
Historique des transactions

Architecture Technique

Connexion Globale

// Gestionnaire de connexion Axelor
class AxelorConnection {
  private static instance: AxelorConnection;
  private client: AxelorClient;

  private constructor() {
    this.client = new AxelorClient({
      url: process.env.AXELOR_URL,
      database: process.env.AXELOR_DB,
      username: process.env.AXELOR_USER,
      password: process.env.AXELOR_PASSWORD,
    });

    // Gestion SIGINT
    process.on('SIGINT', async () => {
      await this.cleanup();
      process.exit(0);
    });
  }

  public static getInstance(): AxelorConnection {
    if (!AxelorConnection.instance) {
      AxelorConnection.instance = new AxelorConnection();
    }
    return AxelorConnection.instance;
  }

  private async cleanup() {
    await this.client.disconnect();
  }
}

Cache LRU

// Configuration du cache
const cache = new LRUCache({
  max: 500, // Taille maximale
  ttl: 1000 * 60 * 5, // 5 minutes
  updateAgeOnGet: true,
});

// Utilisation du cache
const getCachedPartner = async (code: string) => {
  const cacheKey = `partner:${code}`;
  const cached = cache.get(cacheKey);
  
  if (cached) return cached;

  const partner = await axelor.fetchPartner(code);
  cache.set(cacheKey, partner);
  return partner;
};

Processus de Synchronisation

Initialisation

Vérification des connexions
Validation des schémas
Synchronisation initiale
Configuration du monitoring

Synchronisation Continue

Détection des modifications
Gestion des conflits
File d'attente des mises à jour
Retry automatique

// Gestionnaire de synchronisation
class SyncManager {
  private queue: Queue;

  constructor() {
    this.queue = new Queue({
      concurrency: 3,
      autoStart: true,
    });
  }

  async syncEntity(entity: SyncEntity) {
    return this.queue.add(async () => {
      try {
        await this.performSync(entity);
      } catch (error) {
        await this.handleSyncError(error, entity);
      }
    });
  }
}

Sécurité et Authentification

Session Management

Authentification sécurisée
Gestion des tokens
Renouvellement automatique
Isolation par tenant

Validation des Données

// Schéma de validation
const companySchema = z.object({
  code: z.string(),
  name: z.string(),
  email: z.string().email(),
  address: z.object({
    street: z.string(),
    city: z.string(),
    zip: z.string(),
  }),
});

Monitoring et Maintenance

Logs et Métriques

Journalisation détaillée
Métriques de performance
Alertes et notifications
Dashboard de supervision

Outils de Débogage

// Utilitaire de debug
const debugSync = (entity: SyncEntity) => {
  debug('sync:entity', {
    type: entity.type,
    id: entity.id,
    timestamp: new Date(),
    direction: entity.direction,
  });
};

Bonnes Pratiques

Résilience
- Gestion des erreurs
- Circuit breaker
- Retry avec backoff
- Transactions atomiques
Performance
- Batch processing
- Compression des données
- Optimisation des requêtes
- Monitoring des ressources
Maintenance
- Backup régulier
- Nettoyage des données
- Mise à jour des schémas
- Documentation des APIs

Synchronisation des Données

On this page