Files
Django_TasksApp/main/recipes/views.py
T
2026-10-12 01:53:21 +02:00

261 lines
12 KiB
Python

import json
import uuid
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.db import transaction
from django.db.models import Q
from django.http import FileResponse, Http404, HttpResponseBadRequest, JsonResponse
from django.shortcuts import get_object_or_404, redirect, render
from django.urls import reverse
from django.views.decorators.http import require_http_methods, require_POST
from PIL import Image
from .forms import RecipeForm, RecipeIngredientFormSet, RecipeSubrecipeFormSet
from .models import Recipe, RecipeIngredient, RecipeSubrecipe
def _owned(user):
return Recipe.objects.filter(owner=user)
def _library(request, selected=None):
explicit_detail = selected is not None
recipes = _owned(request.user).prefetch_related('ingredients')
query = request.GET.get('q', '').strip()[:100]
category = request.GET.get('category', '').strip()[:80]
tag = request.GET.get('tag', '').strip()[:40]
favourite = request.GET.get('favourite') == '1'
if query:
recipes = recipes.filter(Q(title__icontains=query) | Q(description__icontains=query) |
Q(ingredients__name__icontains=query)).distinct()
if category:
recipes = recipes.filter(category=category)
if favourite:
recipes = recipes.filter(is_favourite=True)
recipes = list(recipes)
if tag:
recipes = [recipe for recipe in recipes if tag in recipe.tags]
recipes = recipes[:100]
if selected is None and recipes:
selected = recipes[0]
categories = list(_owned(request.user).exclude(category='').order_by('category')
.values_list('category', flat=True).distinct())
tags = sorted({tag for values in _owned(request.user).values_list('tags', flat=True)
for tag in values if isinstance(tag, str)})
return render(request, 'recipes/library.html', {
'recipes': recipes, 'selected': selected, 'query': query,
'category': category, 'tag': tag, 'favourite': favourite,
'categories': categories, 'tags': tags, 'explicit_detail': explicit_detail,
})
@login_required
def library(request):
return _library(request)
@login_required
def detail(request, identifier):
recipe = get_object_or_404(_owned(request.user).select_related('parent')
.prefetch_related('ingredients', 'subrecipes__component', 'variations'), api_id=identifier)
return _library(request, recipe)
def _edit(request, recipe=None, allow_draft_resume=False):
creating = recipe is None or recipe.pk is None
recipe = recipe or Recipe(owner=request.user)
old_photo = recipe.photo.name if recipe.pk and recipe.photo else ''
form = RecipeForm(request.POST or None, request.FILES or None,
instance=recipe, user=request.user)
ingredients = RecipeIngredientFormSet(request.POST or None, instance=recipe,
prefix='ingredients', user=request.user)
subrecipes = RecipeSubrecipeFormSet(request.POST or None, instance=recipe,
prefix='subrecipes', user=request.user)
if request.method == 'POST' and form.is_valid() and ingredients.is_valid() and subrecipes.is_valid():
with transaction.atomic():
current = Recipe.objects.select_for_update().get(pk=recipe.pk) if not creating else None
if (current and current.markdown_revision != form.cleaned_data['markdown_revision'] and
not (allow_draft_resume and current.markdown_revision == 1 and
form.cleaned_data['markdown_revision'] == 0)):
form.add_error(None, 'This recipe changed in another tab. Reload before saving your changes.')
else:
recipe = form.save(commit=False)
recipe.owner = request.user
if form.cleaned_data['remove_photo']:
recipe.photo = ''
if current:
recipe.markdown_revision = current.markdown_revision + 1
recipe.full_clean()
recipe.save()
ingredients.instance = recipe
ingredients.save()
subrecipes.instance = recipe
subrecipes.save()
if old_photo and old_photo != recipe.photo.name:
transaction.on_commit(lambda: recipe.photo.storage.delete(old_photo))
messages.success(request, 'Recipe saved.')
return redirect('recipes:detail', identifier=recipe.api_id)
return render(request, 'recipes/form.html', {
'form': form, 'ingredients': ingredients, 'subrecipes': subrecipes, 'recipe': recipe,
'creating': creating, 'new_draft_id': recipe.api_id if creating else None,
})
@login_required
@require_http_methods(['GET', 'POST'])
def create(request):
if request.method == 'POST' and request.POST.get('draft_id'):
try:
draft_id = uuid.UUID(request.POST['draft_id'])
except (ValueError, TypeError, AttributeError):
return HttpResponseBadRequest('Invalid draft ID.')
existing = Recipe.objects.filter(api_id=draft_id).first()
if existing and existing.owner_id != request.user.pk:
raise Http404
return _edit(request, existing or Recipe(owner=request.user, api_id=draft_id),
allow_draft_resume=bool(existing))
return _edit(request)
@login_required
@require_http_methods(['GET', 'POST'])
def edit(request, identifier):
return _edit(request, get_object_or_404(_owned(request.user), api_id=identifier))
@login_required
@require_POST
def autosave(request, identifier):
try:
payload = json.loads(request.body)
revision = payload['revision']
instructions = payload['instructions_markdown']
notes = payload['notes_markdown']
title = payload['title']
except (ValueError, TypeError, KeyError):
return JsonResponse({'error': 'Invalid Markdown data.'}, status=400)
if (type(revision) is not int or revision < 0 or
not isinstance(instructions, str) or not isinstance(notes, str) or
not isinstance(title, str) or not title.strip() or len(title) > 180 or
len(instructions) > 100_000 or len(notes) > 100_000):
return JsonResponse({'error': 'Invalid Markdown data.'}, status=400)
with transaction.atomic():
recipe = get_object_or_404(_owned(request.user).select_for_update(), api_id=identifier)
if recipe.markdown_revision != revision:
return JsonResponse({'error': 'This recipe changed in another tab. Reload to continue.',
'revision': recipe.markdown_revision}, status=409)
recipe.instructions_markdown = instructions
recipe.notes_markdown = notes
recipe.title = title.strip()
recipe.markdown_revision += 1
recipe.save(update_fields=('title', 'instructions_markdown', 'notes_markdown',
'markdown_revision', 'updated_at'))
return JsonResponse({'revision': recipe.markdown_revision})
@login_required
@require_POST
def autosave_new(request):
try:
payload = json.loads(request.body)
draft_id = uuid.UUID(payload['draft_id'])
title = payload['title']
instructions = payload['instructions_markdown']
notes = payload['notes_markdown']
except (ValueError, TypeError, KeyError, AttributeError):
return JsonResponse({'error': 'Invalid draft data.'}, status=400)
if (not isinstance(title, str) or not title.strip() or len(title) > 180 or
not isinstance(instructions, str) or not isinstance(notes, str) or
len(instructions) > 100_000 or len(notes) > 100_000):
return JsonResponse({'error': 'Invalid draft data.'}, status=400)
with transaction.atomic():
recipe = Recipe.objects.select_for_update().filter(api_id=draft_id).first()
if recipe is None:
recipe = Recipe.objects.create(owner=request.user, api_id=draft_id,
title=title.strip(), instructions_markdown=instructions,
notes_markdown=notes, markdown_revision=1)
elif recipe.owner_id != request.user.pk:
return JsonResponse({'error': 'Draft not found.'}, status=404)
elif (recipe.title != title.strip() or recipe.instructions_markdown != instructions or
recipe.notes_markdown != notes):
return JsonResponse({'error': 'This draft changed. Reload to continue.'}, status=409)
return JsonResponse({'revision': recipe.markdown_revision,
'edit_url': reverse('recipes:edit', args=[recipe.api_id]),
'autosave_url': reverse('recipes:autosave', args=[recipe.api_id])})
@login_required
@require_POST
def create_variation(request, identifier):
parent = get_object_or_404(_owned(request.user).prefetch_related('ingredients', 'subrecipes'),
api_id=identifier)
with transaction.atomic():
variation = Recipe.objects.create(
owner=request.user, parent=parent, title=f'{parent.title[:160]} variation',
description=parent.description, instructions_markdown=parent.instructions_markdown,
notes_markdown=parent.notes_markdown, preparation_minutes=parent.preparation_minutes,
cooking_minutes=parent.cooking_minutes, default_servings=parent.default_servings,
category=parent.category, tags=list(parent.tags), status=Recipe.Status.DRAFT,
)
RecipeIngredient.objects.bulk_create([
RecipeIngredient(recipe=variation, name=item.name, quantity=item.quantity,
unit=item.unit, display_order=item.display_order,
inventory_product=item.inventory_product,
nutrition_product=item.nutrition_product,
preparation_note=item.preparation_note, is_optional=item.is_optional)
for item in parent.ingredients.all()
])
RecipeSubrecipe.objects.bulk_create([
RecipeSubrecipe(recipe=variation, component=item.component, quantity=item.quantity,
unit=item.unit, display_order=item.display_order, note=item.note)
for item in parent.subrecipes.all()
])
messages.success(request, 'Variation created. Edit it to make it your own.')
return redirect('recipes:edit', identifier=variation.api_id)
@login_required
@require_http_methods(['GET', 'POST'])
def delete(request, identifier):
recipe = get_object_or_404(_owned(request.user), api_id=identifier)
if request.method == 'POST':
if recipe.used_in_recipes.exists():
messages.error(request, 'Remove this recipe from other recipes before deleting it.')
return redirect('recipes:detail', identifier=recipe.api_id)
photo = recipe.photo.name if recipe.photo else ''
with transaction.atomic():
recipe.delete()
if photo:
transaction.on_commit(lambda: recipe.photo.storage.delete(photo))
messages.success(request, 'Recipe deleted.')
return redirect('recipes:list')
return render(request, 'recipes/delete.html', {'recipe': recipe})
@login_required
@require_POST
def toggle_favourite(request, identifier):
recipe = get_object_or_404(_owned(request.user), api_id=identifier)
recipe.is_favourite = not recipe.is_favourite
recipe.save(update_fields=('is_favourite', 'updated_at'))
return redirect('recipes:detail', identifier=recipe.api_id)
@login_required
def photo(request, identifier):
recipe = get_object_or_404(_owned(request.user), api_id=identifier)
if not recipe.photo:
from django.http import Http404
raise Http404
file = recipe.photo.open('rb')
image_format = Image.open(file).format
file.seek(0)
response = FileResponse(file, content_type={
'JPEG': 'image/jpeg', 'PNG': 'image/png', 'WEBP': 'image/webp',
}.get(image_format, 'application/octet-stream'))
response['Content-Disposition'] = 'inline'
response['Cache-Control'] = 'private, max-age=3600'
response['X-Content-Type-Options'] = 'nosniff'
return response