datasynth_generators/sourcing/
contract_generator.rs

1//! Procurement contract generator.
2
3use chrono::NaiveDate;
4use datasynth_config::schema::ContractConfig;
5use datasynth_core::models::sourcing::{
6    ContractLineItem, ContractSla, ContractStatus, ContractTerms, ContractType,
7    ProcurementContract, SupplierBid,
8};
9use datasynth_core::utils::seeded_rng;
10use datasynth_core::uuid_factory::{DeterministicUuidFactory, GeneratorType};
11use rand::prelude::*;
12use rand_chacha::ChaCha8Rng;
13use rust_decimal::Decimal;
14
15/// Generates procurement contracts from awarded bids.
16pub struct ContractGenerator {
17    rng: ChaCha8Rng,
18    uuid_factory: DeterministicUuidFactory,
19    config: ContractConfig,
20}
21
22impl ContractGenerator {
23    /// Create a new contract generator.
24    pub fn new(seed: u64) -> Self {
25        Self {
26            rng: seeded_rng(seed, 0),
27            uuid_factory: DeterministicUuidFactory::new(seed, GeneratorType::ProcurementContract),
28            config: ContractConfig::default(),
29        }
30    }
31
32    /// Create with custom configuration.
33    pub fn with_config(seed: u64, config: ContractConfig) -> Self {
34        Self {
35            rng: seeded_rng(seed, 0),
36            uuid_factory: DeterministicUuidFactory::new(seed, GeneratorType::ProcurementContract),
37            config,
38        }
39    }
40
41    /// Generate a contract from a winning bid.
42    pub fn generate_from_bid(
43        &mut self,
44        winning_bid: &SupplierBid,
45        sourcing_project_id: Option<&str>,
46        category_id: &str,
47        owner_id: &str,
48        start_date: NaiveDate,
49    ) -> ProcurementContract {
50        let duration_months = self
51            .rng
52            .gen_range(self.config.min_duration_months..=self.config.max_duration_months);
53        let end_date = start_date + chrono::Duration::days((duration_months * 30) as i64);
54
55        let contract_type = self.select_contract_type();
56
57        let auto_renewal = self.rng.gen_bool(self.config.auto_renewal_rate);
58
59        let terms = ContractTerms {
60            payment_terms: winning_bid.payment_terms.clone(),
61            delivery_terms: winning_bid.delivery_terms.clone(),
62            warranty_months: if self.rng.gen_bool(0.5) {
63                Some(self.rng.gen_range(6..=24))
64            } else {
65                None
66            },
67            early_termination_penalty_pct: Some(self.rng.gen_range(0.02..=0.10)),
68            auto_renewal,
69            termination_notice_days: self.rng.gen_range(30..=120),
70            price_adjustment_clause: self.rng.gen_bool(0.3),
71            max_annual_price_increase_pct: if self.rng.gen_bool(0.4) {
72                Some(self.rng.gen_range(0.02..=0.05))
73            } else {
74                None
75            },
76        };
77
78        let slas = vec![
79            ContractSla {
80                metric_name: "on_time_delivery".to_string(),
81                target_value: 0.95,
82                minimum_value: 0.90,
83                breach_penalty_pct: 0.02,
84                measurement_frequency: "monthly".to_string(),
85            },
86            ContractSla {
87                metric_name: "defect_rate".to_string(),
88                target_value: 0.02,
89                minimum_value: 0.05,
90                breach_penalty_pct: 0.03,
91                measurement_frequency: "quarterly".to_string(),
92            },
93        ];
94
95        let line_items: Vec<ContractLineItem> = winning_bid
96            .line_items
97            .iter()
98            .map(|bl| {
99                let annual_qty = bl.quantity * Decimal::from(12);
100                ContractLineItem {
101                    line_number: bl.item_number,
102                    material_id: None,
103                    description: format!("Contract item {}", bl.item_number),
104                    unit_price: bl.unit_price,
105                    uom: "EA".to_string(),
106                    min_quantity: Some(bl.quantity),
107                    max_quantity: Some(annual_qty),
108                    quantity_released: Decimal::ZERO,
109                    value_released: Decimal::ZERO,
110                }
111            })
112            .collect();
113
114        // Total value = sum of max quantities * prices
115        let total_value: Decimal = line_items
116            .iter()
117            .map(|li| li.max_quantity.unwrap_or(Decimal::ZERO) * li.unit_price)
118            .sum();
119
120        ProcurementContract {
121            contract_id: self.uuid_factory.next().to_string(),
122            company_code: winning_bid.company_code.clone(),
123            contract_type,
124            status: ContractStatus::Active,
125            vendor_id: winning_bid.vendor_id.clone(),
126            title: format!(
127                "Contract with {} for {}",
128                winning_bid.vendor_id, category_id
129            ),
130            sourcing_project_id: sourcing_project_id.map(|s| s.to_string()),
131            bid_id: Some(winning_bid.bid_id.clone()),
132            start_date,
133            end_date,
134            total_value,
135            consumed_value: Decimal::ZERO,
136            terms,
137            slas,
138            line_items,
139            category_id: category_id.to_string(),
140            owner_id: owner_id.to_string(),
141            amendment_count: if self.rng.gen_bool(self.config.amendment_rate) {
142                self.rng.gen_range(1..=3)
143            } else {
144                0
145            },
146            previous_contract_id: None,
147        }
148    }
149
150    fn select_contract_type(&mut self) -> ContractType {
151        let dist = &self.config.type_distribution;
152        let r: f64 = self.rng.gen();
153        if r < dist.fixed_price {
154            ContractType::FixedPrice
155        } else if r < dist.fixed_price + dist.blanket {
156            ContractType::Blanket
157        } else if r < dist.fixed_price + dist.blanket + dist.time_and_materials {
158            ContractType::TimeAndMaterials
159        } else {
160            ContractType::ServiceAgreement
161        }
162    }
163}
164
165#[cfg(test)]
166#[allow(clippy::unwrap_used)]
167mod tests {
168    use super::*;
169    use datasynth_core::models::sourcing::{BidLineItem, BidStatus};
170
171    fn test_winning_bid() -> SupplierBid {
172        SupplierBid {
173            bid_id: "BID-001".to_string(),
174            rfx_id: "RFX-001".to_string(),
175            vendor_id: "V001".to_string(),
176            company_code: "C001".to_string(),
177            status: BidStatus::Submitted,
178            submission_date: NaiveDate::from_ymd_opt(2024, 3, 15).unwrap(),
179            line_items: vec![
180                BidLineItem {
181                    item_number: 1,
182                    unit_price: Decimal::from(50),
183                    quantity: Decimal::from(100),
184                    total_amount: Decimal::from(5000),
185                    lead_time_days: 10,
186                    notes: None,
187                },
188                BidLineItem {
189                    item_number: 2,
190                    unit_price: Decimal::from(25),
191                    quantity: Decimal::from(200),
192                    total_amount: Decimal::from(5000),
193                    lead_time_days: 15,
194                    notes: None,
195                },
196            ],
197            total_amount: Decimal::from(10000),
198            validity_days: 60,
199            payment_terms: "NET30".to_string(),
200            delivery_terms: Some("FCA".to_string()),
201            technical_summary: None,
202            is_on_time: true,
203            is_compliant: true,
204        }
205    }
206
207    #[test]
208    fn test_basic_generation() {
209        let mut gen = ContractGenerator::new(42);
210        let bid = test_winning_bid();
211        let start = NaiveDate::from_ymd_opt(2024, 4, 1).unwrap();
212        let contract = gen.generate_from_bid(&bid, Some("SP-001"), "CAT-001", "BUYER-01", start);
213
214        assert!(!contract.contract_id.is_empty());
215        assert_eq!(contract.company_code, "C001");
216        assert_eq!(contract.vendor_id, "V001");
217        assert_eq!(contract.status, ContractStatus::Active);
218        assert_eq!(contract.bid_id.as_deref(), Some("BID-001"));
219        assert_eq!(contract.sourcing_project_id.as_deref(), Some("SP-001"));
220        assert_eq!(contract.category_id, "CAT-001");
221        assert_eq!(contract.owner_id, "BUYER-01");
222        assert_eq!(contract.start_date, start);
223        assert!(contract.end_date > start);
224        assert!(contract.total_value > Decimal::ZERO);
225        assert_eq!(contract.consumed_value, Decimal::ZERO);
226        assert_eq!(contract.line_items.len(), 2);
227        assert_eq!(contract.slas.len(), 2);
228    }
229
230    #[test]
231    fn test_deterministic() {
232        let bid = test_winning_bid();
233        let start = NaiveDate::from_ymd_opt(2024, 4, 1).unwrap();
234
235        let mut gen1 = ContractGenerator::new(42);
236        let mut gen2 = ContractGenerator::new(42);
237
238        let r1 = gen1.generate_from_bid(&bid, Some("SP-001"), "CAT-001", "BUYER-01", start);
239        let r2 = gen2.generate_from_bid(&bid, Some("SP-001"), "CAT-001", "BUYER-01", start);
240
241        assert_eq!(r1.contract_id, r2.contract_id);
242        assert_eq!(r1.contract_type, r2.contract_type);
243        assert_eq!(r1.end_date, r2.end_date);
244        assert_eq!(r1.total_value, r2.total_value);
245        assert_eq!(r1.terms.payment_terms, r2.terms.payment_terms);
246        assert_eq!(r1.terms.auto_renewal, r2.terms.auto_renewal);
247        assert_eq!(r1.amendment_count, r2.amendment_count);
248    }
249
250    #[test]
251    fn test_field_constraints() {
252        let mut gen = ContractGenerator::new(99);
253        let bid = test_winning_bid();
254        let start = NaiveDate::from_ymd_opt(2024, 4, 1).unwrap();
255        let contract = gen.generate_from_bid(&bid, None, "CAT-001", "BUYER-01", start);
256
257        // Duration should be within configured range (12-36 months default)
258        let duration_days = (contract.end_date - contract.start_date).num_days();
259        assert!(duration_days >= 12 * 30 && duration_days <= 36 * 30);
260
261        // Terms constraints
262        assert!(contract.terms.termination_notice_days >= 30);
263        assert!(contract.terms.termination_notice_days <= 120);
264        assert_eq!(contract.terms.payment_terms, "NET30"); // From winning bid
265
266        // SLA metrics
267        for sla in &contract.slas {
268            assert!(!sla.metric_name.is_empty());
269            assert!(!sla.measurement_frequency.is_empty());
270        }
271
272        // Contract line items should match bid line items
273        assert_eq!(contract.line_items.len(), 2);
274        for line in &contract.line_items {
275            assert!(line.unit_price > Decimal::ZERO);
276            assert_eq!(line.quantity_released, Decimal::ZERO);
277            assert_eq!(line.value_released, Decimal::ZERO);
278        }
279
280        // No sourcing project when None passed
281        assert!(contract.sourcing_project_id.is_none());
282    }
283}
datasynth_generators/sourcing/contract_generator.rs

datasynth_generators/sourcing/
contract_generator.rs
