variable_price.rs (3894B)
1 use crate::{ 2 DiscountBps, Money, MoneyError, PositiveDecimal, PricingError, Quantity, 3 listing::MeasurementUnit, pricing::net_line_minor, 4 }; 5 use core::fmt; 6 7 /// Bounded measurement-price data, without agreement installation or stock. 8 /// The enclosing offer or agreement determines whether bounds describe one 9 /// sale unit or one complete line; this value performs no implicit scaling. 10 #[derive(Clone, Copy, Eq, PartialEq)] 11 #[cfg_attr(feature = "serde", derive(serde::Serialize))] 12 pub struct VariableWeight { 13 measurement_unit: MeasurementUnit, 14 minimum: PositiveDecimal, 15 maximum: PositiveDecimal, 16 rate: Money, 17 basis: PositiveDecimal, 18 maximum_total: Money, 19 } 20 21 impl VariableWeight { 22 /// Checks inclusive positive bounds, count units, currency and a feasible cap. 23 /// The cap may restrict the range's more expensive measurements; the minimum 24 /// must remain admissible. Zero rate/cap are explicit, not quote-required. 25 pub fn new( 26 measurement_unit: MeasurementUnit, 27 minimum: PositiveDecimal, 28 maximum: PositiveDecimal, 29 rate: Money, 30 basis: PositiveDecimal, 31 maximum_total: Money, 32 ) -> Result<Self, PricingError> { 33 if minimum > maximum 34 || Quantity::new(minimum.amount(), measurement_unit).is_err() 35 || Quantity::new(maximum.amount(), measurement_unit).is_err() 36 { 37 return Err(PricingError::InvalidMeasurementRange); 38 } 39 if rate.currency() != maximum_total.currency() { 40 return Err(MoneyError::CurrencyMismatch.into()); 41 } 42 let value = Self { 43 measurement_unit, 44 minimum, 45 maximum, 46 rate, 47 basis, 48 maximum_total, 49 }; 50 value.total(minimum)?; 51 Ok(value) 52 } 53 54 /// Returns the exact authorized measurement identity. 55 pub const fn measurement_unit(self) -> MeasurementUnit { 56 self.measurement_unit 57 } 58 /// Returns the inclusive positive lower bound. 59 pub const fn minimum(self) -> PositiveDecimal { 60 self.minimum 61 } 62 /// Returns the inclusive positive upper bound. 63 pub const fn maximum(self) -> PositiveDecimal { 64 self.maximum 65 } 66 /// Returns the exact currency/rate used for final measurement pricing. 67 pub const fn rate(self) -> Money { 68 self.rate 69 } 70 /// Returns the strictly positive measurement price basis. 71 pub const fn basis(self) -> PositiveDecimal { 72 self.basis 73 } 74 /// Returns the explicit monetary authorization ceiling. 75 pub const fn maximum_total(self) -> Money { 76 self.maximum_total 77 } 78 79 /// Prices an exact same-unit in-range measurement and enforces the cap. 80 /// No implicit conversion, discount, amendment or physical consumption occurs. 81 pub fn total_at(self, measurement: Quantity) -> Result<Money, PricingError> { 82 if measurement.unit() != self.measurement_unit { 83 return Err(PricingError::MeasurementUnitMismatch); 84 } 85 if measurement.amount() < self.minimum.amount() 86 || measurement.amount() > self.maximum.amount() 87 { 88 return Err(PricingError::MeasurementOutOfRange); 89 } 90 let amount = PositiveDecimal::new(measurement.amount()) 91 .map_err(|_| PricingError::MeasurementOutOfRange)?; 92 self.total(amount) 93 } 94 95 fn total(self, amount: PositiveDecimal) -> Result<Money, PricingError> { 96 let minor = net_line_minor(self.rate.minor(), amount, self.basis, DiscountBps::NONE)?; 97 if minor > self.maximum_total.minor() { 98 return Err(PricingError::CapExceeded); 99 } 100 Ok(Money::new(self.rate.currency(), minor)) 101 } 102 } 103 104 impl fmt::Debug for VariableWeight { 105 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { 106 f.write_str("VariableWeight(<redacted>)") 107 } 108 }