[FIX] round in all cases to the required decimal precision

Author: theangryangel

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "odoo-rapid-quant"
-version = "0.1.3"
+version = "0.1.4"
 license = "LGPL-3.0-or-later"
 edition = "2024"
 rust-version = "1.85"

Cargo.toml

@@ -13,6 +13,14 @@ use crate::{
 
 pub mod v15;
 
+pub fn dp_from_rounding(rounding: Decimal) -> u32 {
+    if rounding >= Decimal::ONE {
+        0
+    } else {
+        rounding.scale()
+    }
+}
+
 #[async_trait]
 pub trait OdooAdapter: Send + Sync {
     fn major(&self) -> OdooVersion;

src/dialect/mod.rs

@@ -7,7 +7,7 @@ use rust_decimal::{Decimal, RoundingStrategy};
 use sqlx::{PgPool, QueryBuilder};
 
 use crate::{
-    dialect::OdooAdapter,
+    dialect::{OdooAdapter, dp_from_rounding},
     odoo::OdooVersion,
     product::{Product, ProductId, Quant},
     warehouse::Warehouse,
@@ -80,7 +80,7 @@ impl OdooAdapter for Adapter {
             .fetch(pool);
 
         while let Some((product_id, rounding)) = simple_stream.try_next().await? {
-            let _ = catalogue.insert(product_id, Product::Simple(rounding.scale()));
+            let _ = catalogue.insert(product_id, Product::Simple(dp_from_rounding(rounding)));
             let _ = graph.add_node(product_id);
         }
 
@@ -105,7 +105,8 @@ impl OdooAdapter for Adapter {
                 .build_query_as::<(ProductId, Decimal)>()
                 .fetch(pool);
             while let Some((product_id, rounding)) = stream.try_next().await? {
-                let _ = catalogue.insert(product_id, Product::Commingled(rounding.scale()));
+                let _ =
+                    catalogue.insert(product_id, Product::Commingled(dp_from_rounding(rounding)));
                 let _ = graph.add_node(product_id);
             }
         }
@@ -146,9 +147,8 @@ impl OdooAdapter for Adapter {
                 .fetch(pool);
 
             while let Some((product_id, bom_type, quantity, rounding)) = stream.try_next().await? {
-                let dp = rounding.scale();
-                let quantity =
-                    quantity.round_dp_with_strategy(dp, RoundingStrategy::MidpointAwayFromZero);
+                let dp = dp_from_rounding(rounding);
+                let quantity = quantity.round_dp_with_strategy(dp, RoundingStrategy::ToZero);
                 let product = match bom_type.as_str() {
                     "phantom" => Product::MrpPhantom(quantity, dp),
                     "normal" => Product::MrpNormal(quantity, dp),
@@ -207,8 +207,8 @@ impl OdooAdapter for Adapter {
             while let Some((parent, child, child_qty, rounding)) = stream.try_next().await? {
                 if graph.contains_node(parent) && graph.contains_node(child) {
                     let child_qty = child_qty.round_dp_with_strategy(
-                        rounding.scale(),
-                        RoundingStrategy::MidpointAwayFromZero,
+                        dp_from_rounding(rounding),
+                        RoundingStrategy::ToZero,
                     );
                     let _ = graph.add_edge(child, parent, child_qty);
                 }

src/dialect/v15.rs

@@ -373,14 +373,23 @@ impl Graph {
                 )
             });
             if info.is_simple() {
+                let dp = info.dp();
                 let mut avail = Availability::default();
 
                 if let Some(quant) = raw_quants.get(&product) {
-                    avail.quantity = quant.quantity;
-                    avail.reserved = quant.reserved;
-
-                    avail.incoming = quant.incoming;
-                    avail.outgoing = quant.outgoing;
+                    avail.quantity = quant
+                        .quantity
+                        .round_dp_with_strategy(dp, RoundingStrategy::ToZero);
+                    avail.reserved = quant
+                        .reserved
+                        .round_dp_with_strategy(dp, RoundingStrategy::ToZero);
+
+                    avail.incoming = quant
+                        .incoming
+                        .round_dp_with_strategy(dp, RoundingStrategy::ToZero);
+                    avail.outgoing = quant
+                        .outgoing
+                        .round_dp_with_strategy(dp, RoundingStrategy::ToZero);
                     // Required to seed the buildable for future things
                     // Realistically this isn't actually helpful as a figure for a simple, but this
                     // is the least impactful solution here
@@ -403,23 +412,41 @@ impl Graph {
             for edge in graph.edges_directed(product, petgraph::Incoming) {
                 let (dependency, required_qty) = (edge.source(), *edge.weight());
                 if let Some(dependency_stock) = stock_cache.get(&dependency) {
-                    // only do this work if we need to
-                    quantity.push(dependency_stock.quantity / required_qty);
-                    reserved.push(dependency_stock.reserved / required_qty);
-
-                    incoming.push(dependency_stock.incoming / required_qty);
-                    outgoing.push(dependency_stock.outgoing / required_qty);
-
-                    free_imm.push(dependency_stock.free_immediately() / required_qty);
-                    virtual_avail.push(dependency_stock.virtual_available() / required_qty);
-
                     let dependency_dp = catalogue.get(&product).unwrap_or_else(|| {
                         panic!(
                             "Somehow we have a product in the graph not in the catalogue?!: {:?}",
                             product
                         )
                     }).dp();
 
+                    // only do this work if we need to
+                    quantity.push(
+                        (dependency_stock.quantity / required_qty)
+                            .round_dp_with_strategy(dependency_dp, RoundingStrategy::ToZero),
+                    );
+                    reserved.push(
+                        (dependency_stock.reserved / required_qty)
+                            .round_dp_with_strategy(dependency_dp, RoundingStrategy::ToZero),
+                    );
+
+                    incoming.push(
+                        (dependency_stock.incoming / required_qty)
+                            .round_dp_with_strategy(dependency_dp, RoundingStrategy::ToZero),
+                    );
+                    outgoing.push(
+                        (dependency_stock.outgoing / required_qty)
+                            .round_dp_with_strategy(dependency_dp, RoundingStrategy::ToZero),
+                    );
+
+                    free_imm.push(
+                        (dependency_stock.free_immediately() / required_qty)
+                            .round_dp_with_strategy(dependency_dp, RoundingStrategy::ToZero),
+                    );
+                    virtual_avail.push(
+                        (dependency_stock.virtual_available() / required_qty)
+                            .round_dp_with_strategy(dependency_dp, RoundingStrategy::ToZero),
+                    );
+
                     buildable.push(
                         (dependency_stock.buildable / required_qty)
                             .round_dp_with_strategy(dependency_dp, RoundingStrategy::ToZero),