Migration 1C:UPP vers UH via Python SQLite

# Migration des données de 1C:ERP vers 1C:HC : Pipeline Python, SQLite et COM

Les développeurs 1C se heurtent souvent à des blocages avec les outils de conversion standards lors du passage d'ERP à HC. Les modifications sources personnalisées, les incohérences de structures de données et les exécutions répétées nécessitent une couche intermédiaire. Un pipeline Python + SQLite + COM offre une transparence totale : importation vers des bases brutes, traitement basé sur des mappings, et export vers la cible. Le code open-source est disponible sur GitHub.

Architecture en trois étapes

Le pipeline se décompose en étapes indépendantes :

• import : Lecture depuis ERP via COM, normalisation et sauvegarde en SQLite.
• process : Transformation pour s'adapter au modèle HC via des mappings de champs, types et références.
• export : Localisation/création d'objets en HC et écriture via COM.

Les bases SQLite intermédiaires permettent d'inspecter les données à chaque étape et de comparer les versions brutes et traitées. Chaque entité dispose de son propre fichier de base.

Exigences du pipeline de migration

Cette configuration résout les principaux défis industriels de migration :

• Transfert d'entités liées en respectant les dépendances.
• Séparation de la lecture, du traitement et de l'écriture.
• Stockage de données intermédiaires pour analyse.
• Mappings automatiques et manuels de champs/énumérations.
• Suivi dédié des références par UUID.
• Réexport sélectif d'enregistrements.
• Interface web pour lancement et suivi.
• Exécutions automatisées programmées avec notifications.

Pourquoi SQLite comme couche intermédiaire

SQLite excelle par sa praticité :

• Accès local, sans serveur.
• Comparaisons faciles entre étapes.
• Gestion sans problème des exécutions répétées.
• Une base par entité et par étape.

Le format des données est prévisible : références en JSON avec nom affiché, UUID et type ; énumérations sous forme Enum.Nom.Valeur.

{
  "presentation": "SARL Romashka",
  "uuid": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
  "type": "Catalog.Contreparties"
}

Import depuis ERP : Structure modulaire

Les modules dans IN/ se connectent à ERP via COM, exécutent des requêtes, normalisent les types et sauvegardent en base. Tâches principales :

• Extraction des noms affichés et UUID pour les références.
• Gestion des énumérations.
• Préservation des types pour transformations ultérieures.

L'export automatisé des métadonnées ERP et HC génère des mappings initiaux, compare les attributs et signale les écarts.

Traitement des données : Processeur et mappings

L'étape process est le cœur : renommage de champs, conversion de types, consolidation de comptes, préparation des références. La logique se divise en :

• Processeur central pour l'infrastructure.
• PROCESS/<catalogue>_processor.py personnalisé pour les règles métier.

Les mappings résident dans des fichiers dédiés :

• catalog_mapping.json — routes chargeur/processeur/écrivain.
• chart_of_accounts_mapping.json — plan comptable.
• Correspondances objets, champs, types et énumérations.

L'automatisation génère des brouillons à partir des métadonnées ; les ajustements manuels gèrent la sémantique.

Gestion des références : Base reference_objects

Une base dédiée suit les objets créés par UUID :

• Référence source (objet, champ).
• Statut d'enregistrement.
• Support des mises à jour partielles et réexports.

Cela démêle le chaos des erreurs : le statut des références est toujours visible.

Export vers HC

L'écrivain lit la base traitée, localise les objets par clé, remplit les attributs et met à jour reference_objects. Avantage clé : les données sont préparées, le débogage est simple.

Interface web opérationnelle

La couche web lance le pipeline, affiche les logs, bases et exports sélectifs. Pas de duplication de logique, accès convivial pour l'équipe.

Automatisation et planification

Intégration de planificateur : exécutions nocturnes, alertes messagerie. Du lancement manuel à l'automatisation complète.

Avantages sur la conversion standard

Ce pipeline offre :

• Données intermédiaires transparentes.
• Cycles export-analyse-ajustement.
• Mappings et références contrôlés.
• Supervision granulaire.
• Interface web et planification.

Intégration plus rapide de nouvelles entités, sans reconstructions totales.

Points clés

• Pipeline SQLite en trois étapes réduit les risques de migration.
• Mappings auto + manuels accélèrent les configurations personnalisées.
• Suivi dédié des références évite les pertes de données.
• Interface web et planification rendent le processus opérationnel.
• Code open-source pour réplication facile.

— Editorial Team