310 lines
12 KiB
Python
310 lines
12 KiB
Python
from django.db import models
|
||
from django.contrib.auth.models import User
|
||
from django.utils import timezone
|
||
import datetime
|
||
|
||
import os
|
||
from django.db import models
|
||
from django.core.exceptions import ValidationError
|
||
from django.core.validators import FileExtensionValidator
|
||
# Pillow ist für die Bildbearbeitung zuständig (installiere per pip install pillow)
|
||
from PIL import Image as PilImage
|
||
|
||
# Optional: Wenn du später Thumbnails mit sorl-thumbnail nutzen möchtest:
|
||
# from sorl.thumbnail import get_thumbnail
|
||
|
||
class Person(models.Model):
|
||
"""Repräsentiert Schüler oder Lehrer."""
|
||
user = models.OneToOneField(User, on_delete=models.CASCADE)
|
||
rolle = models.CharField(max_length=20, choices=[('schueler', 'Schüler'), ('lehrer', 'Lehrer'), ('mitarbeiter','Mensa-Mitarbeiter'), ('chef','Mensa-Leitung')])
|
||
klasse = models.CharField(max_length=4, blank=True, null=True) # Nur für Schüler relevant
|
||
|
||
class Meta:
|
||
verbose_name_plural = "Personen"
|
||
|
||
def __str__(self):
|
||
return f"{self.user.username} ({self.rolle})"
|
||
|
||
|
||
class Schulwoche(models.Model):
|
||
"""Repräsentiert eine Schulwoche mit einem eindeutigen Datum."""
|
||
|
||
id = models.CharField(max_length=20, unique=True, primary_key=True, default="test_1") # eine eindeutige ID wie "Woche_2024_10"
|
||
datum = models.DateField(unique=True) # Datum der Schulwoche (z. B. Montag der ersten Woche)
|
||
|
||
ist_aktiv = models.BooleanField(default=False)
|
||
ist_ferienwoche = models.BooleanField(default=False)
|
||
|
||
class Meta:
|
||
verbose_name = "Schulwoche"
|
||
verbose_name_plural = "Schulwochen"
|
||
|
||
|
||
class SpeiseplanTag(models.Model):
|
||
"""Ein bestimmter Tag im Speiseplan."""
|
||
datum = models.DateField(unique=True)
|
||
|
||
schulwoche = models.ForeignKey(
|
||
Schulwoche,
|
||
on_delete=models.CASCADE,
|
||
#related_name='tag_get_schulwoche' # Für Abfragen wie: Schulwoche.tag_get_schulwoche.all()
|
||
default = "test_1"
|
||
)
|
||
|
||
class Meta:
|
||
verbose_name = "Tag mit Speiseplan"
|
||
verbose_name_plural = "Tage mit Speiseplan"
|
||
|
||
def __str__(self):
|
||
return self.datum.strftime('%d.%m.%Y')
|
||
|
||
class Kategorie(models.Model):
|
||
"""
|
||
Definiert die Art der Speise (Süßspeise, Hauptgericht, etc.).
|
||
"""
|
||
name = models.CharField(max_length=50, unique=True, default="")
|
||
|
||
class Meta:
|
||
verbose_name = "Kategorie"
|
||
verbose_name_plural = "Kategorien"
|
||
|
||
def __str__(self):
|
||
return self.name
|
||
|
||
class Gericht(models.Model):
|
||
"""Ein einzelnes Gericht (z.B. 'Nudeln mit Tomatensauce')."""
|
||
name = models.CharField(max_length=100)
|
||
# PROTECT verhindert, dass eine Kategorie gelöscht wird,
|
||
# solange noch Gerichte ihr zugeordnet sind.
|
||
kategorie = models.ForeignKey(
|
||
Kategorie,
|
||
on_delete=models.PROTECT,
|
||
related_name='gerichte'
|
||
)
|
||
ist_vegetarisch = models.BooleanField(default=False)
|
||
ist_allergene_frei = models.BooleanField(default=False)
|
||
allergene = models.TextField(blank=True, default="")
|
||
preis = models.DecimalField(max_digits=5, decimal_places=2, default=0.00)
|
||
|
||
now = datetime.datetime.now()
|
||
|
||
time_last_change = models.TimeField(default=now)
|
||
time_creation = models.TimeField(default=now)
|
||
|
||
# Das Attribut für das "Dauerangebot"
|
||
ist_dauerangebot = models.BooleanField(
|
||
default=False,
|
||
help_text="Wenn aktiviert, ist dieses Gericht immer verfügbar und nicht an einen spezifischen Tag gebunden."
|
||
)
|
||
|
||
def __str__(self):
|
||
return f"{self.name} ({self.kategorie.name})"
|
||
|
||
class Meta:
|
||
verbose_name = "Gericht"
|
||
verbose_name_plural = "Gerichte"
|
||
permissions = [("can_create_Gericht", "Kann neues Gericht anlegen")]
|
||
ordering = ["kategorie", "name", "preis"]
|
||
get_latest_by = "time_last_change"
|
||
|
||
class Menue(models.Model):
|
||
"""Eine Kombination von Speisen für einen Tag (z.B. Hauptgang + Dessert)."""
|
||
tag = models.ForeignKey(SpeiseplanTag, on_delete=models.CASCADE, related_name='menues')
|
||
gericht = models.ForeignKey(Gericht, on_delete=models.CASCADE)
|
||
preis = models.DecimalField(max_digits=5, decimal_places=2)
|
||
|
||
def __str__(self):
|
||
return f"{self.tag.datum}: {self.gericht.name} ({self.preis}€)"
|
||
|
||
class Meta:
|
||
verbose_name = "Menü"
|
||
verbose_name_plural = "Menüs"
|
||
|
||
class Bestellung(models.Model):
|
||
"""Eine abgeschlossene Bestellung eines Nutzers."""
|
||
STATUS_CHOICES = [
|
||
('offen', 'Offen'),
|
||
('abgeholt', 'Abgeholt'),
|
||
('verwaist', 'Nicht abgeholt'),
|
||
('bezahlt', 'Bezahlt'),
|
||
('storniert', 'Storniert'),
|
||
]
|
||
|
||
person = models.ForeignKey(Person, on_delete=models.CASCADE)
|
||
menue = models.ForeignKey(Menue, on_delete=models.CASCADE)
|
||
datum_bestellung = models.DateTimeField(default=timezone.now)
|
||
status = models.CharField(max_length=10, choices=STATUS_CHOICES, default='offen')
|
||
bezahlt = models.BooleanField(default=False)
|
||
|
||
def __str__(self):
|
||
return f"Bestellung {self.id} von {self.person.user.username}"
|
||
|
||
class Meta:
|
||
verbose_name = "Bestellung"
|
||
verbose_name_plural = "Bestellungen"
|
||
|
||
|
||
from django.core.exceptions import ValidationError
|
||
|
||
|
||
class Bewertung(models.Model):
|
||
"""
|
||
Repräsentiert die Bewertung eines Gerichts durch einen Nutzer.
|
||
"""
|
||
|
||
class Sterne(models.IntegerChoices):
|
||
EINER = 1, '★☆☆☆☆'
|
||
ZWEI = 2, '★★☆☆☆'
|
||
DREI = 3, '★★★☆☆'
|
||
VIER = 4, '★★★★☆'
|
||
FUENF = 5, '★★★★★'
|
||
|
||
user = models.ForeignKey('Person', on_delete=models.CASCADE, related_name='bewertungen')
|
||
gericht = models.ForeignKey('Gericht', on_delete=models.CASCADE, related_name='bewertungen')
|
||
sterne = models.IntegerField(choices=Sterne.choices, default=3)
|
||
kommentar = models.TextField(blank=True, null=True)
|
||
datum = models.DateTimeField(auto_now_add=True)
|
||
|
||
# Das Feld für die Verifizierung
|
||
ist_verifiziert = models.BooleanField(
|
||
default=False,
|
||
help_text="Wird automatisch auf True gesetzt, wenn eine bezahlte Bestellung vorliegt."
|
||
)
|
||
|
||
class Meta:
|
||
# Verhindert, dass ein Nutzer dasselbe Gericht mehrfach bewertet
|
||
unique_together = ('user', 'gericht')
|
||
verbose_name = "Bewertung"
|
||
verbose_name_plural = "Bewertungen"
|
||
|
||
def __str__(self):
|
||
return f"{self.user.user.username} bewertet {self.gericht.name} mit {self.sterne} Sternen"
|
||
|
||
def clean(self):
|
||
"""
|
||
Hier können wir zusätzliche Validierungen einbauen.
|
||
"""
|
||
if self.sterne < 1 or self.sterne > 5:
|
||
raise ValidationError("Die Bewertung muss zwischen 1 und 5 Sternen liegen.")
|
||
|
||
def check_verifizierung(self):
|
||
"""
|
||
Ein hilfreicher Service-Method, um den Status der Verifizierung
|
||
automatisch zu prüfen.
|
||
"""
|
||
# Wir prüfen, ob es eine Bestellung für diesen User und dieses Gericht gibt,
|
||
# die bereits als 'bezahlt' markiert ist.
|
||
exists = Bestellung.objects.filter(
|
||
person=self.user,
|
||
menue__gericht=self.gericht,
|
||
bezahlt=True
|
||
).exists()
|
||
|
||
if exists:
|
||
self.ist_verifiziert = True
|
||
return self.ist_verifiziert
|
||
|
||
class GerichtBild(models.Model):
|
||
"""
|
||
Speichert ein hochgeladenes Bild für ein Gericht.
|
||
- Kann später beliebig erweitert werden (z.B. Beschreibung, Sortierreihenfolge).
|
||
"""
|
||
gericht = models.ForeignKey(
|
||
'Gericht', # Verweis auf das Gericht
|
||
on_delete=models.CASCADE, # Wenn das Gericht gelöscht wird, lösche auch die Bilder
|
||
related_name='bilder' # -> Gericht.bilder.all()
|
||
)
|
||
|
||
image = models.ImageField( # Typ: Bild‑Datei (JPEG)
|
||
upload_to='gerichte_bilder/', # Unterordner im MEDIA_ROOT
|
||
validators=[FileExtensionValidator(['jpg', 'jpeg'])], # Nur JPEG zulassen
|
||
help_text="Bitte nur JPEG-Dateien (.jpg/.jpeg) hochladen."
|
||
)
|
||
|
||
# Optional: Sortierreihenfolge, wenn mehrere Bilder angezeigt werden sollen
|
||
sort_order = models.PositiveIntegerField(default=0)
|
||
|
||
class Meta:
|
||
# Verhindert, dass ein Bild mehrfach zu einem Gericht angelegt wird
|
||
unique_together = ('image', 'gericht')
|
||
verbose_name = "Bild"
|
||
verbose_name_plural = "Bilder"
|
||
|
||
def clean(self):
|
||
"""
|
||
Zusätzliche Validierung – wird vor dem Speichern aufgerufen,
|
||
wenn du .full_clean() oder ModelForm nutzt.
|
||
"""
|
||
# Prüfe ob die Datei tatsächlich ein JPEG ist (optional, da Validator schon hilft)
|
||
_, ext = os.path.splitext(self.image.name.lower())
|
||
if ext not in ('.jpg', '.jpeg'):
|
||
raise ValidationError('Nur JPEG-Dateien sind erlaubt.')
|
||
|
||
def _resize_image_if_needed(self):
|
||
"""
|
||
Verkleinert das hochgeladene Bild auf maximal 640 × 480 px
|
||
(beibehält Seitenverhältnis). Überschreibt die Originaldatei.
|
||
"""
|
||
# Sicherstellen, dass ein Dateiname vorhanden ist und die Datei lesbar ist
|
||
if not self.image or not self.image.name:
|
||
return
|
||
|
||
try:
|
||
# Öffne das Bild mit Pillow – .open('rb') liefert eine File‑Instanz
|
||
with self.image.open('rb') as img_file:
|
||
pil_img = PilImage.open(img_file)
|
||
pil_img = pil_img.convert('RGB')
|
||
|
||
# thumbnail passt das Bild in die Grenzen (640×480) und behält
|
||
# das Seitenverhältnis bei.
|
||
pil_img.thumbnail((640, 480), PilImage.LANCZOS)
|
||
|
||
# Schreibe das verkleinerte Bild zurück in dieselbe Datei.
|
||
# storage = self.image.field.storage # z.B. FileSystemStorage
|
||
storage = self.image.field.storage
|
||
path = self.image.path
|
||
|
||
with storage.open(path, 'wb') as out_f:
|
||
pil_img.save(out_f, format='JPEG', quality=85)
|
||
|
||
except Exception as exc:
|
||
# Im Produktiv‑Betrieb wäre hier ein Logging sinnvoll.
|
||
print(f'Fehler beim Verkleinern von {self.image.name}: {exc}')
|
||
|
||
|
||
def save(self, *args, **kwargs):
|
||
"""
|
||
Überschreibe das Speichern, um das Bild automatisch auf 640×480 px
|
||
(oder darunter) zu verkleinern. Das Ergebnis überschreibt die Original‑Datei.
|
||
"""
|
||
# 1️⃣ Führe die normale save() aus – nötig, damit wir später den Pfad haben
|
||
super().save(*args, **kwargs)
|
||
|
||
# 2️⃣ Führe die Verkleinerung nur dann aus, wenn tatsächlich ein Bild da ist.
|
||
if self.image and self.image.name:
|
||
self._resize_image_if_needed()
|
||
|
||
def delete(self, *args, **kwargs):
|
||
"""
|
||
Erweiterte Delete‑Logik:
|
||
1. Versuche die Datei aus dem Storage zu löschen (falls sie existiert).
|
||
2. Führe eigene Aktionen durch (z.B. Logging).
|
||
3. Rufe die Standard‑Delete‑Methode auf, um den DB‑Eintrag zu entfernen.
|
||
"""
|
||
# --- 1️⃣ Versuche die Datei zu löschen -------------------------------------------------
|
||
storage = self.image.field.storage # z.B. FileSystemStorage
|
||
path = self.image.path # vollständiger Pfad im Media-Ordner
|
||
|
||
try:
|
||
if storage.exists(path):
|
||
# Optional: Backup, Logging usw.
|
||
print(f"[DELETE] Bild entfernt: {path}")
|
||
|
||
storage.delete(path) # tatsächliches Löschen der Datei
|
||
except Exception as exc:
|
||
# Im Produktiv‑Betrieb besser mit logging.exception() umgehen
|
||
print(f"Warnung – konnte die Bilddatei nicht löschen ({exc})")
|
||
|
||
# --- 2️⃣ Rufe die normale Django-Delete‑Logik auf ------------------------------------
|
||
super().delete(*args, **kwargs) # löscht den DB‑Eintrag
|