Files
Django_TasksApp/main/food/inventory.py
T

339 lines
18 KiB
Python

from datetime import timedelta
from decimal import Decimal
import re
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.db import transaction
from django.db.models import F, Q
from django.http import HttpResponseBadRequest
from django.shortcuts import get_object_or_404, redirect, render
from django.urls import reverse
from django.utils import timezone
from django.views.decorators.http import require_http_methods, require_POST
from .forms import InventoryItemForm, InventoryManualProductForm
from .models import (FoodProduct, InventoryCategory, InventoryConsumption, InventoryLocation,
InventoryReviewPreference, InventoryScanItem, KitchenInventoryItem)
from .services.inventory_consumption import FACTORS, StockError, consume, materialize_packages, preview, undo
from .services.openfoodfacts import OpenFoodFactsError, cached_product, cached_search
from .services.products import local_products
def _owned_items(user):
return KitchenInventoryItem.objects.filter(user=user, archived_at__isnull=True).select_related('product', 'location', 'category')
@login_required
def overview(request):
items = _owned_items(request.user)
query = request.GET.get('q', '').strip()[:100]
if query:
items = items.filter(Q(product__product_name__icontains=query) | Q(product__brand__icontains=query) |
Q(product__barcode__icontains=query) | Q(location__name__icontains=query) |
Q(category__name__icontains=query))
location = request.GET.get('location', '')
category = request.GET.get('category', '')
if location.isdigit():
items = items.filter(location_id=location)
if category.isdigit():
items = items.filter(category_id=category)
opened = request.GET.get('opened', '')
if opened in ('yes', 'no'):
items = items.filter(opened=(opened == 'yes'))
if request.GET.get('use_soon') == '1':
items = items.filter(best_before__isnull=False, best_before__lte=timezone.localdate() + timedelta(days=14))
sort = request.GET.get('sort', 'location')
orderings = {'location': ('location__sort_order', 'location__name', 'product__product_name'),
'category': ('category__name', 'product__product_name'),
'name': ('product__product_name',), 'recent': ('-added_at',),
'best_before': (F('best_before').asc(nulls_last=True), 'product__product_name')}
items = list(items.order_by(*orderings.get(sort, orderings['location'])))
cards = {}
for item in items:
native_unit = item.inventory_unit or 'packs'
dimension, factor = FACTORS[native_unit]
unit = {'mass': 'g', 'volume': 'ml'}.get(dimension, native_unit)
key = (item.product_id, dimension)
if key not in cards:
choices = {'mg': ('mg', 'g', 'kg'), 'g': ('mg', 'g', 'kg'), 'kg': ('mg', 'g', 'kg'),
'ml': ('ml', 'L'), 'L': ('ml', 'L')}
cards[key] = {'product': item.product, 'unit': unit, 'packages': [], 'total': Decimal(0),
'units': list(choices.get(unit, (unit,))), 'piece_total': 0, 'has_pieces': False,
'package_count': 0,
'count_unit': dimension in ('pieces', 'packs', 'portions')}
cards[key]['packages'].append(item)
cards[key]['package_count'] += item.quantity if item.original_amount is None else 1
cards[key]['total'] += (item.remaining_amount if item.remaining_amount is not None
else Decimal(item.quantity)) * factor
if item.remaining_pieces is not None:
cards[key]['piece_total'] += item.remaining_pieces
cards[key]['has_pieces'] = True
if 'pieces' not in cards[key]['units'] and (item.piece_amount is not None or item.inner_packs_per_package):
cards[key]['units'].append('pieces')
if item.inner_packs_per_package and 'inner_packs' not in cards[key]['units']:
cards[key]['units'].append('inner_packs')
recent = InventoryConsumption.objects.filter(user=request.user, reverses__isnull=True).select_related('product').prefetch_related('lines__package').order_by('-created_at')[:8]
review_items = InventoryScanItem.objects.filter(batch__run__user=request.user)
processing_count = review_items.filter(status__in=(InventoryScanItem.Status.QUEUED,
InventoryScanItem.Status.PROCESSING)).count()
needs_review_count = review_items.filter(status__in=(InventoryScanItem.Status.NEEDS_REVIEW,
InventoryScanItem.Status.DEFERRED, InventoryScanItem.Status.FAILED)).count()
preference = InventoryReviewPreference.objects.filter(user=request.user).first()
return render(request, 'food/inventory_overview.html', {
'items': items, 'cards': list(cards.values()), 'recent_consumption': recent,
'query': query, 'sort': sort, 'selected_location': location,
'selected_category': category, 'opened': opened, 'use_soon': request.GET.get('use_soon'),
'locations': InventoryLocation.objects.filter(user=request.user),
'categories': InventoryCategory.objects.filter(user=request.user),
'today': timezone.localdate(), 'soon_date': timezone.localdate() + timedelta(days=14),
'processing_count': processing_count, 'needs_review_count': needs_review_count,
'review_mode': preference.mode if preference else InventoryReviewPreference.Mode.INDIVIDUAL,
})
@login_required
@require_http_methods(['GET', 'POST'])
def add(request):
product_id = request.GET.get('product') or request.POST.get('product')
product = get_object_or_404(FoodProduct, owner=request.user, pk=product_id) if product_id else None
query = request.GET.get('q', '').strip()[:100]
products = local_products(request.user, query)
form = InventoryItemForm(request.POST or None, initial={'quantity': 1, 'location_name': request.session.get('inventory_location', ''),
'original_amount': product.package_amount if product else None,
'inventory_unit': product.package_unit if product else ''}) if product else None
existing = _owned_items(request.user).filter(product=product) if product else []
if request.method == 'POST':
if not product:
return HttpResponseBadRequest('Choose a product.')
if form.is_valid():
with transaction.atomic():
location, _ = InventoryLocation.objects.get_or_create(user=request.user, name__iexact=form.cleaned_data['location_name'], defaults={'name': form.cleaned_data['location_name']})
category_name = form.cleaned_data['category_name']
category = None
if category_name:
category, _ = InventoryCategory.objects.get_or_create(user=request.user, name__iexact=category_name, defaults={'name': category_name})
item = form.save(commit=False)
item.user, item.product, item.location, item.category = request.user, product, location, category
if item.original_amount is not None:
if item.remaining_amount is None:
item.remaining_amount = item.original_amount
if item.quantity > 1:
count = item.quantity
item.quantity = 1
else:
count = 1
else:
count = 1
item.full_clean()
item.save()
if count > 1:
item.quantity = count
materialize_packages(item)
request.session['inventory_location'] = location.name
messages.success(request, f'{product.product_name} added. Scan the next item when ready.')
return redirect('food:inventory-add')
return render(request, 'food/inventory_add.html', {
'product': product, 'products': products.order_by('product_name')[:40], 'query': query,
'form': form, 'existing': existing,
'locations': InventoryLocation.objects.filter(user=request.user),
'categories': InventoryCategory.objects.filter(user=request.user),
'off_categories': product.raw_data.get('categories', '') if product and isinstance(product.raw_data, dict) else '',
})
@login_required
@require_POST
def lookup(request):
barcode = request.POST.get('barcode', '').strip()
try:
if not barcode.isascii() or not barcode.isdigit() or len(barcode) > 64:
raise ValueError('Enter a numeric barcode.')
product = FoodProduct.objects.filter(owner=request.user, barcode=barcode).first()
if not product:
product = cached_product(request.user, barcode)
except (ValueError, OpenFoodFactsError) as error:
messages.warning(request, str(error))
return redirect('food:inventory-add')
if product:
return redirect(f"{reverse('food:inventory-add')}?product={product.pk}")
return redirect(f"{reverse('food:inventory-manual')}?barcode={barcode}")
@login_required
@require_http_methods(['GET', 'POST'])
def external_search(request):
query = (request.POST.get('q') or request.GET.get('q') or '').strip()[:100]
results, notice = [], ''
if request.method == 'POST':
try:
results = cached_search(request.user, query)
except (ValueError, OpenFoodFactsError) as error:
notice = str(error)
return render(request, 'food/inventory_external.html', {'query': query, 'results': results, 'notice': notice})
@login_required
@require_http_methods(['GET', 'POST'])
def manual(request):
form = InventoryManualProductForm(request.POST or None, user=request.user, initial={'barcode': request.GET.get('barcode', '')})
if request.method == 'POST' and form.is_valid():
product = form.save(commit=False)
product.owner = request.user
match = re.fullmatch(r'\s*(\d+(?:[.,]\d+)?)\s*(kg|g|ml|l)\s*', product.package_quantity, re.I)
if match:
amount = Decimal(match.group(1).replace(',', '.'))
unit = match.group(2).lower()
if unit in ('kg', 'l'):
amount *= 1000
unit = 'g' if unit == 'kg' else 'ml'
if 0 < amount <= Decimal('9999999.999') and amount == amount.quantize(Decimal('.001')):
product.package_amount, product.package_unit = amount, unit
product.save()
return redirect(f"{reverse('food:inventory-add')}?product={product.pk}")
return render(request, 'food/inventory_manual.html', {'form': form})
@login_required
@require_http_methods(['GET', 'POST'])
def edit(request, pk):
item = get_object_or_404(_owned_items(request.user), pk=pk)
was_count_only = item.original_amount is None
form = InventoryItemForm(request.POST or None, instance=item)
if request.method == 'POST' and form.is_valid():
with transaction.atomic():
location, _ = InventoryLocation.objects.get_or_create(user=request.user, name__iexact=form.cleaned_data['location_name'], defaults={'name': form.cleaned_data['location_name']})
category_name = form.cleaned_data['category_name']
category = None
if category_name:
category, _ = InventoryCategory.objects.get_or_create(user=request.user, name__iexact=category_name, defaults={'name': category_name})
item = form.save(commit=False)
item.location, item.category = location, category
if item.original_amount is not None and item.remaining_amount is None:
item.remaining_amount = item.original_amount
item.full_clean()
item.save()
if was_count_only and item.original_amount is not None:
materialize_packages(item)
return redirect('food:inventory')
return render(request, 'food/inventory_edit.html', {'item': item, 'form': form,
'locations': InventoryLocation.objects.filter(user=request.user),
'categories': InventoryCategory.objects.filter(user=request.user)})
@login_required
@require_POST
def change_quantity(request, pk):
action = request.POST.get('action')
if action == 'used':
item = get_object_or_404(_owned_items(request.user), pk=pk)
try:
consume(request.user, item.product, item.remaining_amount if item.original_amount is not None else 1,
item.inventory_unit or 'packs', package_id=item.api_id)
messages.success(request, f'{item.product.product_name} used.')
except StockError as exc:
messages.error(request, str(exc))
return redirect('food:inventory')
if action != 'increase':
return HttpResponseBadRequest('Invalid action.')
with transaction.atomic():
item = get_object_or_404(KitchenInventoryItem.objects.select_for_update(), pk=pk, user=request.user, archived_at__isnull=True)
if item.original_amount is not None:
KitchenInventoryItem.objects.create(user=item.user, product=item.product, location=item.location,
category=item.category, 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)
else:
item.quantity += 1
item.save(update_fields=('quantity', 'updated_at'))
return redirect('food:inventory')
@login_required
@require_POST
def add_existing(request, pk):
with transaction.atomic():
item = get_object_or_404(KitchenInventoryItem.objects.select_for_update(), pk=pk, user=request.user, archived_at__isnull=True)
if item.original_amount is not None:
KitchenInventoryItem.objects.create(user=item.user, product=item.product, location=item.location,
category=item.category, 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)
else:
item.quantity += 1
item.save(update_fields=('quantity', 'updated_at'))
messages.success(request, f'{item.product.product_name} quantity increased.')
return redirect('food:inventory-add')
@login_required
@require_POST
def preview_consumption(request, pk):
product = get_object_or_404(FoodProduct, pk=pk, owner=request.user)
try:
plan = preview(request.user, product, request.POST.get('amount'),
request.POST.get('unit'), request.POST.get('package_id') or None)
except StockError as exc:
return render(request, 'food/partials/inventory_preview.html', {'error': str(exc)})
base_unit = product.base_unit
base_dimension = FACTORS[base_unit][0]
equivalent = Decimal(0)
compatible_equivalent = True
estimated_piece_weight = False
for deduction in plan['deductions']:
unit = deduction['unit']
if FACTORS[unit][0] != base_dimension:
compatible_equivalent = False
break
equivalent += deduction['amount'] * FACTORS[unit][1]
if deduction['package'].inner_packs_per_package and plan['unit'] in ('pieces', 'inner_packs'):
estimated_piece_weight = True
nutrition = []
if compatible_equivalent and equivalent:
for label, field in (('Energy', 'energy_kcal_100'), ('Carbohydrates', 'carbohydrates_100'),
('Protein', 'protein_100'), ('Fat', 'fat_100'),
('Fibre', 'fibre_100'), ('Sugars', 'sugars_100'), ('Salt', 'salt_100')):
value = getattr(product, field)
if value is not None:
nutrition.append({'label': label, 'value': (value * equivalent / 100).quantize(Decimal('.1')),
'unit': 'kcal' if label == 'Energy' else 'g'})
plan['equivalent_amount'] = equivalent.quantize(Decimal('.001')) if compatible_equivalent else None
plan['equivalent_unit'] = base_unit
plan['estimated_piece_weight'] = estimated_piece_weight
plan['nutrition'] = nutrition
return render(request, 'food/partials/inventory_preview.html',
{'plan': plan, 'product': product, 'package_id': request.POST.get('package_id', '')})
@login_required
@require_POST
def use_amount(request, pk):
product = get_object_or_404(FoodProduct, pk=pk, owner=request.user)
try:
operation = consume(request.user, product, request.POST.get('amount'), request.POST.get('unit'),
package_id=request.POST.get('package_id') or None,
allow_partial=request.POST.get('allow_partial') == 'yes')
messages.success(request, f'Used {operation.amount} {operation.unit} of {product.product_name}.')
except StockError as exc:
messages.error(request, str(exc))
return redirect('food:inventory')
@login_required
@require_POST
def undo_consumption(request, identifier):
try:
undo(request.user, identifier)
messages.success(request, 'Consumption undone.')
except StockError as exc:
messages.error(request, str(exc))
return redirect('food:inventory')