mensa_app/views.py

@@ -1,101 +1,97 @@
-from django.shortcuts import render
+from django.shortcuts import render, redirect
+from django.views import View
+from .forms import OrderConfirmationForm # Ein Formular für die finalen Details
+# Importieren Sie notwendige Django-Module (z.B. Django Payments)
+import stripe # Beispiel: Stripe Payment Library
 
-# Create your views here.
+class CheckoutView(View):
-from django.views.generic import ListView
+    def get(self, request):
-from .models import Gericht
+        # 1. Warenkorb aus der Session laden (vereinfacht dargestellt)
+        cart_items = self.get_cart_from_session(request) 
+        context = {
+            'cart': cart_items,
+        }
+        return render(request, 'orders/checkout.html', context)
 
-class GerichtListView(ListView):
+    def post(self, request):
-    model = Gericht
+        # 2. Bestätigungsdaten validieren (z.B. Lieferadresse falls nötig)
-    template_name = 'mensa_app/gericht_liste.html'  # Der Pfad zum Template
+        form = OrderConfirmationForm()
-    context_object_name = 'alle_gerichte'          # Der Name, den wir im Template nutzen
+        if form.is_valid():
+            user = request.user
+            cart_items = self.get_cart_from_session(request)
 
-from django.views.generic import TemplateView
+            # --- 3. Transaktionsdaten erstellen und speichern ---
-from django.utils import timezone
+            total = sum(item['price'] * item['quantity'] for item in cart_items)
-from datetime import datetime
-from .models import Menue, Gericht, SpeiseplanTag
 
-class SpeiseplanView(TemplateView):
+            # Erstelle die Hauptbestellung (STATUS: PENDING)
-    template_name = 'mensa_app/speiseplan.html'
+            order = Order.objects.create(user=user, total_price=total, status='PENDING')
 
-    def get_context_data(self, **kwargs):
+            # Speichere jeden Artikel als OrderItem
-        context = super().get_context_data(**kwargs)
+            for item in cart_items:
+                OrderItem.objects.create(
+                    order=order, 
+                    menu_item=item['item'], # Angenommen, der Item-Objekt ist verfügbar
+                    quantity=item['quantity'], 
+                    price_at_purchase=item['price']
+                )
 
-        # 1. Datum aus der URL holen (z.B. ?datum=2023-10-27)
+            # --- 4. Zahlung verarbeiten (CRITICAL STEP) ---
-        # Wenn kein Datum angegeben ist, nehmen wir heute.
-        date_str = self.request.GET.get('datum')
-        if date_str:
             try:
-                target_date = datetime.strptime(date_str, '%Y-%m-%d').date()
+                payment_token = request.POST.get('stripePaymentToken') # Token aus dem Frontend erhalten
-            except ValueError:
-                target_date = timezone.glob.now().date()
-        else:
-            target_date = timezone.now().date()
                 
-        # 2. Menüs für diesen spezifischen Tag laden
+                # ACHTUNG: Hier wird das tatsächliche Stripe/PayPal API-Call ausgeführt
-        # Wir suchen alle Menüs, deren Tag das target_date hat
+                charge = stripe.Charge.create(
-        context['target_date'] = target_date
+                    amount=int(total * 100),  # Stripe erwartet Cent
-        context['menues_day'] = Menue.objects.filter(tag__datum=target_date)
+                    currency='eur',
+                    source=payment_token,
+                    description=f"Mensa Bestellung für {user.username}"
+                )
 
-        # 3. Dauerangebote laden (unabhängig vom Tag)
+                # Zahlung erfolgreich! Bestätige die Order im Backend
-        context['dauerangebote'] = Gericht.objects.filter(ist_dauerangebot=True)
+                order.status = 'CONFIRMED'
+                order.save()
                 
-        # 4. Pager-Logik: Vorherigen und nächsten Tag finden
+                return redirect('bestellung_erfolgreich')
-        # Wir suchen in der Tabelle SpeiseplanTag nach dem Tag davor/danach
-        prev_tag = SpeiseplanTag.objects.filter(datum__lt=target_date).order_by('-datum').first()
-        next_tag = SpeiseplanTag.objects.filter(datum__gt=target_date).order_by('datum').first()
 
-        context['prev_date'] = prev_tag.datum.strftime('%Y-%m-%d') if prev_tag else None
+            except stripe.error.CardError as e:
-        context['next_date'] = next_tag.datum.strftime('%Y-%m-%d') if next_tag else None
+                # Fehlerbehandlung (z.B. falsche Karte, zu viel Geld)
+                form.add_error('payment', 'Zahlung fehlgeschlagen: ' + str(e))
+            except Exception as e:
+                 print(f"Allgemeiner Fehler bei der Zahlung: {e}")
 
-        return context
+        return render(request, 'orders/checkout.html', {'form': form})
 
+# Hilfsfunktion (muss in die View oder ein Servicescript ausgelagert werden)
+def get_cart_from_session(request):
+    # Logik zum Laden von Menüpunkten und Mengen aus der Session
+    pass 
+    from django.shortcuts import render, redirect
+from django.views import View
+from .forms import ReviewForm # Muss ein Formular für Rating und Kommentar enthalten
 
-from django.views.generic import TemplateView
+class ReviewView(View):
-from django.utils import timezone
+    def get(self, request):
-from django.db.models import Count, Sum
+        # Zeigt alle bestehenden Bewertungen (z.B. für das Hauptmenü)
-from datetime import datetime
+        all_reviews = Review.objects.select_related('menu_item').order_by('-created_at')
-from .models import Bestellung, SpeiseplanTag, Gericht, Menue
+        context = {'reviews': all_reviews}
+        return render(request, 'reviews/list.html', context)
 
-class BestellSummaryView(TemplateView):
+    def post(self, request):
-    template_name = 'mensa_app/bestell_summary.html'
+        form = ReviewForm(request.POST)
+        if form.is_valid():
+            review_data = form.cleaned_data
             
-    def get_context_data(self, **kwargs):
+            # 1. Den Menüpunkt bestimmen (oder lassen Sie ihn optional)
-        context = super().get_context_data(**kwargs)
+            menu_item = request.GET.get('menu_item') 
 
-        # 1. Datum aus der URL holen (wie beim Speiseplan)
+            # 2. Review erstellen
-        date_str = self.request.GET.  get('datum')
+            Review.objects.create(
-        if date_str:
+                user=request.user,
-            try:
+                menu_item=menu_item, # Kann None sein
-                target_date = datetime.strptime(date_str, '%Y-%m-%d').date()
+                rating=review_data['rating'],
-            except ValueError:
+                comment=review_data['comment']
-                target_date = timezone.now().date()
-        else:
-            target_date = timezone.now().date()
-
-        context['target_date'] = target_date
-
-        # 2. Aggregation: Bestellungen nach Gericht gruppieren
-        # Wir suchen alle Bestellungen, deren Menü am target_date stattfindet
-        summary_stats = (
-            Bestellung.objects.filter(menue__tag__datum=target_date)
-            .values('menue__gericht__name', 'menue__gericht__kategorie__name') # Gruppierung nach Name & Kategorie
-            .annotate(
-                anzahl=Count('id'),                      # Wie viele wurden bestellt?
-                umsatz=Sum('menue__preis')              # Was macht das für einen Umsatz?
             )
-            .order_by('menue__gericht__name')
+            return redirect('nach_bewertung')
-        )
-        context['summary_stats'] = summary_stats
 
-        # 3. Pager-Logik (identisch mit dem Speiseplan-View)
+        # Bei Fehler: Formular mit Fehlern erneut anzeigen
-        prev_tag = SpeiseplanTag.objects.filter(datum__lt=target_date).order_by('-datum').first()
+        return render(request, 'reviews/list.html', {'form': form, 'reviews': Review.objects.all()})
-        next_tag = SpeiseplanTag.objects.filter(datum__gt=target_date).order_by('datum').first()
-
-        context['prev_date'] = prev_tag.datum.strftime('%Y-%m-%d') if prev_tag else None
-        context['next_date'] = next_tag.datum.strftime('%Y-%m-%d') if next_tag else None
-
-        # 4. Gesamtzahlen für die Übersicht
-        context['total_bestellungen'] = Bestellung.objects.filter(menue__tag__datum=target_date).count()
-        context['total_umsatz'] = Bestellung.objects.filter(menue__tag__datum=target_date).aggregate(Sum('menue__preis'))['menue__preis__sum'] or 0
-
-        return context