Files
Django_TasksApp/main/food/forms.py
T

379 lines
23 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
from django import forms
from decimal import Decimal
import uuid
from .models import FoodLogEntry, FoodPortion, FoodProduct, KitchenInventoryItem
class ManualFoodForm(forms.ModelForm):
basis_amount = forms.DecimalField(min_value=Decimal('0.001'), max_digits=10, decimal_places=3,
initial=100, required=False, label='Nutrition basis amount')
class Meta:
model = FoodProduct
fields = ('product_name', 'brand', 'barcode', 'base_unit', 'energy_kcal_100', 'carbohydrates_100', 'protein_100', 'fat_100', 'saturated_fat_100', 'fibre_100', 'sugars_100', 'salt_100')
labels = {
'energy_kcal_100': 'Calories for base quantity',
'carbohydrates_100': 'Carbohydrates for base quantity',
'protein_100': 'Protein for base quantity',
'fat_100': 'Fat for base quantity',
'saturated_fat_100': 'Saturated fat for base quantity (optional)',
'fibre_100': 'Fibre for base quantity (optional)',
'sugars_100': 'Sugars for base quantity (optional)',
'salt_100': 'Salt for base quantity (optional)',
}
def __init__(self, *args, **kwargs):
self.user = kwargs.pop('user', None)
super().__init__(*args, **kwargs)
self.fields['barcode'].required = False
self.fields['base_unit'].required = False
if self.instance.pk:
self.fields['base_unit'].disabled = True
def clean_base_unit(self):
return self.cleaned_data['base_unit'] or self.instance.base_unit or 'g'
def clean_basis_amount(self):
return self.cleaned_data['basis_amount'] or Decimal('100')
def clean_barcode(self):
barcode = self.cleaned_data['barcode'].strip()
if barcode and (not barcode.isascii() or not barcode.isdigit()):
raise forms.ValidationError('Enter a numeric barcode.')
if barcode and self.user and FoodProduct.objects.filter(owner=self.user, barcode=barcode).exclude(pk=self.instance.pk).exists():
raise forms.ValidationError('This barcode is already saved in your foods.')
return barcode
def clean(self):
data = super().clean()
basis = data.get('basis_amount')
if basis:
factor = Decimal('100') / basis
for name in ('energy_kcal_100', 'carbohydrates_100', 'protein_100', 'fat_100',
'saturated_fat_100', 'fibre_100', 'sugars_100', 'salt_100'):
value = data.get(name)
if value is not None and value * factor > Decimal('9999999.999'):
self.add_error(name, 'This amount is too large for the chosen base quantity.')
return data
def save(self, commit=True):
product = super().save(commit=False)
factor = Decimal('100') / self.cleaned_data['basis_amount']
for name in ('energy_kcal_100', 'carbohydrates_100', 'protein_100', 'fat_100',
'saturated_fat_100', 'fibre_100', 'sugars_100', 'salt_100'):
value = self.cleaned_data[name]
setattr(product, name, (value * factor).quantize(Decimal('0.001')) if value is not None else None)
if commit:
product.save()
return product
class FoodLogForm(forms.ModelForm):
portion = forms.ChoiceField(label='Portion', required=False)
portion_count = forms.IntegerField(label='How many portions', min_value=1, max_value=999,
required=False, initial=1)
inventory_package = forms.ChoiceField(label='Use inventory', required=False)
save_portion = forms.BooleanField(required=False, label='Save custom amount as a portion')
new_portion_label = forms.CharField(max_length=100, required=False, label='New portion label')
make_default = forms.BooleanField(required=False, label='Use this portion by default')
class Meta:
model = FoodLogEntry
fields = ('meal', 'amount', 'unit', 'portion_label_snapshot')
labels = {'portion_label_snapshot': 'Portion label (optional)'}
widgets = {'amount': forms.NumberInput(attrs={'min': '0.001', 'step': '0.001'})}
def __init__(self, *args, product=None, inventory_options=None, **kwargs):
super().__init__(*args, **kwargs)
self.product = product or getattr(self.instance, 'product', None)
self.fields['inventory_package'].choices = [('', 'Log without using inventory')] + (inventory_options or [])
if self.instance.pk and self.instance.created_via == 'recipe':
self.fields['unit'].choices = [('servings', 'servings')]
if self.product and self.product.pk:
self.fields['unit'].initial = self.product.base_unit
unit = self.product.base_unit
choices = [('custom', 'Custom amount'), ('base', f'100 {unit}')]
if self.product.serving_amount and self.product.serving_unit == unit:
choices.append(('serving', f'Serving — {self.product.serving_amount:g} {unit}'))
portions = list(FoodPortion.objects.filter(product=self.product, user=self.product.owner).order_by('label'))
choices.extend((f'portion:{item.pk}', f'{item.label} — {item.amount:g} {item.unit}') for item in portions)
self.fields['portion'].choices = choices
self.portions = {str(item.pk): item for item in portions}
default = next((item for item in portions if item.is_default), None)
if default is None:
last = self.product.log_entries.filter(user=self.product.owner).order_by('-created_at').first()
default = next((item for item in portions if last and item.label == last.portion_label_snapshot and
item.amount == last.amount and item.unit == last.unit), None)
if self.instance.pk:
selected = next((item for item in portions if item.label == self.instance.portion_label_snapshot and
item.amount == self.instance.amount and item.unit == self.instance.unit), None)
self.fields['portion'].initial = f'portion:{selected.pk}' if selected else 'custom'
elif default:
self.fields['portion'].initial = f'portion:{default.pk}'
self.fields['amount'].initial = default.amount
elif self.product.serving_amount and self.product.serving_unit == unit:
self.fields['portion'].initial = 'serving'
self.fields['amount'].initial = self.product.serving_amount
else:
self.fields['portion'].initial = 'base'
self.fields['amount'].initial = 100
self.fields['amount'].required = False
def clean_unit(self):
unit = self.cleaned_data['unit']
if self.instance.pk and self.instance.created_via == 'recipe' and unit != 'servings':
raise forms.ValidationError('Recipe entries use servings.')
if self.product and unit != self.product.base_unit:
raise forms.ValidationError('Use the same unit as the product nutrition basis.')
return unit
def clean(self):
data = super().clean()
if self.instance.pk and self.instance.created_via == 'recipe':
run = getattr(self.instance, 'recipe_cooking_run', None)
if run and data.get('amount') is not None and data['amount'] > run.prepared_servings:
self.add_error('amount', 'This portion exceeds the prepared servings.')
selected = data.get('portion') or 'custom'
count = data.get('portion_count') or 1
if not self.product or not selected:
return data
if selected == 'base':
data['amount'], data['portion_label_snapshot'] = Decimal('100') * count, ''
elif selected == 'serving':
data['amount'], data['portion_label_snapshot'] = self.product.serving_amount * count, f'{count} × serving' if count > 1 else 'Serving'
elif selected.startswith('portion:'):
portion = self.portions.get(selected.partition(':')[2])
if not portion:
self.add_error('portion', 'Choose a valid portion.')
else:
data['amount'], data['portion_label_snapshot'] = portion.amount * count, f'{count} × {portion.label}' if count > 1 else portion.label
elif selected == 'custom':
if data.get('amount') is None or data['amount'] <= 0:
self.add_error('amount', 'Enter an amount greater than zero.')
if data.get('save_portion'):
label = (data.get('new_portion_label') or '').strip()
if not label:
self.add_error('new_portion_label', 'Enter a label for the saved portion.')
elif FoodPortion.objects.filter(user=self.product.owner, product=self.product, label=label).exists():
try:
submission_id = uuid.UUID(self.data.get('submission_id', ''))
except (ValueError, TypeError, AttributeError):
submission_id = None
if not (submission_id and FoodLogEntry.objects.filter(user=self.product.owner,
api_id=submission_id).exists()):
self.add_error('new_portion_label', 'You already have a portion with this label.')
else:
data['portion_label_snapshot'] = label
elif data.get('make_default'):
self.add_error('make_default', 'Save the portion before making it the default.')
return data
class FoodLogEditForm(FoodLogForm):
edit_nutrition = forms.BooleanField(required=False, label='Use these nutrition values for this entry')
class Meta(FoodLogForm.Meta):
fields = FoodLogForm.Meta.fields + ('quantity', 'calories_kcal', 'carbohydrates_g',
'protein_g', 'fat_g', 'fibre_g', 'sugars_g', 'salt_g')
labels = {**FoodLogForm.Meta.labels, 'quantity': 'Quantity (portions)',
'calories_kcal': 'Calories (kcal)', 'carbohydrates_g': 'Carbohydrates (g)',
'protein_g': 'Protein (g)', 'fat_g': 'Fat (g)', 'fibre_g': 'Fibre (g)',
'sugars_g': 'Sugars (g)', 'salt_g': 'Salt (g)'}
widgets = {**FoodLogForm.Meta.widgets,
'quantity': forms.NumberInput(attrs={'min': '0.01', 'step': '0.01'})}
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# Older clients may omit the new field; keep the saved quantity in that case.
self.fields['quantity'].required = False
def clean_quantity(self):
return self.cleaned_data['quantity'] if self.cleaned_data['quantity'] is not None else self.instance.quantity
class FoodProductHydrationForm(forms.ModelForm):
class Meta:
model = FoodProduct
fields = ('is_beverage', 'hydration_enabled', 'hydration_factor')
labels = {'is_beverage': 'Count as a beverage',
'hydration_enabled': 'Include in hydration totals',
'hydration_factor': 'Fluid counting factor (0 to 1)'}
widgets = {'hydration_factor': forms.NumberInput(attrs={'min': 0, 'max': 1, 'step': '.001'})}
class InventoryItemForm(forms.ModelForm):
location_name = forms.CharField(max_length=100, label='Location', widget=forms.TextInput(attrs={'list': 'inventory-locations', 'autocomplete': 'off'}))
category_name = forms.CharField(max_length=100, required=False, label='My category', widget=forms.TextInput(attrs={'list': 'inventory-categories', 'autocomplete': 'off'}))
class Meta:
model = KitchenInventoryItem
fields = ('quantity', 'original_amount', 'inventory_unit', 'pieces_per_package',
'remaining_pieces', 'piece_amount', 'inner_packs_per_package',
'pieces_per_inner_pack', 'inner_pack_amount', 'inner_pack_label',
'piece_label', 'opened', 'best_before', 'notes')
widgets = {'quantity': forms.NumberInput(attrs={'min': 1, 'step': 1}),
'original_amount': forms.NumberInput(attrs={'min': '.001', 'step': '.001'}),
'pieces_per_package': forms.NumberInput(attrs={'min': 1, 'step': 1}),
'remaining_pieces': forms.NumberInput(attrs={'min': 0, 'step': 1}),
'piece_amount': forms.NumberInput(attrs={'min': '.001', 'step': '.001'}),
'inner_packs_per_package': forms.NumberInput(attrs={'min': 1, 'step': 1}),
'pieces_per_inner_pack': forms.NumberInput(attrs={'min': 1, 'step': 1}),
'inner_pack_amount': forms.NumberInput(attrs={'min': '.001', 'step': '.001'}),
'best_before': forms.DateInput(attrs={'type': 'date'}),
'notes': forms.Textarea(attrs={'rows': 2})}
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields['inventory_unit'] = forms.ChoiceField(required=False, label='Package unit',
choices=[('', 'Count only (unknown size)')] + [(unit, unit) for unit in
('mg', 'g', 'kg', 'ml', 'L', 'pieces', 'packs', 'portions')])
self.fields['original_amount'].label = 'Amount in outer package'
self.fields['quantity'].label = 'Number of packages'
self.fields['pieces_per_package'].label = 'Total pieces per package (flat package)'
self.fields['remaining_pieces'].label = 'Individual pieces remaining'
self.fields['piece_amount'].label = 'Amount per piece in package unit (optional)'
self.fields['inner_packs_per_package'].label = 'Inner packs per package (optional)'
self.fields['pieces_per_inner_pack'].label = 'Pieces per inner pack'
self.fields['inner_pack_amount'].label = 'Amount per inner pack'
self.fields['inner_pack_label'].label = 'Inner pack name'
self.fields['piece_label'].label = 'Individual item name'
self.fields['quantity'].help_text = 'Count packages or cans here, not the pieces inside them.'
self.fields['original_amount'].help_text = 'For nested packs, leave blank to calculate it from inner-pack amount × inner packs.'
self.fields['pieces_per_package'].help_text = 'For flat packages, such as 12 rolls or 10 sausages. Leave blank when entering nested pack counts below.'
self.fields['remaining_pieces'].help_text = 'Total individual pieces left across all inner packs. For a full package, leave blank.'
self.fields['piece_amount'].help_text = 'Enter a measured amount per piece for g or ml conversion; never inferred from the pack label.'
self.fields['inner_packs_per_package'].help_text = 'For a nested pack, such as 6 individually wrapped inner packs.'
self.fields['pieces_per_inner_pack'].help_text = 'How many individual items are in each inner pack.'
self.fields['inner_pack_amount'].help_text = 'Measured amount in one inner pack, for example 44 g. This derives the approximate amount per piece.'
self.fields['inner_pack_label'].help_text = 'For example, packet or wrapper.'
self.fields['piece_label'].help_text = 'For example, biscuit or cracker.'
if self.instance.pk:
self.fields['location_name'].initial = self.instance.location.name
self.fields['category_name'].initial = self.instance.category.name if self.instance.category else ''
self.fields['inventory_unit'].initial = self.instance.inventory_unit
def clean(self):
data = super().clean()
pieces = data.get('pieces_per_package')
remaining_pieces = data.get('remaining_pieces')
piece_amount = data.get('piece_amount')
original = data.get('original_amount')
unit = data.get('inventory_unit')
inner_packs = data.get('inner_packs_per_package')
pieces_per_inner = data.get('pieces_per_inner_pack')
inner_amount = data.get('inner_pack_amount')
was_count_only = self.instance.pk and KitchenInventoryItem.objects.filter(
pk=self.instance.pk, original_amount__isnull=True).exists()
nested = inner_packs is not None or pieces_per_inner is not None
if nested:
if inner_packs is None or pieces_per_inner is None:
raise forms.ValidationError('Enter both inner packs per package and pieces per inner pack.')
if pieces is not None and pieces != inner_packs * pieces_per_inner:
raise forms.ValidationError('Total pieces must equal inner packs times pieces per inner pack.')
pieces = inner_packs * pieces_per_inner
data['pieces_per_package'] = pieces
self.instance.pieces_per_package = pieces
if not data.get('piece_label'):
raise forms.ValidationError('Name the individual item, for example biscuit.')
if inner_packs > 1 and not data.get('inner_pack_label'):
raise forms.ValidationError('Name the inner package, for example packet.')
if not original and not unit:
if inner_amount is not None:
raise forms.ValidationError('Choose a package unit for the measured inner-pack amount.')
original, unit = Decimal(pieces), 'pieces'
data['original_amount'], data['inventory_unit'] = original, unit
self.instance.original_amount, self.instance.inventory_unit = original, unit
if unit == 'pieces':
if inner_amount is not None:
raise forms.ValidationError('Piece-only packages do not use a measured inner-pack amount.')
original = Decimal(pieces)
data['original_amount'] = original
self.instance.original_amount = original
elif unit in ('mg', 'g', 'kg', 'ml', 'L'):
if inner_amount is None:
raise forms.ValidationError('Enter the measured amount in one inner pack.')
expected_original = inner_amount * inner_packs
if original is not None and original != expected_original:
raise forms.ValidationError('Outer package amount must equal inner-pack amount times inner packs.')
original = expected_original
data['original_amount'] = original
self.instance.original_amount = original
else:
raise forms.ValidationError('Nested contents require a pieces, mass, or volume unit.')
if piece_amount is not None:
raise forms.ValidationError('Nested packages derive piece amounts from the inner-pack amount.')
if pieces is not None:
if remaining_pieces is None:
remaining_pieces = pieces
data['remaining_pieces'] = pieces
self.instance.remaining_pieces = pieces
if remaining_pieces > pieces:
raise forms.ValidationError('Pieces remaining cannot exceed pieces per package.')
if not original and not unit:
original, unit = Decimal(pieces), 'pieces'
data['original_amount'], data['inventory_unit'] = original, unit
self.instance.original_amount, self.instance.inventory_unit = original, unit
if unit == 'pieces':
if original != Decimal(pieces) or piece_amount is not None:
raise forms.ValidationError('For piece stock, package amount must equal pieces per package; leave amount per piece blank.')
if not self.instance.pk or was_count_only:
self.instance.remaining_amount = Decimal(remaining_pieces)
elif unit in ('mg', 'g', 'kg', 'ml', 'L'):
if remaining_pieces < pieces and (not self.instance.pk or was_count_only):
if nested:
full_packs, loose_pieces = divmod(remaining_pieces, pieces_per_inner)
remaining_value = inner_amount * full_packs
if loose_pieces:
remaining_value += (inner_amount * loose_pieces / pieces_per_inner).quantize(Decimal('.001'))
self.instance.remaining_amount = remaining_value
elif piece_amount is None:
raise forms.ValidationError('Enter an explicit amount per piece to record a partly used weighed package.')
else:
self.instance.remaining_amount = piece_amount * remaining_pieces
if self.instance.remaining_amount > original:
raise forms.ValidationError('Piece amounts exceed the package amount.')
else:
raise forms.ValidationError('Piece contents require a piece, mass, or volume package unit.')
if remaining_pieces < pieces:
self.instance.opened = True
data['opened'] = True
elif remaining_pieces is not None or piece_amount is not None:
raise forms.ValidationError('Enter pieces per package first.')
if bool(data.get('original_amount')) != bool(data.get('inventory_unit')):
raise forms.ValidationError('Enter both package amount and unit, or leave both blank.')
if data.get('original_amount') and self.instance.remaining_amount is None:
self.instance.remaining_amount = data['original_amount']
if self.instance.pk and not was_count_only and self.instance.original_amount and data.get('original_amount') != self.instance.original_amount:
raise forms.ValidationError('Existing package sizes cannot be changed after tracking starts.')
if self.instance.pk and not was_count_only and self.instance.original_amount and data.get('inventory_unit') != self.instance.inventory_unit:
raise forms.ValidationError('Existing package units cannot be changed after tracking starts.')
if self.instance.pk and not was_count_only and self.instance.original_amount and data.get('quantity') != 1:
raise forms.ValidationError('A tracked package has a quantity of one.')
if self.instance.pk and not was_count_only:
old = KitchenInventoryItem.objects.get(pk=self.instance.pk)
nested_state = (inner_packs, pieces_per_inner, inner_amount,
data.get('inner_pack_label'), data.get('piece_label'))
old_nested_state = (old.inner_packs_per_package, old.pieces_per_inner_pack,
old.inner_pack_amount, old.inner_pack_label, old.piece_label)
if old.pieces_per_package is not None and (pieces != old.pieces_per_package or piece_amount != old.piece_amount or remaining_pieces != old.remaining_pieces or nested_state != old_nested_state):
raise forms.ValidationError('Use inventory consumption to change tracked pieces.')
if old.pieces_per_package is None and pieces is not None and not nested and piece_amount is not None and old.remaining_amount != piece_amount * remaining_pieces:
raise forms.ValidationError('Piece counts must match current measured stock; use inventory consumption for deductions.')
return data
def clean_location_name(self):
value = ' '.join(self.cleaned_data['location_name'].split())
if not value:
raise forms.ValidationError('Enter a location.')
return value
def clean_category_name(self):
return ' '.join(self.cleaned_data['category_name'].split())
class InventoryManualProductForm(ManualFoodForm):
class Meta(ManualFoodForm.Meta):
fields = ('product_name', 'brand', 'barcode', 'package_quantity', 'base_unit',
'energy_kcal_100', 'carbohydrates_100', 'protein_100', 'fat_100',
'saturated_fat_100', 'fibre_100', 'sugars_100', 'salt_100')