https://docs.rs/objets_metier_rs

Objets Métier Sage 100c - Bibliothèque Rust

📋 Description

objets_metier_rs est une bibliothèque Rust moderne et sûre pour l'API COM Objets Métier Sage 100c, disponible sur crates.io. Elle permet d'interagir avec les bases de données et fonctionnalités de Sage 100c depuis des applications Rust modernes avec une syntaxe élégante et une gestion d'erreurs robuste.

Sage 100c fournit uniquement des exemples pour C# et Visual Basic dans sa documentation PDF. Ce projet comble cette lacune en offrant une interface Rust moderne, type-safe et ergonomique pour les développeurs souhaitant intégrer Sage 100c dans leurs applications.

✨ Fonctionnalités v1.0.0

• ✅ Production Ready - Stable et testée en production 🎉
• ✅ Bibliothèque pure publiée sur crates.io
• ✅ Installation simple via cargo add objets_metier_rs
• ✅ 37 Factories Comptabilité (97% de couverture module CPTA)
• ✅ 38 Factories Commerce (100% de couverture module CIAL) 🎯
• ✅ 16 objets métier enrichis (40-85 méthodes chacun)
• ✅ Système de Traits pour abstraction des factories (24 factories)
• ✅ Cache performant avec TTL et statistiques
• ✅ Auto-discovery CLSID depuis le registre Windows (4 méthodes)
• ✅ Syntaxe élégante similaire au C# : app.loggable()?.user_name()?
• ✅ Conversion VARIANT complète avec types Rust natifs
• ✅ Connexion fonctionnelle à Sage 100c avec authentification
• ✅ Architecture modulaire avec wrappers spécialisés
• ✅ Gestion mémoire automatique et sûre (RAII)
• ✅ Support complet COM avec discovery automatique
• ✅ Documentation en ligne sur docs.rs
• ✅ Exemples intégrés via cargo run --example

🎯 Objectifs du projet

Objectifs principaux

• ✅ Wrapper Rust sûr pour la DLL COM objets100c.dll
• ✅ Interface ergonomique cachant la complexité COM
• ✅ Documentation complète avec exemples pratiques
• ✅ Gestion d'erreurs robuste avec types Rust idiomatiques
• ✅ Support des opérations CRUD sur les données Sage
• ✅ Abstraction des modules Comptabilité, Commercial, Paie, etc.

Fonctionnalités cibles

• 🔗 Connexion aux bases Sage (ouverture/fermeture)
• 📊 Lecture des données (comptes, écritures, articles, clients...)
• ✏️ Écriture des données (création/modification d'écritures)
• 📈 Opérations de reporting et d'export
• 🔍 Requêtes avancées avec filtres
• 🔄 Synchronisation et opérations batch

🏗️ Architecture v1.0.0

objets_metier_rs/
├── src/
│   ├── lib.rs                     # API publique de la bibliothèque
│   ├── cache/                     # 🔄 Système de cache
│   │   ├── mod.rs
│   │   └── factory_cache.rs       # Cache des factories
│   ├── com/                       # Couche COM bas niveau
│   │   ├── mod.rs
│   │   ├── instance.rs            # Gestion des instances COM
│   │   ├── dispatch.rs            # Appels de méthodes COM
│   │   ├── variant.rs             # Conversion VARIANT ↔ Rust
│   │   ├── safe_string.rs         # Gestion BSTR sécurisée
│   │   └── collection.rs          # Gestion des collections COM
│   ├── errors/                    # Gestion d'erreurs
│   │   ├── mod.rs
│   │   └── sage_error.rs          # Types d'erreurs personnalisés
│   └── wrappers/                  # Wrappers métier spécialisés
│       ├── mod.rs
│       ├── cpta/                  # 💼 Module Comptabilité (37/38 factories)
│       │   ├── mod.rs
│       │   ├── cpta_application_wrapper.rs    # BSCPTAApplication100c
│       │   ├── loggable_wrapper.rs            # IBILoggable (auth)
│       │   ├── factories/         # 🏭 37 Factories Comptabilité
│       │   │   ├── mod.rs
│       │   │   ├── factory_journal_wrapper.rs
│       │   │   ├── factory_compte_wrapper.rs
│       │   │   ├── factory_ecriture_wrapper.rs
│       │   │   ├── factory_ecriture_od_wrapper.rs
│       │   │   ├── factory_ecriture_in_wrapper.rs
│       │   │   ├── factory_tiers_wrapper.rs
│       │   │   ├── factory_client_wrapper.rs
│       │   │   ├── factory_fournisseur_wrapper.rs
│       │   │   ├── factory_tiers_autre_wrapper.rs
│       │   │   ├── factory_tiers_salarie_wrapper.rs
│       │   │   ├── factory_devise_wrapper.rs
│       │   │   ├── factory_taxe_wrapper.rs
│       │   │   ├── factory_reglement_wrapper.rs
│       │   │   ├── factory_banque_wrapper.rs
│       │   │   ├── factory_adresse_wrapper.rs
│       │   │   ├── factory_contact_wrapper.rs
│       │   │   ├── factory_dossier_contact_wrapper.rs
│       │   │   ├── factory_collaborateur_wrapper.rs
│       │   │   ├── factory_analytique_wrapper.rs
│       │   │   ├── factory_compte_ana_wrapper.rs
│       │   │   ├── factory_journal_analytique_wrapper.rs
│       │   │   ├── factory_analyse_wrapper.rs
│       │   │   ├── factory_ecriture_ana_wrapper.rs
│       │   │   ├── factory_modele_ecriture_wrapper.rs
│       │   │   ├── factory_modele_grille_wrapper.rs
│       │   │   ├── factory_modele_reglement_wrapper.rs
│       │   │   ├── factory_rappel_wrapper.rs
│       │   │   ├── factory_dossier_wrapper.rs
│       │   │   ├── factory_pays_wrapper.rs
│       │   │   ├── factory_nature_compte_wrapper.rs
│       │   │   ├── factory_compte_reporting_wrapper.rs
│       │   │   ├── factory_tiers_stat_wrapper.rs
│       │   │   ├── factory_tiers_type_wrapper.rs
│       │   │   ├── factory_code_risque_wrapper.rs
│       │   │   ├── factory_type_contacts_wrapper.rs
│       │   │   ├── factory_service_contact_wrapper.rs
│       │   │   └── factory_struct_banque_wrapper.rs
│       │   ├── objects/           # 📦 37 Objets métier Comptabilité
│       │   │   ├── mod.rs
│       │   │   ├── journal_wrapper.rs
│       │   │   ├── compte_general_wrapper.rs
│       │   │   ├── ecriture_wrapper.rs
│       │   │   ├── ecriture_od_wrapper.rs
│       │   │   ├── tiers_wrapper.rs
│       │   │   ├── client_wrapper.rs
│       │   │   ├── fournisseur_wrapper.rs
│       │   │   ├── tiers_autre_wrapper.rs
│       │   │   ├── tiers_salarie_wrapper.rs
│       │   │   ├── devise_wrapper.rs
│       │   │   ├── taxe_wrapper.rs
│       │   │   ├── reglement_wrapper.rs
│       │   │   ├── banque_wrapper.rs
│       │   │   ├── adresse_wrapper.rs
│       │   │   ├── contact_wrapper.rs
│       │   │   ├── dossier_contact_wrapper.rs
│       │   │   ├── collaborateur_wrapper.rs
│       │   │   ├── analytique_wrapper.rs
│       │   │   ├── compte_ana_wrapper.rs
│       │   │   ├── journal_analytique_wrapper.rs
│       │   │   ├── analyse_wrapper.rs
│       │   │   ├── ecriture_ana_wrapper.rs
│       │   │   ├── modele_ecriture_wrapper.rs
│       │   │   ├── modele_grille_wrapper.rs
│       │   │   ├── modele_reglement_wrapper.rs
│       │   │   ├── rappel_wrapper.rs
│       │   │   ├── dossier_wrapper.rs
│       │   │   ├── pays_wrapper.rs
│       │   │   ├── nature_compte_wrapper.rs
│       │   │   ├── compte_reporting_wrapper.rs
│       │   │   ├── tiers_stat_wrapper.rs
│       │   │   ├── tiers_type_wrapper.rs
│       │   │   ├── code_risque_wrapper.rs
│       │   │   ├── type_contacts_wrapper.rs
│       │   │   ├── service_contact_wrapper.rs
│       │   │   └── struct_banque_wrapper.rs
│       │   ├── traits/            # 🎯 Traits pour patterns uniformes
│       │   │   ├── mod.rs
│       │   │   ├── factory_create.rs      # Trait de création
│       │   │   ├── factory_read.rs        # Trait de lecture
│       │   │   ├── factory_read_by.rs     # Trait de lecture filtrée
│       │   │   ├── factory_syncable.rs    # Trait de synchronisation
│       │   │   └── info_libre_capable.rs  # Trait infos libres
│       │   └── process/           # 🔧 Objets de traitement
│       │       ├── mod.rs
│       │       ├── pm_encoder_wrapper.rs       # Encodeur PM
│       │       └── error_collection_wrapper.rs # Collection d'erreurs
│       └── cial/                  # 🛒 Module Commercial (38/38 factories - 100% ✅)
│           ├── mod.rs
│           ├── tests.rs
│           ├── cial_application_wrapper.rs    # BSCIALApplication100c
│           ├── factories/         # 🏭 38 Factories Commerce
│           │   ├── mod.rs
│           │   ├── factory_article_wrapper.rs
│           │   ├── factory_document_vente_wrapper.rs
│           │   ├── factory_document_achat_wrapper.rs
│           │   ├── factory_document_stock_wrapper.rs
│           │   ├── factory_document_interne_wrapper.rs
│           │   ├── factory_document_wrapper.rs
│           │   ├── factory_famille_wrapper.rs
│           │   ├── factory_depot_wrapper.rs
│           │   ├── factory_conditionnement_wrapper.rs
│           │   ├── factory_unite_wrapper.rs
│           │   ├── factory_gamme_wrapper.rs
│           │   ├── factory_produit_wrapper.rs
│           │   ├── factory_categorie_tarif_wrapper.rs
│           │   ├── factory_article_stat_wrapper.rs
│           │   ├── factory_bareme_rabais_wrapper.rs
│           │   ├── factory_bareme_solde_wrapper.rs
│           │   ├── factory_bareme_commission_wrapper.rs
│           │   ├── factory_categorie_compta_vente_wrapper.rs
│           │   ├── factory_categorie_compta_achat_wrapper.rs
│           │   ├── factory_categorie_compta_stock_wrapper.rs
│           │   ├── factory_dossier_wrapper.rs
│           │   ├── factory_dossier_param_wrapper.rs
│           │   ├── factory_souche_vente_wrapper.rs
│           │   ├── factory_souche_achat_wrapper.rs
│           │   ├── factory_souche_stock_wrapper.rs
│           │   ├── factory_souche_interne_wrapper.rs
│           │   ├── factory_param_doc_vente_wrapper.rs
│           │   ├── factory_param_doc_achat_wrapper.rs
│           │   ├── factory_param_doc_stock_wrapper.rs
│           │   ├── factory_param_doc_interne_wrapper.rs
│           │   ├── factory_expedition_wrapper.rs
│           │   ├── factory_condition_livraison_wrapper.rs
│           │   ├── factory_arrondi_wrapper.rs
│           │   ├── factory_agenda_wrapper.rs
│           │   ├── factory_modele_wrapper.rs
│           │   ├── factory_glossaire_wrapper.rs
│           │   ├── factory_motif_devis_wrapper.rs
│           │   └── factory_periodicite_wrapper.rs
│           └── objects/           # 📦 38 Objets métier Commerce
│               ├── mod.rs
│               ├── article_wrapper.rs
│               ├── document_vente_wrapper.rs
│               ├── document_achat_wrapper.rs
│               ├── document_stock_wrapper.rs
│               ├── document_interne_wrapper.rs
│               ├── document_wrapper.rs
│               ├── famille_wrapper.rs
│               ├── depot_wrapper.rs
│               ├── conditionnement_wrapper.rs
│               ├── unite_wrapper.rs
│               ├── gamme_wrapper.rs
│               ├── produit_wrapper.rs
│               ├── categorie_tarif_wrapper.rs
│               ├── article_stat_wrapper.rs
│               ├── bareme_rabais_wrapper.rs
│               ├── bareme_solde_wrapper.rs
│               ├── bareme_commission_wrapper.rs
│               ├── categorie_compta_vente_wrapper.rs
│               ├── categorie_compta_achat_wrapper.rs
│               ├── categorie_compta_stock_wrapper.rs
│               ├── dossier_wrapper.rs
│               ├── dossier_param_wrapper.rs
│               ├── souche_vente_wrapper.rs
│               ├── souche_achat_wrapper.rs
│               ├── souche_stock_wrapper.rs
│               ├── souche_interne_wrapper.rs
│               ├── param_doc_vente_wrapper.rs
│               ├── param_doc_achat_wrapper.rs
│               ├── param_doc_stock_wrapper.rs
│               ├── param_doc_interne_wrapper.rs
│               ├── expedition_wrapper.rs
│               ├── condition_livraison_wrapper.rs
│               ├── arrondi_wrapper.rs
│               ├── agenda_wrapper.rs
│               ├── modele_wrapper.rs
│               ├── glossaire_wrapper.rs
│               ├── motif_devis_wrapper.rs
│               └── periodicite_wrapper.rs
├── examples/                      # Exemples d'utilisation
│   ├── sage_connection_demo.rs    # Connexion style C#
│   ├── elegant_syntax.rs          # Syntaxe moderne Rust
│   ├── bijou_example.rs           # Exemple complet base BIJOU
│   ├── recursive_analyzer.rs      # Analyseur récursif COM
│   └── test_typed_journal.rs      # Test journaux typés
├── tests/                         # Tests d'intégration
├── benches/                       # Benchmarks de performance
├── docs/                          # Documentation supplémentaire
├── scripts/                       # Scripts utilitaires
├── Cargo.toml                     # Configuration du projet
├── README.md                      # Ce fichier
├── CHANGELOG.md                   # Historique des versions
├── CLAUDE.md                      # Guidelines pour agents IA
└── LICENSE                        # Licence MIT

🚀 Démarrage rapide

Prérequis

1. Rust 1.70+ installé
2. Sage 100c installé avec objets100c.dll
3. Privilèges administrateur pour l'enregistrement DLL
4. Windows (COM nécessaire)

Installation

Via Cargo (Recommandé)

# Ajouter la dépendance
cargo add objets_metier_rs

# Ou manuellement dans Cargo.toml
[dependencies]
objets_metier_rs = "1.0.0"

Depuis les sources

# Cloner le projet
git clone https://github.com/mcastelain-pdw/objets_metier_rs.git
cd objets_metier_rs

# Compiler la bibliothèque
cargo build --release

Configuration Sage (requis dans tous les cas)

# Enregistrer la DLL Sage (en tant qu'administrateur)
regsvr32 "C:\Sage\Sage100c\objets100c.dll"

Exemple d'utilisation v1.0.0

Connexion à Sage 100c

use objets_metier_rs::{CptaApplication, SageResult};

fn main() -> SageResult<()> {
    // Créer une instance de l'application Comptabilité
    // Détection automatique du CLSID depuis le registre Windows
    let app = CptaApplication::new_auto()?;
    println!("✅ BSCPTAApplication100c créée avec auto-discovery");
    
    // === SYNTAXE ÉLÉGANTE STYLE C# ===
    
    // Équivalent C# : _mCpta.Name = "D:\\TMP\\BIJOU.MAE";
    app.set_name(r"D:\TMP\BIJOU.MAE")?;
    
    // Équivalent C# : _mCpta.Loggable.UserName = "<Administrateur>";
    let loggable = app.loggable()?;
    loggable.set_user_name("<Administrateur>")?;
    loggable.set_user_pwd("")?;
    
    // Vérification que les valeurs sont bien définies
    println!("📋 Base: '{}'", app.get_name()?);
    println!("👤 Utilisateur: '{}'", loggable.get_user_name()?);
    
    // Équivalent C# : _mCpta.Open();
    match app.open() {
        Ok(()) => {
            println!("🎉 CONNEXION RÉUSSIE!");
            
            if app.is_open()? {
                println!("✅ Base ouverte: {}", app.get_name()?);
                println!("🔐 Connecté: {}", app.loggable()?.is_logged()?);
                println!("👑 Admin: {}", app.loggable()?.is_administrator()?);
                
                app.close()?;
            }
        }
        Err(e) => println!("❌ Échec connexion: {}", e),
    }
    
    Ok(())
    // Instance libérée automatiquement (RAII)
}

Utilisation des Factories

use objets_metier_rs::wrappers::cpta::CptaApplication;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Détection automatique du CLSID
    let app = CptaApplication::new_auto()?;
    app.set_name(r"D:\TMP\BIJOU.MAE")?;
    
    let loggable = app.loggable()?;
    loggable.set_user_name("<Administrateur>")?;
    loggable.set_user_pwd("")?;
    app.open()?;
    
    // ========== FACTORY TIERS ==========
    let factory_tiers = app.factory_tiers()?;
    if factory_tiers.exists_by_code("BAGUES")? {
        let tiers = factory_tiers.read_by_code("BAGUES")?;
        println!("Tiers: {} - Solde: {:.2} €", 
                 tiers.ct_intitule()?, tiers.ct_solde()?);
    }
    
    // ========== FACTORY CLIENT ==========
    let factory_client = app.factory_client()?;
    let client = factory_client.read_by_code("BAGUES")?;
    println!("Client: {}", client.description()?);
    
    // ========== FACTORY DEVISE ==========
    let factory_devise = app.factory_devise()?;
    if factory_devise.exist_code_iso("EUR")? {
        let devise = factory_devise.read_code_iso("EUR")?;
        println!("Devise: {} - Symbole: {} - Cours: {}", 
                 devise.intitule()?, devise.d_symbole()?, devise.d_cours()?);
    }
    
    // ========== FACTORY TAXE ==========
    let factory_taxe = app.factory_taxe()?;
    if factory_taxe.exist_code("TVA20")? {
        let taxe = factory_taxe.read_code("TVA20")?;
        println!("Taxe: {} - Taux: {}%", 
                 taxe.ta_intitule()?, taxe.ta_taux()?);
    }
    
    // ========== FACTORY REGLEMENT ==========
    let factory_reglement = app.factory_reglement()?;
    if factory_reglement.exist_intitule("Chèque")? {
        let reglement = factory_reglement.read_intitule("Chèque")?;
        println!("Règlement: {} - Type: {}", 
                 reglement.rg_intitule()?, reglement.rg_type()?);
    }
    
    app.close()?;
    Ok(())
}

Résultat :

🚀 Sage 100c - Connexion automatique style C# v1.0.0
✅ BSCPTAApplication100c créée
📋 Base: 'D:\TMP\BIJOU.MAE'
👤 Utilisateur: '<Administrateur>'
🎉 CONNEXION RÉUSSIE!
✅ Base ouverte: D:\TMP\BIJOU.MAE
🔐 Connecté: true
👑 Admin: true
Tiers: BAGUES - Solde: 1245.50 €
Client: Client BAGUES - BIJOUTERIE BAGUES
Devise: Euro - Symbole: € - Cours: 1.0
Taxe: TVA 20% - Taux: 20.0%
Règlement: Chèque - Type: 1

Résultat :

🚀 Sage 100c - Connexion automatique style C# v0.2.0
✅ BSCPTAApplication100c créée
📋 Base: 'D:\TMP\BIJOU.MAE'
👤 Utilisateur: '<Administrateur>'
🎉 CONNEXION RÉUSSIE!
✅ Base ouverte: D:\TMP\BIJOU.MAE
🔐 Connecté: true
👑 Admin: true

Exemples intégrés

# Tester la connexion Sage
cargo run --example sage_connection_demo

# Démonstration de l'auto-discovery (NOUVEAU)
cargo run --example auto_discovery

# Syntaxe élégante 
cargo run --example elegant_syntax

# Analyseur récursif
cargo run --example recursive_analyzer

# Test complet sur la base BIJOU
cargo run --example bijou_example

# Démonstration des 6 nouvelles factories (v0.2.1)
cargo run --example factories_demo

� Auto-Discovery du CLSID

La bibliothèque détecte automatiquement le CLSID de Sage 100c installé sur votre machine via le registre Windows.

Méthodes d'initialisation

1. new_auto() - Détection automatique (Recommandé)

Détecte automatiquement le CLSID depuis le registre Windows :

let app = CptaApplication::new_auto()?;  // ✅ Simple et portable

2. new_version("100c") - Version spécifique

Cible une version précise de Sage :

let app = CptaApplication::new_version("100c")?;

3. from_prog_id(...) - ProgID complet

Utilise un ProgID Windows complet :

let app = CptaApplication::from_prog_id("Objets100c.Cpta.Stream")?;

4. new(clsid) - CLSID explicite (Legacy)

Spécifie directement le CLSID (méthode originale toujours supportée) :

let app = CptaApplication::new("309DE0FB-9FB8-4F4E-8295-CC60C60DAA33")?;

Fonctions de découverte

use objets_metier_rs::com::*;

// Lister toutes les versions installées
let versions = find_bscpta_versions()?;

// Obtenir la dernière version
let (prog_id, clsid) = find_latest_bscpta()?;

// Résoudre un ProgID
let clsid = resolve_prog_id("Objets100c.Cpta.Stream")?;

�📚 Documentation

Structure de la documentation

• 📖 Guide d'utilisation - Configuration et premiers pas
• 🤝 Guide de contribution - Comment contribuer au projet
• 💡 Exemples - Cas d'usage pratiques
• ❓ FAQ - Questions fréquentes
• 🔍 Troubleshooting - Résolution de problèmes
• 🎯 Guide des Traits - Utilisation des traits communs
• 📝 Guide PMEncoder - Création de pièces comptables
• 📚 Documentation API - Référence complète de l'API COM Sage

Modules supportés v1.0.0

Module	Status	Wrapper	Factories	Description
💼 Comptabilité	✅ Fonctionnel	CptaApplication	37/38 (97%)	Connexion, auth, CRUD
🔐 Authentification	✅ Fonctionnel	ILoggable	-	Login, permissions, admin
🛒 Commercial	✅ Fonctionnel	CialApplication	38/38 (100%) 🎯	Articles, documents, stocks

Factories Comptabilité implémentées (37/38)

Factory	Status	Objets retournés	Description
✅ FactoryJournal	v0.2.0	Journal	Gestion des journaux comptables
✅ FactoryCompte	v0.2.0	CompteG	Plan comptable général
✅ FactoryCompteAna	v0.2.0	CompteA	Comptabilité analytique
✅ FactoryEcriture	v0.2.0	EcritureG	Écritures comptables
✅ FactoryEcritureAna	v0.2.0	EcritureA	Écritures analytiques
✅ FactoryTiers	v0.2.1	Tiers	Tous types de tiers
✅ FactoryClient	v0.2.1	Client	Clients uniquement
✅ FactoryFournisseur	v0.2.1	Fournisseur	Fournisseurs
✅ FactoryDevise	v0.2.1	Devise	Devises et taux de change
✅ FactoryTaxe	v0.2.1	Taxe	Taxes et TVA
✅ FactoryReglement	v0.2.1	Reglement	Modes de règlement
✅ FactoryCompteR	v0.2.0	CompteR	Comptes de reporting
✅ FactoryJournalA	v0.2.0	JournalA	Journaux analytiques
✅ FactoryBanque	v0.2.8	Banque	Comptes bancaires
✅ FactoryModeleReglement	v0.2.8	ModeleReglement	Modèles de règlement
✅ FactoryCollaborateur	v0.2.8	Collaborateur	Collaborateurs
✅ FactoryAdresse	v0.2.8	Adresse	Adresses de livraison
✅ FactoryAnalyse	v0.2.8	Analyse	Analyses comptables
✅ FactoryAnalytique	v0.2.8	Analytique	Comptabilité analytique
✅ FactoryCodeRisque	v0.2.8	CodeRisque	Codes risque
✅ FactoryContact	v0.2.8	Contact	Contacts tiers
✅ FactoryDossier	v0.2.8	Dossier	Dossiers comptables
✅ FactoryDossierContact	v0.2.8	DossierContact	Contacts dossier
✅ FactoryEcritureIn	v0.2.8	EcritureG	Import écritures
✅ FactoryEcritureOD	v0.2.8	EcritureOD	Écritures OD
✅ FactoryModeleEcriture	v0.2.8	ModeleEcriture	Modèles d'écriture
✅ FactoryModeleGrille	v0.2.8	ModeleGrille	Modèles de grille
✅ FactoryNatureCompte	v0.2.8	NatureCompte	Natures de compte
✅ FactoryPays	v0.2.8	Pays	Pays
✅ FactoryRappel	v0.2.8	Rappel	Rappels
✅ FactoryServiceContact	v0.2.8	ServiceContact	Services contact
✅ FactoryStructBanque	v0.2.8	StructBanque	Structures bancaires
✅ FactoryTiersAutre	v0.2.8	TiersAutre	Autres tiers
✅ FactoryTiersSalarie	v0.2.8	TiersSalarie	Tiers salariés
✅ FactoryTiersStat	v0.2.8	TiersStat	Statistiques tiers
✅ FactoryTiersType	v0.2.8	TiersType	Types de tiers
✅ FactoryTypeContacts	v0.2.8	TypeContacts	Types de contacts

Factories Commerce implémentées (38/38 - 100% COMPLET 🎯)

Objets métier enrichis (Phase 6)

Factory	Status	Objets enrichis	Description
✅ FactoryArticle	v0.3.0	Article (62 méthodes)	Articles avec prix, stock, comptabilité
✅ FactoryDocumentVente	v0.3.0	DocumentVente (85 méthodes)	Devis, commandes, factures vente
✅ FactoryDocumentAchat	v0.3.0	DocumentAchat (66 méthodes)	Commandes, réceptions, factures achat
✅ FactoryDocumentStock	v0.3.0	DocumentStock (54 méthodes)	Mouvements de stock enrichis
✅ FactoryGamme	v0.3.0	Gamme (19 méthodes)	Gammes produits (couleurs, tailles)
✅ FactoryUnite	v0.3.0	Unite (16 méthodes)	Unités de mesure avec conversion
✅ FactoryProduit	v0.3.0	Produit (16 méthodes)	Natures d'articles
✅ FactoryConditionnement	v0.3.0	Conditionnement (14 méthodes)	Conditionnements (carton, palette)
✅ FactoryGlossaire	v0.3.0	Glossaire (14 méthodes)	Textes standardisés documents
✅ FactoryBaremeCommission	v0.3.0	BaremeCommission (17 méthodes)	Barèmes de commission
✅ FactoryBaremeRabais	v0.3.0	BaremeRabais (17 méthodes)	Barèmes de rabais et remises
✅ FactoryBaremeSolde	v0.3.0	BaremeSolde (17 méthodes)	Barèmes de solde et promotions
✅ FactorySoucheVente	v0.3.0	SoucheVente (14 méthodes)	Souches numérotation vente
✅ FactorySoucheAchat	v0.3.0	SoucheAchat (14 méthodes)	Souches numérotation achat
✅ FactorySoucheStock	v0.3.0	SoucheStock (14 méthodes)	Souches numérotation stock
✅ FactorySoucheInterne	v0.3.0	SoucheInterne (14 méthodes)	Souches numérotation interne

Factories complémentaires (Phase 4bis)

Factory	Status	Objet	Description
✅ FactoryAgenda	v0.3.0	Agenda	Gestion des agendas commerciaux
✅ FactoryDossier	v0.3.0	Dossier	Dossiers commerciaux
✅ FactoryDossierParam	v0.3.0	DossierParam	Paramètres de dossiers
✅ FactoryMotifDevis	v0.3.0	MotifDevis	Motifs de devis perdus

Autres factories (Phases 1-4)

Factory	Status	Description
✅ FactoryDepot	v0.3.0	Dépôts de stockage
✅ FactoryFamille	v0.3.0	Familles d'articles
✅ FactoryDocument	v0.3.0	Documents génériques
✅ FactoryDocumentInterne	v0.3.0	Documents internes
... + 14 autres	v0.3.0	Catégories, paramètres, statistiques

🎯 Fonctionnalités Principales v0.2.8

✅ Connexion Sage 100c

// Détection automatique du CLSID
let app = CptaApplication::new_auto()?;
app.set_name(r"D:\chemin\base.MAE")?;
let loggable = app.loggable()?;
loggable.set_user_name("<Administrateur>")?;
loggable.set_user_pwd("")?;
app.open()?; // Connexion réussie !

✅ Syntaxe Élégante

// Style C# natif
app.loggable()?.get_user_name()?       // _mCpta.Loggable.UserName
app.is_open()?                         // _mCpta.IsOpen  
app.loggable()?.is_administrator()?    // _mCpta.Loggable.IsAdministrator

✅ Factories et Objets Métier

// Lecture d'un client
let factory_client = app.factory_client()?;
let client = factory_client.read_by_code("BAGUES")?;
println!("Client: {}", client.ct_intitule()?);
println!("Solde: {:.2} €", client.ct_solde()?);

// Lecture d'une devise
let factory_devise = app.factory_devise()?;
let devise = factory_devise.read_code_iso("EUR")?;
println!("Devise: {} ({})", devise.intitule()?, devise.d_symbole()?);
println!("Cours: {}", devise.d_cours()?);

// Lecture d'une taxe
let factory_taxe = app.factory_taxe()?;
let taxe = factory_taxe.read_code("TVA20")?;
println!("Taux TVA: {}%", taxe.ta_taux()?);

✅ Conversion VARIANT Complète

• Strings : BSTR ↔ String avec gestion UTF-16
• Nombres : VT_I4, VT_R8 ↔ i32, f64
• Booléens : VARIANT_BOOL ↔ bool
• Objets COM : VT_DISPATCH ↔ IDispatch

✅ Gestion d'Erreurs Robuste

match app.open() {
    Ok(()) => println!("🎉 Connexion réussie"),
    Err(SageError::ComError { hresult, message }) => {
        println!("❌ Erreur COM: {} - {}", hresult, message);
    }
    Err(e) => println!("❌ Autre erreur: {}", e),
}

� Découverte des interfaces COM

Inspection intelligente des membres

La bibliothèque offre une classification intelligente des membres COM basée sur les conventions Sage 100c :

use objets_metier_rs::com::{ComInstance, MemberType};

let instance = ComInstance::new("309DE0FB-9FB8-4F4E-8295-CC60C60DAA33")?;

// Découverte avec classification intelligente
let members = instance.list_members()?;
for member in members {
    match member.member_type {
        MemberType::Method => println!("🔧 Méthode: {} ({:?} params)", 
                                      member.name, member.param_count),
        MemberType::PropertyGet => println!("📖 Propriété: {} -> {:?}", 
                                           member.name, member.return_type),
        // ...
    }
}

// Résultats typiques pour BSCPTAApplication100c:
// 🔧 7 méthodes (Open, Close, Create, DatabaseInfo, etc.)
// 📖 40 propriétés (FactoryTiers, FactoryClient, Name, IsOpen, etc.)

Classification automatique

L'algorithme de classification reconnaît :

• Factory* → Propriétés retournant des objets métier
• Is*, Name, Version → Propriétés d'état/information
• Open, Close, Create → Méthodes d'action
• DatabaseInfo, Synchro → Méthodes de traitement

Filtrage par type

// Filtrage avancé
let methods_only = instance.list_methods_only()?;     // 7 méthodes
let properties = instance.list_properties()?;         // 40 propriétés  
let grouped_props = instance.group_properties()?;     // Propriétés groupées

println!("Trouvé {} méthodes et {} propriétés", 
         methods_only.len(), properties.len());

// Exemples de propriétés Factory découvertes:
// - FactoryTiers -> Object (gestion des tiers)
// - FactoryClient -> Object (gestion des clients)  
// - FactoryFournisseur -> Object (gestion des fournisseurs)
// - FactoryCompteG -> Object (gestion du plan comptable)

Informations des membres

Chaque membre découvert fournit :

• ID : Identifiant unique COM (DISPID)
• Nom : Nom de la méthode/propriété
• Type : Method, PropertyGet, PropertyPut, PropertyPutRef
• Paramètres : Nombre de paramètres estimé selon le type
• Type de retour : Type de la valeur retournée (Object, String, Boolean, etc.)

Appels sécurisés

use objets_metier_rs::com::SafeDispatch;

let dispatch = SafeDispatch::new(instance.dispatch()?);

// Appel par nom avec gestion d'erreur
match dispatch.call_method_by_name("IsOpen", &[]) {
    Ok(result) => println!("Base ouverte: {}", result.type_name()),
    Err(e) => println!("Erreur: {}", e),
}

�🛠️ Développement

Contribuer

1. Fork le projet
2. Créer une branche feature (git checkout -b feature/nouvelle-fonctionnalite)
3. Commiter les changements (git commit -m 'Ajout nouvelle fonctionnalité')
4. Push vers la branche (git push origin feature/nouvelle-fonctionnalite)
5. Ouvrir une Pull Request

Tests

# Tests unitaires de la bibliothèque
cargo test

# Tests avec exemples intégrés
cargo test --examples

# Tests d'intégration (nécessite Sage 100c)
cargo test --test integration

# Tests avec une base de données test
SAGE_DB_PATH="C:\\Sage\\Data\\TEST.gcm" cargo test

Standards de code

• Format : cargo fmt
• Linting : cargo clippy
• Documentation : Toutes les APIs publiques documentées
• Tests : Couverture > 80%

📦 Dépendances

Principales

• windows = "0.52" - Bindings Windows COM
• winreg = "0.52" - Accès au registre Windows (auto-discovery)
• serde = "1.0" - Sérialisation des entités
• chrono = "0.4" - Gestion des dates
• thiserror = "1.0" - Gestion d'erreurs

Développement

• tokio-test - Tests asynchrones
• mockall - Mocking pour les tests
• criterion - Benchmarks

📋 Roadmap

Version 0.1.0 - Fondations ✅ TERMINÉE

• Configuration projet Rust
• Connexion COM basique
• Découverte CLSID et méthodes
• Wrapper sûr pour les appels COM
• Gestion d'erreurs Rust

Version 0.1.2 - Classification intelligente ✅ TERMINÉE

• Distinction automatique méthodes vs propriétés
• Reconnaissance patterns Sage (Factory*, Is*, etc.)
• Classification heuristique (7 méthodes, 40 propriétés)
• Documentation complète et tests

Version 0.1.3 - Architecture modulaire ✅ TERMINÉE

• Conversion VARIANT complète avec types Rust natifs
• Syntaxe élégante style C# (app.loggable()?.user_name()?)
• Connexion fonctionnelle à Sage 100c avec authentification
• Architecture modulaire avec wrappers spécialisés (CptaApplication, CptaLoggable)
• Gestion mémoire automatique et sûre (RAII)
• Tests de connexion réels avec base Sage

Version 0.2.0 - Bibliothèque crates.io ✅ TERMINÉE

• Conversion en bibliothèque pure (suppression main.rs)
• Publication crates.io avec documentation complète
• API publique finalisée avec ré-exports propres
• Exemples intégrés accessibles via cargo run --example
• Documentation docs.rs générée automatiquement
• Tests de la bibliothèque validés

Version 0.2.1 - Factories Prioritaires ✅ TERMINÉE

• FactoryTiers - Gestion des tiers (19 méthodes)
• FactoryClient - Gestion des clients (11 méthodes)
• FactoryFournisseur - Gestion des fournisseurs (11 méthodes)
• FactoryDevise - Gestion des devises (10 méthodes)
• FactoryTaxe - Gestion des taxes (9 méthodes)
• FactoryReglement - Modes de règlement (9 méthodes)
• Enrichissement objets - Devise, Taxe, Reglement (+600 lignes)
• Nouveaux wrappers - Client et Fournisseur spécialisés
• Exemple factories_demo.rs - Démonstration complète
• 27 tests unitaires - Couverture complète
• Couverture 34% - 13/38 factories CPTA implémentées

Version 0.3.0 - Module Commercial ✅ TERMINÉE

• CialApplication wrapper pour BSCIALApplication100c
• 38/38 Factories Commerce (100% de couverture) 🎯
• 16 objets enrichis avec 40-85 méthodes chacun
  • Article (62 méthodes) - Prix, stock, comptabilité
  • DocumentVente (85 méthodes) - Devis, commandes, factures
  • DocumentAchat (66 méthodes) - Commandes, réceptions
  • DocumentStock (54 méthodes) - Mouvements de stock
  • Gamme, Unite, Produit, Conditionnement, Glossaire (14-19 méthodes)
  • Barèmes (Commission, Rabais, Solde) - 17 méthodes chacun
  • Souches (Vente, Achat, Stock, Interne) - 14 méthodes chacune
• CRUD opérations commerciales
• Gestion des stocks et dépôts
• Configuration produits complète
• Paramètres commerciaux (barèmes, souches)
• Factories complémentaires (agenda, dossiers, motifs)
• 38/38 Factories implémentées (100% de couverture) 🎯
• 100 tests unitaires passent avec succès
• Phase 7 - Documentation et workflows

Version 1.0.0 - Production Ready ✅ TERMINÉE

• Documentation complète tous modules
• Performances optimisées
• Support multi-threading sécurisé
• Package crates.io publié
• Certification et tests exhaustifs

⚠️ Limitations connues

• Windows uniquement - Dépendance COM native
• Architecture - La DLL et l'executable doivent avoir la même architecture (32-bit)
• Licences Sage - Respect des termes de licence Sage 100c
• Version Sage - Testé sur Sage 100c v12

🤝 Support

Canaux de support

• 🐛 Issues GitHub - Bugs et demandes de fonctionnalités
• 💬 Discussions - Questions et aide communautaire
• 📧 Email - Contact direct pour les entreprises

Ressources utiles

• Documentation Sage 100c
• Guide COM en Rust

📄 Licence

Ce projet est sous licence MIT. Voir le fichier LICENSE pour plus de détails.

👥 Contributeurs

• Matthieu Castelain - Créateur et mainteneur principal - mcastelain_pdw

🙏 Remerciements

• Sage pour la documentation PDF des Objets Métier
• Microsoft pour les bindings Rust Windows
• Communauté Rust pour les outils et bibliothèques

---