lib

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

plan.rs (5582B)


      1 use super::*;
      2 
      3 pub(super) fn record_version(catalog: i64) -> Result<u8, OperationError> {
      4     match catalog {
      5         2 => Ok(1),
      6         3..=20 => Ok(2),
      7         _ => Err(OperationError::RecoveryRequired),
      8     }
      9 }
     10 pub(super) fn plan_effect(
     11     command: &radroots_storage::inventory::CapturedInventoryCommand,
     12     before: Option<PoolSnapshot>,
     13     held_loss: radroots_domain::stock::StockTicks,
     14 ) -> Result<
     15     (
     16         PoolSnapshot,
     17         radroots_domain::stock::StockTicks,
     18         MovementKind,
     19     ),
     20     OperationError,
     21 > {
     22     use radroots_domain::stock::{AvailableStockCorrection, StockError};
     23     use radroots_storage::inventory::CapturedInventoryCommand;
     24     match command {
     25         CapturedInventoryCommand::MapOption(command) => {
     26             let pool = before.ok_or(OperationError::StaleState)?;
     27             if pool.id() != command.input().pool_id() {
     28                 return Err(OperationError::RecoveryRequired);
     29             }
     30             Ok((
     31                 pool,
     32                 radroots_domain::stock::StockTicks::ZERO,
     33                 MovementKind::Introduced,
     34             ))
     35         }
     36         CapturedInventoryCommand::CreatePool(command) => {
     37             if before.is_some() {
     38                 return Err(OperationError::StaleState);
     39             }
     40             let input = command.input();
     41             let quantity = input.initial_ticks();
     42             let balances = PoolBalances::new(
     43                 quantity,
     44                 PhysicalBalances {
     45                     available: quantity,
     46                     ..PhysicalBalances::ZERO
     47                 },
     48             )
     49             .map_err(|_| OperationError::InvalidCommand)?;
     50             Ok((
     51                 PoolSnapshot::new(
     52                     input.id(),
     53                     input.unit(),
     54                     balances,
     55                     Sequence::new(1).map_err(|_| OperationError::RecoveryRequired)?,
     56                 ),
     57                 quantity,
     58                 MovementKind::Introduced,
     59             ))
     60         }
     61         CapturedInventoryCommand::CorrectPool(command) => {
     62             let input = command.input();
     63             let before = before.ok_or(OperationError::StaleState)?;
     64             if before.id() != input.pool_id() || before.version() != input.expected_version() {
     65                 return Err(OperationError::StaleState);
     66             }
     67             let quantity = before
     68                 .unit()
     69                 .ticks_for(
     70                     radroots_domain::Quantity::new(input.amount().amount(), before.unit().unit())
     71                         .map_err(|_| OperationError::InvalidCommand)?,
     72                 )
     73                 .map_err(|_| OperationError::InvalidCommand)?;
     74             let available_quantity = quantity
     75                 .checked_sub(held_loss)
     76                 .map_err(|_| OperationError::RecoveryRequired)?;
     77             if held_loss != radroots_domain::stock::StockTicks::ZERO
     78                 && (input.kind() == AvailableStockCorrection::Add
     79                     || available_quantity != before.balances().physical().available)
     80             {
     81                 return Err(OperationError::RecoveryRequired);
     82             }
     83             let balances = if available_quantity == radroots_domain::stock::StockTicks::ZERO {
     84                 before.balances()
     85             } else {
     86                 before
     87                     .balances()
     88                     .correct_available(input.kind(), available_quantity)
     89                     .map_err(|error| match error {
     90                         StockError::Underflow => OperationError::StaleState,
     91                         StockError::OutOfRange => WorkspaceError::Capacity.into(),
     92                         _ => OperationError::InvalidCommand,
     93                     })?
     94             };
     95             let balances = if held_loss == radroots_domain::stock::StockTicks::ZERO {
     96                 Ok(balances)
     97             } else {
     98                 balances.deplete_held(
     99                     radroots_domain::stock::HeldStockCategory::Committed,
    100                     match input.kind() {
    101                         AvailableStockCorrection::Remove => {
    102                             radroots_domain::stock::HeldStockLoss::Removal
    103                         }
    104                         AvailableStockCorrection::Spoil => {
    105                             radroots_domain::stock::HeldStockLoss::Spoilage
    106                         }
    107                         AvailableStockCorrection::Add => {
    108                             return Err(OperationError::RecoveryRequired);
    109                         }
    110                     },
    111                     held_loss,
    112                 )
    113             }
    114             .map_err(|error| match error {
    115                 StockError::Underflow => OperationError::StaleState,
    116                 StockError::OutOfRange => WorkspaceError::Capacity.into(),
    117                 _ => OperationError::InvalidCommand,
    118             })?;
    119             let version = Sequence::new(
    120                 before
    121                     .version()
    122                     .get()
    123                     .checked_add(1)
    124                     .ok_or(WorkspaceError::Capacity)?,
    125             )
    126             .map_err(|_| WorkspaceError::Capacity)?;
    127             let movement = match input.kind() {
    128                 AvailableStockCorrection::Add => MovementKind::Introduced,
    129                 AvailableStockCorrection::Remove => MovementKind::Removed,
    130                 AvailableStockCorrection::Spoil => MovementKind::Wasted,
    131             };
    132             Ok((
    133                 PoolSnapshot::new(before.id(), before.unit(), balances, version),
    134                 quantity,
    135                 movement,
    136             ))
    137         }
    138     }
    139 }