# Notes : Exemple Création Commande Client avec CARAT
## Modifications apportées
### Intégration CPTA/CIAL complète
L'exemple `create_commande_carat.rs` a été enrichi pour démontrer l'intégration complète entre les modules **Comptabilité (CPTA)** et **Commercial (CIAL)**.
## Structure de l'exemple
### 1. Double connexion (CPTA + CIAL)
```rust
// Connexion CPTA (Comptabilité)
let cpta = CptaApplication::new(BSCPTA_CLSID)?;
cpta.set_name(r"D:\TMP\BIJOU.MAE")?;
cpta.open()?;
// Connexion CIAL (Commercial)
let cial = CialApplication::new("Objets100c.CIAL")?;
// ⚠️ CRUCIAL : Lier CIAL à CPTA AVANT open()
cial.set_cpta_application(cpta.instance())?;
cial.set_name(r"D:\TMP\BIJOU.MAE")?;
cial.open()?;
```
### 2. Vérification client via FactoryClient (CPTA)
```rust
// Obtenir la factory depuis le module comptable
let factory_client = cpta.factory_client()?;
// Vérifier l'existence
if factory_client.exist_numero("CARAT")? {
// Lire les détails
let client = factory_client.read_numero("CARAT")?;
println!("Compte : {}", client.ct_num()?);
println!("Intitulé : {}", client.ct_intitule()?);
println!("Qualité : {}", client.ct_qualite()?);
}
```
### 3. Vérification article via FactoryArticle (CIAL)
```rust
// Obtenir la factory depuis le module commercial
let factory_article = cial.factory_article()?;
// Vérifier et lire l'article
if factory_article.exist_reference("LOCCOLLIER")? {
let article = factory_article.read_reference("LOCCOLLIER")?;
println!("Référence : {}", article.ar_ref()?);
println!("Désignation : {}", article.ar_design()?);
}
```
### 4. Création document de vente (CIAL)
```rust
// Créer une commande client (Type 1)
let factory_doc = cial.factory_document_vente()?;
let commande = factory_doc.create_type(1)?; // Type 1 = Commande
// Enregistrer
commande.write()?;
let piece = commande.do_piece()?;
```
### 5. Fermeture propre des deux connexions
```rust
// Fermer dans l'ordre : CIAL puis CPTA
cial.close()?;
cpta.close()?;
```
## Points importants
### ✅ Ce qui fonctionne (Phase 1)
1. **Connexion simultanée CPTA + CIAL**
- Deux applications indépendantes sur la même base
- Authentification séparée pour chaque module
2. **Lecture client via CPTA**
- `FactoryClient` accessible depuis `CptaApplication`
- Méthodes `exist_numero()` et `read_numero()`
- Propriétés : `ct_num`, `ct_intitule`, `ct_qualite`, `ct_classement`, etc.
3. **Lecture article via CIAL**
- `FactoryArticle` accessible depuis `CialApplication`
- Méthodes `exist_reference()` et `read_reference()`
- Propriétés : `ar_ref`, `ar_design`, etc.
4. **Création document vente**
- `FactoryDocumentVente` pour créer documents
- Méthode `create_type(1)` pour commande client
- Méthode `write()` pour enregistrer
- Propriétés `do_piece()` et `do_type()` accessibles
### ⏳ Ce qui reste à implémenter (Phase 2)
1. **Propriétés détaillées DocumentVente**
- `set_do_tiers()` - Définir le client sur le document
- `set_do_date()` - Définir la date du document
- `set_do_ref()` - Définir la référence du document
- Et ~50 autres propriétés
2. **Gestion des lignes de commande**
- Objet `DocumentLigne`
- Collection `lignes()` sur DocumentVente
- Méthodes pour ajouter/modifier/supprimer des lignes
- Propriétés : `ar_ref`, `dl_qte`, `dl_puttc`, etc.
3. **Calculs automatiques**
- `montant_ht()` - Total HT
- `montant_ttc()` - Total TTC
- `montant_tva()` - Total TVA
- Recalcul automatique des totaux
## Workflow complet attendu (Phase 2)
```rust
// 1. Connexion CPTA + CIAL
let cpta = CptaApplication::new(BSCPTA_CLSID)?;
cpta.open()?;
let cial = CialApplication::new("Objets100c.CIAL")?;
cial.open()?;
// 2. Vérifier client
let client = cpta.factory_client()?.read_numero("CARAT")?;
// 3. Créer commande
let commande = cial.factory_document_vente()?.create_type(1)?;
// 4. Définir les propriétés (Phase 2)
commande.set_do_tiers("CARAT")?;
commande.set_do_date(chrono::Local::now())?;
commande.set_do_ref("CMD-2024-001")?;
// 5. Ajouter des lignes (Phase 2)
let lignes = commande.lignes()?;
let ligne = lignes.add()?;
ligne.set_ar_ref("LOCCOLLIER")?;
ligne.set_dl_qte(2.0)?;
ligne.set_dl_puttc(1500.0)?;
// 6. Enregistrer
commande.write()?;
// 7. Afficher les totaux (Phase 2)
println!("Total HT : {}", commande.montant_ht()?);
println!("Total TTC : {}", commande.montant_ttc()?);
// 8. Fermer
cial.close()?;
cpta.close()?;
```
## Architecture
```
┌─────────────────────────────────────────────────┐
│ Application Rust Utilisateur │
└─────────────────────────────────────────────────┘
│
┌─────────────┴─────────────┐
│ │
▼ ▼
┌──────────────┐ ┌──────────────┐
│ CptaApplication │ │ CialApplication │
│ (Comptabilité) │ │ (Commercial) │
└──────────────┘ └──────────────┘
│ │
│ │
┌───┴────┐ ┌───┴────┐
│FactoryClient │ │FactoryArticle │
│FactoryTiers │ │FactoryDocumentVente │
│FactoryCompteG│ │FactoryDepot │
└───────────┘ └───────────┘
│ │
└─────────────┬─────────────┘
│
▼
┌──────────────┐
│ BIJOU.MAE │
│ (Base Sage) │
└──────────────┘
```
## Tests recommandés
Pour tester l'exemple avec une vraie installation Sage 100c :
1. **Prérequis**
- Sage 100c installé avec licence valide
- Base BIJOU.MAE créée et accessible
- Client "CARAT" créé dans la comptabilité
- Article "LOCCOLLIER" créé dans le commercial
2. **Exécution**
```bash
cargo run --example create_commande_carat
```
3. **Vérification dans Sage**
- Ouvrir Sage 100c Commercial
- Menu Ventes → Documents de vente
- Filtrer sur Type = "Commande client"
- Vérifier la présence du document créé
## Références
- **Documentation Sage** : `docs/V12_Sage 100cloud Objets métiers v1200.md`
- **Guide exemple** : `examples/README_CREATE_COMMANDE.md`
- **Code source** : `examples/create_commande_carat.rs`
- **Architecture** : `AGENTS.md`
## Prochaines étapes
1. **Phase 2 - Configuration Produits** (5 factories)
- FactoryGamme - Gammes articles (couleurs, tailles)
- FactoryProduit - Types de produits
- FactoryUnite - Unités de mesure
- FactoryConditionnement - Conditionnements
- FactoryGlossaire - Glossaires commerciaux
2. **Phase 2 - Enrichissement DocumentVente**
- Implémenter ~50 propriétés setters
- Méthodes de calcul (HT, TVA, TTC)
- Validation métier
3. **Phase 2 - DocumentLigne**
- Objet DocumentLigne complet
- Collection lignes sur DocumentVente
- Gestion CRUD des lignes
- Recalcul automatique des totaux
## Conclusion
Cet exemple démontre que l'intégration CPTA/CIAL fonctionne correctement en Phase 1. Les bases sont solides pour implémenter les fonctionnalités avancées de Phase 2.
**État actuel** : ✅ Fondations solides, prêt pour Phase 2
**Compilation** : ✅ Succès en mode debug et release
**Documentation** : ✅ Complète et à jour