Merge branch 'master' into feature/multiplePartImage#t2

Author: matmair

=0.9.4

@@ -267,7 +267,7 @@ Simple mathematical operators are available, as demonstrated in the example temp
 
 ### Input Types
 
-These mathematical functions accept inputs of various input types, and attempt to perform the operation accordingly. Note that any inputs which are provided as strings will be converted to floating point numbers before the operation is performed.
+These mathematical functions accept inputs of various input types, and attempt to perform the operation accordingly. Note that any inputs which are provided as strings or numbers will be converted to `Decimal` class types before the operation is performed.
 
 ### add
 

docs/docs/report/helpers.md

@@ -6,6 +6,7 @@
 from urllib.parse import urljoin
 
 from django.conf import settings
+from django.core.exceptions import ValidationError
 from django.core.validators import URLValidator
 from django.db.utils import OperationalError, ProgrammingError
 from django.utils.translation import gettext_lazy as _
@@ -184,6 +185,7 @@ def render_currency(
     money: Money,
     decimal_places: Optional[int] = None,
     currency: Optional[str] = None,
+    multiplier: Optional[Decimal] = None,
     min_decimal_places: Optional[int] = None,
     max_decimal_places: Optional[int] = None,
     include_symbol: bool = True,
@@ -194,6 +196,7 @@ def render_currency(
         money: The Money instance to be rendered
         decimal_places: The number of decimal places to render to. If unspecified, uses the PRICING_DECIMAL_PLACES setting.
         currency: Optionally convert to the specified currency
+        multiplier: An optional multiplier to apply to the money amount before rendering
         min_decimal_places: The minimum number of decimal places to render to. If unspecified, uses the PRICING_DECIMAL_PLACES_MIN setting.
         max_decimal_places: The maximum number of decimal places to render to. If unspecified, uses the PRICING_DECIMAL_PLACES setting.
         include_symbol: If True, include the currency symbol in the output
@@ -202,7 +205,16 @@ def render_currency(
         return '-'
 
     if type(money) is not Money:
-        return '-'
+        # Try to convert to a Money object
+        try:
+            money = Money(
+                Decimal(str(money)),
+                currency or get_global_setting('INVENTREE_DEFAULT_CURRENCY'),
+            )
+        except Exception:
+            raise ValidationError(
+                f"render_currency: {_('Invalid money value')}: '{money}' ({type(money).__name__})"
+            )
 
     if currency is not None:
         # Attempt to convert to the provided currency
@@ -212,6 +224,14 @@ def render_currency(
         except Exception:
             pass
 
+    if multiplier is not None:
+        try:
+            money *= Decimal(str(multiplier).strip())
+        except Exception:
+            raise ValidationError(
+                f"render_currency: {_('Invalid multiplier value')}: '{multiplier}' ({type(multiplier).__name__})"
+            )
+
     if min_decimal_places is None or not isinstance(min_decimal_places, (int, float)):
         min_decimal_places = get_global_setting('PRICING_DECIMAL_PLACES_MIN', 0)
 

src/backend/InvenTree/InvenTree/helpers_model.py

@@ -70,12 +70,6 @@ def str2bool(x, *args, **kwargs):
     return InvenTree.helpers.str2bool(x)
 
 
-@register.simple_tag()
-def add(x, y, *args, **kwargs):
-    """Add two numbers together."""
-    return x + y
-
-
 @register.simple_tag()
 def to_list(*args):
     """Return the input arguments as list."""

src/backend/InvenTree/InvenTree/templatetags/inventree_extras.py

@@ -39,10 +39,6 @@ def test_str2bool(self):
         self.assertEqual(int(inventree_extras.str2bool('none')), False)
         self.assertEqual(int(inventree_extras.str2bool('off')), False)
 
-    def test_add(self):
-        """Test that the 'add."""
-        self.assertEqual(int(inventree_extras.add(3, 5)), 8)
-
     def test_inventree_instance_name(self):
         """Test the 'instance name' setting."""
         self.assertEqual(inventree_extras.inventree_instance_name(), 'InvenTree')

src/backend/InvenTree/part/test_part.py

@@ -546,6 +546,9 @@ def print(self, items: list, request=None, output=None, **kwargs) -> DataOutput:
                     msg = _('Template syntax error')
                     output.mark_failure(msg)
                     raise ValidationError(f'{msg}: {e!s}')
+                except ValidationError as e:
+                    output.mark_failure(str(e))
+                    raise e
                 except Exception as e:
                     msg = _('Error rendering report')
                     output.mark_failure(msg)
@@ -582,6 +585,9 @@ def print(self, items: list, request=None, output=None, **kwargs) -> DataOutput:
                         msg = _('Template syntax error')
                         output.mark_failure(error=_('Template syntax error'))
                         raise ValidationError(f'{msg}: {e!s}')
+                    except ValidationError as e:
+                        output.mark_failure(str(e))
+                        raise e
                     except Exception as e:
                         msg = _('Error rendering report')
                         output.mark_failure(error=msg)

src/backend/InvenTree/report/models.py

@@ -4,7 +4,7 @@
 import logging
 import os
 from datetime import date, datetime
-from decimal import Decimal
+from decimal import Decimal, InvalidOperation
 from typing import Any, Optional, Union
 
 from django import template
@@ -413,54 +413,161 @@ def internal_link(link, text) -> str:
     return mark_safe(f'<a href="{url}">{text}</a>')
 
 
-def destringify(value: Any) -> Any:
-    """Convert a string value into a float.
+def make_decimal(value: Any) -> Any:
+    """Convert an input value into a Decimal.
 
-    - If the value is a string, attempt to convert it to a float.
-    - If conversion fails, return the original string.
-    - If the value is not a string, return it unchanged.
+    - Converts [string, int, float] types into Decimal
+    - If conversion fails, returns the original value
 
     The purpose of this function is to provide "seamless" math operations in templates,
     where numeric values may be provided as strings, or converted to strings during template rendering.
     """
-    if isinstance(value, str):
-        value = value.strip()
+    if any(isinstance(value, t) for t in [int, float, str]):
         try:
-            return float(value)
-        except ValueError:
-            return value
+            value = Decimal(str(value).strip())
+        except (InvalidOperation, TypeError, ValueError):
+            logger.warning(
+                'make_decimal: Failed to convert value to Decimal: %s (%s)',
+                value,
+                type(value),
+            )
 
     return value
 
 
+def cast_to_type(value: Any, cast: type) -> Any:
+    """Attempt to cast a value to the provided type.
+
+    If casting fails, the original value is returned.
+    """
+    if cast is not None:
+        try:
+            value = cast(value)
+        except (ValueError, TypeError):
+            pass
+
+    return value
+
+
+def debug_vars(x: Any, y: Any) -> str:
+    """Return a debug string showing the types and values of two variables."""
+    return f": x='{x}' ({type(x).__name__}), y='{y}' ({type(y).__name__})"
+
+
 @register.simple_tag()
-def add(x: Any, y: Any) -> Any:
-    """Add two numbers (or number like values) together."""
-    return destringify(x) + destringify(y)
+def add(x: Any, y: Any, cast: Optional[type] = None) -> Any:
+    """Add two numbers (or number like values) together.
+
+    Arguments:
+        x: The first value to add
+        y: The second value to add
+        cast: Optional type to cast the result to (e.g. int, float, str)
+
+    Raises:
+        ValidationError: If the values cannot be added together
+    """
+    try:
+        result = make_decimal(x) + make_decimal(y)
+    except (InvalidOperation, TypeError, ValueError):
+        raise ValidationError(
+            _('Cannot add values of incompatible types') + debug_vars(x, y)
+        )
+    return cast_to_type(result, cast)
 
 
 @register.simple_tag()
-def subtract(x: Any, y: Any) -> Any:
-    """Subtract one number (or number-like value) from another."""
-    return destringify(x) - destringify(y)
+def subtract(x: Any, y: Any, cast: Optional[type] = None) -> Any:
+    """Subtract one number (or number-like value) from another.
+
+    Arguments:
+        x: The value to be subtracted from
+        y: The value to be subtracted
+        cast: Optional type to cast the result to (e.g. int, float, str)
+
+    Raises:
+        ValidationError: If the values cannot be subtracted
+    """
+    try:
+        result = make_decimal(x) - make_decimal(y)
+    except (InvalidOperation, TypeError, ValueError):
+        raise ValidationError(
+            _('Cannot subtract values of incompatible types') + debug_vars(x, y)
+        )
+
+    return cast_to_type(result, cast)
 
 
 @register.simple_tag()
-def multiply(x: Any, y: Any) -> Any:
-    """Multiply two numbers (or number-like values) together."""
-    return destringify(x) * destringify(y)
+def multiply(x: Any, y: Any, cast: Optional[type] = None) -> Any:
+    """Multiply two numbers (or number-like values) together.
+
+    Arguments:
+        x: The first value to multiply
+        y: The second value to multiply
+        cast: Optional type to cast the result to (e.g. int, float, str)
+
+    Raises:
+        ValidationError: If the values cannot be multiplied together
+    """
+    try:
+        result = make_decimal(x) * make_decimal(y)
+    except (InvalidOperation, TypeError, ValueError):
+        raise ValidationError(
+            _('Cannot multiply values of incompatible types') + debug_vars(x, y)
+        )
+
+    return cast_to_type(result, cast)
 
 
 @register.simple_tag()
-def divide(x: Any, y: Any) -> Any:
-    """Divide one number (or number-like value) by another."""
-    return destringify(x) / destringify(y)
+def divide(x: Any, y: Any, cast: Optional[type] = None) -> Any:
+    """Divide one number (or number-like value) by another.
+
+    Arguments:
+        x: The value to be divided
+        y: The value to divide by
+        cast: Optional type to cast the result to (e.g. int, float, str)
+
+    Raises:
+        ValidationError: If the values cannot be divided
+    """
+    try:
+        result = make_decimal(x) / make_decimal(y)
+    except (InvalidOperation, TypeError, ValueError):
+        raise ValidationError(
+            _('Cannot divide values of incompatible types') + debug_vars(x, y)
+        )
+    except ZeroDivisionError:
+        raise ValidationError(_('Cannot divide by zero') + debug_vars(x, y))
+
+    return cast_to_type(result, cast)
 
 
 @register.simple_tag()
-def modulo(x: Any, y: Any) -> Any:
-    """Calculate the modulo of one number (or number-like value) by another."""
-    return destringify(x) % destringify(y)
+def modulo(x: Any, y: Any, cast: Optional[type] = None) -> Any:
+    """Calculate the modulo of one number (or number-like value) by another.
+
+    Arguments:
+        x: The first value to be used in the modulo operation
+        y: The second value to be used in the modulo operation
+        cast: Optional type to cast the result to (e.g. int, float, str)
+
+    Raises:
+        ValidationError: If the values cannot be used in a modulo operation
+    """
+    try:
+        result = make_decimal(x) % make_decimal(y)
+    except (InvalidOperation, TypeError, ValueError):
+        raise ValidationError(
+            _('Cannot perform modulo operation with values of incompatible types')
+            + debug_vars(x, y)
+        )
+    except ZeroDivisionError:
+        raise ValidationError(
+            _('Cannot perform modulo operation with divisor of zero') + debug_vars(x, y)
+        )
+
+    return cast_to_type(result, cast)
 
 
 @register.simple_tag