SGTMensa/README.md

# SGTMensa

MensaApp für die Schulmensa am SGT

Muster-Implementation durch die Lehrkraft in python3 mit Django

## To get started

## Vorbereitung der virtuellen Entwicklungsumgebung

in einem Projekt-Vezeichnis über dem eigentlichen SGTMensa-Projekt-Ordner

```bash
python3 -m venv .venv
source .venv/bin/activate
pip install django
pip install pillow
```

Falls eine fish-Shell vorliegt:
```fish
python3 -m venv .venv
source .venv/bin/activate.fish
pip install django
pip install pillow
```

## Klonen des eigentlichen Projekts

```bash
git clone https://git.sgtlernen.de/mputzlocher/SGTMensa.git
```

## Starten des Servers

```bash
cd SGTMensa
python manage.py runserver
```


---

# Erweiterte Erklärung einzelner Schritte

### Schritt 1: Die Arbeitsumgebung isolieren (Virtual Environment)

Bevor du auch nur eine Zeile Code schreibst, erstelle eine eigene Umgebung. Das verhindert, dass sich verschiedene Projekte auf deinem Rechner gegenseitig stören.

1.  **Ordner erstellen:** `mkdir mensa_projekt` -> `cd mensa_projekt`
2. Virtuelle Umgebung erstellen:
   - Windows: `python -m venv venv`
   - Mac/Linux: `python3 -m venv .venv`
3. Aktivieren:
   - Windows: `venv\Scripts\activate`
   - Mac/Linux: `source .venv/bin/activate`

*Jetzt siehst du ein `(venv)` vor deiner Kommandozeile. Dein System ist nun "sauber".*

### Schritt 2: Das Fundament legen (Installation)

Installiere nur das Nötigste. Für den Start reicht Django.

```bash
pip install django
pip install pillow 
```

### Schritt 3: Das Projekt initialisieren (nur einmalig, beim ersten Start des Projekts)

Erstelle die Struktur eines Django-Projekts.

```bash
django-admin startproject mensa_core .
python manage.py startapp mensa_app
```

*Hinweis: Der Punkt `.` am Ende von `startproject` sorgt dafür, dass die Dateien im aktuellen Ordner erstellt werden und nicht ein Unterordner entsteht.*

### Schritt 4: Die App registrieren

Damit Django weiß, dass deine neue App `mensa_app` existiert, musst du sie in der Datei `mensa_core/settings.py` unter `INSTALLED_APPS` hinzufügen:

```python
INSTALLED_APPS = [
    ...
    'mensa_app',
]
```

### Schritt 5: Die Modelle implementieren

Jetzt kopierst du den Code für deine Klassen (aus unserer vorherigen Diskussion) in die Datei `mensa_app/models.py`.

### Schritt 6: Die Datenbank "erwecken" (Migrations)

Da du gerade Modelle definiert hast, muss die Datenbank (standardmäßig SQLite, was perfekt für Tests ist) diese Strukturen lernen.

```bash
python manage.py makemigrations mensa_app

python manage.py migrate
```

### Schritt 7: Der "Geheimweg" – Das Admin-Interface nutzen

Das ist der Clou an Django! Du musst noch keine eigenen Webseiten (HTML) programmieren, um Daten einzugeben. Django liefert ein fertiges Interface mit.

1. **Admin-User erstellen:**

   ```bash
   python manage.py createsuperuser
   ```

   

   (Folge den Anweisungen: Name, Email, Passwort – das Passwort wird beim Tippen nicht angezeigt!)

2. **Modelle im Admin registrieren:**
   Gehe in `mensa_app/admin.py` und schreibe:

   ```bash
   1. from django.contrib import admin
   
      from .models import DeinModellName # Ersetze dies durch deine echten Klassennamen
   
      admin.site.register(DeinModellName)
   
   ```

   

### Schritt 8: Den Server starten

Jetzt kommt der magische Moment:

```bash
python manage.py runserver
```



Öffne deinen Browser unter `http://127.0.0.1:8000/admin`. Logge dich mit deinem Superuser ein. **Herzlichen Glückwunsch!** Du hast eine voll funktionsfähige Web-Anwendung, mit der du bereits Speisepläne und Bestellungen in einer Datenbank verwalten kannst.


### Schritt 9: Eigentliche Entwicklungsarbeit

Folgende Befehle werden nacheinander ausgeführt:

#### Eigenen Projektbaum auf dem lokalen Rechen auf den aktuellen Stand bringen

Öffne ein Terminal und navigiere in das Projektverzeichnis, das bereits über `git clone` abgeholt worden ist.

zum Beispiel:
```bash
cd ~/projects/SGTMensa
```

Hole den aktuellen Stand ab:
```bash
git pull
```

Aktiviere die virtuelle Entwicklungsumgebung (falls noch nicht geschehen):
```bash
source .venv/bin/activate
```

Führe notwendige Migrationen der bestehenden Datenbank aus:
```bash
python manage.py makemigrations
python manage.py migrate
```

Starte den Server des Projekts:
```bash
python manage.py runserver
```
Jetzt bist Du startklar für die Entwicklungsarbeit und solltest den aktuellen Stand im Browser unter `http://localhost:8000/` abrufen können.

#### Änderungen vornehmen

Django erkennt selbstständig Veränderungen am Quellcode und startet den Webserver neu. Achte auf Fehlermeldungen!

#### Änderungen wieder auf den git-Server einspielen

Nach einem Entwicklungsschritt solltest Du Deine Änderungen von Deinem lokalen Rechner wieder auf den git-Server hochladen,
damit Dein Team auch sieht, was Du gemacht hast, und damit Deine Ergänzungen und Änderungen wieder in den gemeinsamen
Code integriert werden können.

Nachsehen der Änderungen:
```bash
git status
```
Dies zeigt alle veränderten Dateien an.

Veränderte Dateien ins Änderungspaket aufnehmen:
```bash
git add .
```

Veränderungen bestätigen und beschreiben:
```bash
git commit -m "Deine sinnvolle Beschreibung der Änderung in wenigen Worten"
```

Veränderungen auf den git-Server hochladen:
```bash
git push
```