339 lines
18 KiB
Python
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')
|