lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

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 }