1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
use crate::com::FromDispatchNew;
use crate::errors::SageResult;
use crate::wrappers::cpta::objects::Tiers;
use std::ops::Deref;
use windows::Win32::System::Com::IDispatch;
/// Fournisseur - Spécialisation de Tiers avec CT_Type = 1
///
/// Un fournisseur est un tiers de type 1 dans Sage 100c.
/// Cette structure encapsule un objet Tiers et expose toutes ses méthodes
/// via le trait Deref, tout en permettant d'ajouter des méthodes spécifiques aux fournisseurs.
#[derive(Debug)]
pub struct Fournisseur {
tiers: Tiers,
}
impl Fournisseur {
/// Crée un Fournisseur à partir d'un Tiers existant
///
/// # Arguments
/// * `tiers` - L'objet Tiers sous-jacent
///
/// # Note
/// Cette fonction ne vérifie pas que le tiers est bien de type Fournisseur (CT_Type = 1).
/// Il est de la responsabilité de l'appelant de s'assurer de la cohérence.
pub fn from_tiers(tiers: Tiers) -> Self {
Self { tiers }
}
/// Accède au Tiers sous-jacent (consomme le Fournisseur)
pub fn into_tiers(self) -> Tiers {
self.tiers
}
/// Référence immutable au Tiers sous-jacent
pub fn as_tiers(&self) -> &Tiers {
&self.tiers
}
/// Référence mutable au Tiers sous-jacent
pub fn as_tiers_mut(&mut self) -> &mut Tiers {
&mut self.tiers
}
/// Méthode utilitaire spécifique aux fournisseurs
/// Retourne une description formatée du fournisseur
pub fn description(&self) -> SageResult<String> {
let numero = self.tiers.ct_num()?;
let intitule = self.tiers.ct_intitule()?;
Ok(format!("Fournisseur {} - {}", numero, intitule))
}
/// Vérifie que le tiers est bien de type Fournisseur (CT_Type = 1)
pub fn verify_type(&self) -> SageResult<bool> {
let type_tiers = self.tiers.ct_type()?;
Ok(type_tiers == 1)
}
}
// Implémentation de Deref pour accéder directement aux méthodes de Tiers
// Cela permet d'écrire : fournisseur.ct_num() au lieu de fournisseur.tiers.ct_num()
impl Deref for Fournisseur {
type Target = Tiers;
fn deref(&self) -> &Self::Target {
&self.tiers
}
}
// Implémentation de Clone
impl Clone for Fournisseur {
fn clone(&self) -> Self {
Self {
tiers: self.tiers.clone(),
}
}
}
// Implémentation de PartialEq basée sur le numéro de tiers
impl PartialEq for Fournisseur {
fn eq(&self, other: &Self) -> bool {
self.tiers == other.tiers
}
}
impl FromDispatchNew for Fournisseur {
fn from_dispatch_new(dispatch: IDispatch) -> SageResult<Self> {
Ok(Self::from_tiers(Tiers { dispatch }))
}
}
#[cfg(test)]
mod tests {
#[test]
fn test_fournisseur_documentation() {
// Test de documentation - nécessite un environnement Sage pour s'exécuter
// Utilisation typique :
// let factory = app.factory_fournisseur()?;
// let fournisseur = factory.read_by_code("FOURNISSEUR01")?;
//
// // Accès direct aux méthodes Tiers via Deref
// let numero = fournisseur.ct_num()?;
// let intitule = fournisseur.ct_intitule()?;
// let solde = fournisseur.ct_solde()?;
//
// // Méthode spécifique Fournisseur
// let description = fournisseur.description()?;
// assert_eq!(description, format!("Fournisseur {} - {}", numero, intitule));
}
}