Files
Django_TasksApp/main/food/services/inventory_consumption.py
T

287 lines
15 KiB
Python

"""Atomic package allocation shared by the web inventory and MCP API."""
import hashlib
from decimal import Decimal, InvalidOperation, ROUND_HALF_UP
from django.contrib.auth import get_user_model
from django.db import transaction
from django.utils import timezone
from food.models import FoodProduct, InventoryConsumption, InventoryConsumptionLine, KitchenInventoryItem
FACTORS = {'mg': ('mass', Decimal('.001')), 'g': ('mass', Decimal(1)),
'kg': ('mass', Decimal(1000)), 'ml': ('volume', Decimal(1)),
'L': ('volume', Decimal(1000)), 'pieces': ('pieces', Decimal(1)),
'packs': ('packs', Decimal(1)), 'inner_packs': ('inner_packs', Decimal(1)),
'portions': ('portions', Decimal(1))}
class StockError(ValueError):
pass
def normalized(amount, unit):
if unit not in FACTORS:
raise StockError('Unsupported unit.')
try:
input_value = Decimal(str(amount))
value = input_value * FACTORS[unit][1]
except (InvalidOperation, TypeError):
raise StockError('Enter a valid amount.') from None
if (not value.is_finite() or value <= 0 or value > Decimal('9999999.999') or
input_value != input_value.quantize(Decimal('.001')) or
value != value.quantize(Decimal('.001'))):
raise StockError('Enter a positive amount with at most three decimal places in the base unit.')
if FACTORS[unit][0] in ('pieces', 'packs', 'portions') and value != value.to_integral_value():
raise StockError('Count units must be whole numbers.')
return value, FACTORS[unit][0]
def _package_stock(item):
if item.original_amount is None:
return Decimal(item.quantity), 'packs', 'packs'
unit = item.inventory_unit
return item.remaining_amount * FACTORS[unit][1], FACTORS[unit][0], unit
def _nested_amount_for_pieces(item, piece_count):
"""Return the rounded package-unit balance implied by whole nested pieces."""
full_packs, loose_pieces = divmod(piece_count, item.pieces_per_inner_pack)
amount = item.inner_pack_amount * full_packs
if loose_pieces:
amount += (item.inner_pack_amount * loose_pieces / item.pieces_per_inner_pack).quantize(
Decimal('.001'), rounding=ROUND_HALF_UP)
return amount
def _nested_count_for_amount(item, remaining_amount):
"""Find an exact whole-piece balance for a measured remainder."""
low, high = 0, item.remaining_pieces
while low < high:
middle = (low + high) // 2
if _nested_amount_for_pieces(item, middle) < remaining_amount:
low = middle + 1
else:
high = middle
for candidate in (low, low - 1):
if 0 <= candidate <= item.remaining_pieces and _nested_amount_for_pieces(item, candidate) == remaining_amount:
return candidate
raise StockError('This measured amount does not match a whole number of nested pieces.')
def stock(user, product, location_id=None, lock=False):
if product.owner_id != user.pk:
raise StockError('Product not found.')
qs = KitchenInventoryItem.objects.filter(user=user, product=product, archived_at__isnull=True)
if location_id is not None:
qs = qs.filter(location_id=location_id)
if lock:
qs = qs.select_for_update()
return list(qs.order_by('pk'))
def materialize_packages(item):
"""Turn a newly added count into separate packages when a size is known."""
if item.original_amount is None and item.pieces_per_package is not None:
item.original_amount = Decimal(item.pieces_per_package)
item.remaining_amount = Decimal(item.remaining_pieces)
item.inventory_unit = 'pieces'
if item.original_amount is None and item.product.package_amount and item.product.package_unit:
item.original_amount = item.product.package_amount
item.remaining_amount = item.product.package_amount
item.inventory_unit = item.product.package_unit
if item.original_amount is None:
return item
count = item.quantity
item.quantity = 1
item.full_clean()
item.save()
for _ in range(count - 1):
KitchenInventoryItem.objects.create(user=item.user, product=item.product, quantity=1,
location=item.location, category=item.category, notes=item.notes, opened=False,
original_amount=item.original_amount, remaining_amount=item.original_amount,
inventory_unit=item.inventory_unit, pieces_per_package=item.pieces_per_package,
remaining_pieces=item.pieces_per_package, piece_amount=item.piece_amount,
inner_packs_per_package=item.inner_packs_per_package,
pieces_per_inner_pack=item.pieces_per_inner_pack, inner_pack_amount=item.inner_pack_amount,
inner_pack_label=item.inner_pack_label, piece_label=item.piece_label,
best_before=item.best_before,
purchase_batch=item.purchase_batch)
return item
def preview(user, product, amount, unit, package_id=None, location_id=None, lock=False):
requested, dimension = normalized(amount, unit)
items = stock(user, product, location_id, lock)
if package_id is not None:
items = [item for item in items if str(item.api_id) == str(package_id)]
if not items:
raise StockError('Package not found.')
compatible = []
missing_piece_amount = False
for item in items:
available, kind, native_unit = _package_stock(item)
if dimension == 'inner_packs' and item.inner_packs_per_package:
available = Decimal(item.remaining_pieces // item.pieces_per_inner_pack)
kind = 'inner_packs'
if dimension == 'pieces' and item.pieces_per_package is not None:
if item.inner_packs_per_package is None and kind != 'pieces' and item.piece_amount is None:
missing_piece_amount = True
continue
available = Decimal(item.remaining_pieces)
kind = 'pieces'
if kind == dimension and available > 0:
compatible.append((item, available, native_unit))
if not compatible and missing_piece_amount:
raise StockError('Set an explicit amount per piece before consuming this weighed package by pieces.')
compatible.sort(key=lambda row: (not row[0].opened, row[0].best_before is None,
row[0].best_before or timezone.datetime.max.date(),
row[0].added_at, row[0].pk))
total = sum((row[1] for row in compatible), Decimal(0))
left = requested
deductions = []
for item, available, native_unit in compatible:
if left <= 0:
break
take = min(left, available)
native_factor = FACTORS[native_unit][1]
before_native = item.remaining_amount if item.remaining_amount is not None else Decimal(item.quantity)
before_pieces = item.remaining_pieces
after_pieces = before_pieces
if item.inner_packs_per_package is not None and dimension in ('pieces', 'inner_packs'):
piece_count = int(take) * (item.pieces_per_inner_pack if dimension == 'inner_packs' else 1)
after_pieces = before_pieces - piece_count
native = before_native - _nested_amount_for_pieces(item, after_pieces)
elif dimension == 'pieces' and FACTORS[native_unit][0] != 'pieces':
native = item.piece_amount * take
if take == item.remaining_pieces:
native = before_native # The last piece takes the precise residual.
elif native > before_native:
raise StockError('The amount per piece exceeds remaining package stock.')
else:
native = take / native_factor
if before_pieces is not None and item.inner_packs_per_package is None:
if dimension == 'pieces':
after_pieces -= int(take)
elif take == available:
after_pieces = 0
elif item.piece_amount is None:
raise StockError('Set an explicit amount per piece before partially consuming measured stock.')
else:
piece_count = native / item.piece_amount
if piece_count != piece_count.to_integral_value():
raise StockError('This amount does not correspond to whole pieces at the configured amount per piece.')
if piece_count > before_pieces:
raise StockError('The amount exceeds the remaining piece count.')
after_pieces -= int(piece_count)
elif before_pieces is not None and item.inner_packs_per_package is not None and dimension not in ('pieces', 'inner_packs'):
after_pieces = 0 if take == available else _nested_count_for_amount(item, before_native - native)
if native != native.quantize(Decimal('.001')):
raise StockError('The piece conversion needs more than three decimal places; use a measured amount instead.')
nested_balance = None
if item.inner_packs_per_package is not None:
full_inner, loose = divmod(after_pieces, item.pieces_per_inner_pack)
balance = []
if full_inner:
label = item.inner_pack_label or 'inner pack'
balance.append(f'{full_inner} unopened {label}{"s" if full_inner != 1 else ""}')
if loose:
label = item.inner_pack_label or 'inner pack'
piece_label = item.piece_label or 'piece'
balance.append(f'1 opened {label} with {loose} {piece_label}{"s" if loose != 1 else ""} left')
nested_balance = ' + '.join(balance) if balance else 'no inner packs remaining'
deductions.append({'package': item, 'amount': native, 'unit': native_unit,
'before': before_native, 'after': before_native - native,
'before_pieces': before_pieces, 'after_pieces': after_pieces,
'after_inner_pack_balance': nested_balance})
left -= take
factor = FACTORS[unit][1]
return {'requested': requested / factor, 'unit': unit, 'total': total / factor,
'shortage': max(left, Decimal(0)) / factor, 'deductions': deductions}
def consume(user, product, amount, unit, *, package_id=None, source='manual',
source_reference='', description='', idempotency_key='', allow_partial=False):
if source not in ('manual', 'mcp', 'recipe'):
raise StockError('Invalid source.')
if idempotency_key and len(idempotency_key) > 128:
raise StockError('Idempotency key is too long.')
requested, _ = normalized(amount, unit)
signature = hashlib.sha256(f'{product.pk}|{requested}|{unit}|{package_id or ""}|{source}|{source_reference}|{description}|{allow_partial}'.encode()).hexdigest()
with transaction.atomic():
# Serializes even on databases where select_for_update on inventory rows is limited.
get_user_model().objects.select_for_update().get(pk=user.pk)
if idempotency_key:
previous = InventoryConsumption.objects.filter(user=user, idempotency_key=idempotency_key).first()
if previous:
if previous.request_signature != signature:
raise StockError('Idempotency key was used for another request.')
return previous
plan = preview(user, product, amount, unit, package_id, lock=True)
if plan['shortage'] and not allow_partial:
raise StockError(f"Insufficient stock: shortage {plan['shortage']} {unit}.")
if not plan['deductions']:
raise StockError('No compatible stock available.')
consumed = plan['requested'] - plan['shortage']
operation = InventoryConsumption.objects.create(user=user, product=product, amount=consumed,
unit=unit, source=source, source_reference=source_reference[:255],
description=description[:255], idempotency_key=idempotency_key, request_signature=signature)
for deduction in plan['deductions']:
item = deduction['package']
before_opened, before_opened_at = item.opened, item.opened_at
if item.original_amount is None:
item.quantity = int(deduction['after']) or 1
else:
item.remaining_amount = deduction['after']
item.remaining_pieces = deduction['after_pieces']
if deduction['after'] == 0:
item.archived_at = timezone.now()
elif not item.opened:
item.opened = True
item.opened_at = timezone.now()
item.save(update_fields=('quantity', 'remaining_amount', 'remaining_pieces', 'opened', 'opened_at', 'archived_at', 'updated_at'))
InventoryConsumptionLine.objects.create(transaction=operation, package=item,
amount=deduction['amount'], unit=deduction['unit'], before_amount=deduction['before'],
after_amount=deduction['after'], before_opened=before_opened,
before_opened_at=before_opened_at, before_pieces=deduction['before_pieces'],
after_pieces=deduction['after_pieces'])
return operation
def undo(user, operation_id):
with transaction.atomic():
get_user_model().objects.select_for_update().get(pk=user.pk)
operation = InventoryConsumption.objects.filter(user=user, pk=operation_id).first()
if not operation or operation.reverses_id or hasattr(operation, 'reversal'):
raise StockError('Consumption cannot be undone.')
lines = list(operation.lines.select_related('package').order_by('pk'))
for line in lines:
item = KitchenInventoryItem.objects.select_for_update().get(pk=line.package_id)
current = Decimal(item.quantity) if item.original_amount is None and not item.archived_at else (
Decimal(0) if item.original_amount is None else item.remaining_amount)
if current != line.after_amount:
raise StockError('Package changed since this consumption. Undo it in reverse order.')
if item.remaining_pieces != line.after_pieces:
raise StockError('Piece count changed since this consumption. Undo it in reverse order.')
if item.archived_at is not None and line.after_amount != 0:
raise StockError('Package was removed after this consumption.')
reversal = InventoryConsumption.objects.create(user=user, product=operation.product,
amount=operation.amount, unit=operation.unit, source=operation.source,
description=f'Undo {operation.pk}', reverses=operation)
for line in lines:
item = line.package
if item.original_amount is None:
item.quantity = int(line.before_amount)
else:
item.remaining_amount = line.before_amount
item.remaining_pieces = line.before_pieces
item.archived_at = None
item.opened, item.opened_at = line.before_opened, line.before_opened_at
item.save(update_fields=('quantity', 'remaining_amount', 'remaining_pieces', 'archived_at', 'opened', 'opened_at', 'updated_at'))
InventoryConsumptionLine.objects.create(transaction=reversal, package=item,
amount=line.amount, unit=line.unit, before_amount=line.after_amount,
after_amount=line.before_amount, before_pieces=line.after_pieces,
after_pieces=line.before_pieces)
return reversal