# 🌐 Web-Version (MVP)

Diese Variante stellt den PDF-zu-ICS-Konverter im Browser bereit, damit die Nutzung auch auf mobilen Geräten möglich ist.

## Starten

### Linux/macOS
```bash
./start_web.sh
```

### Windows
Doppelklick auf `start_web.cmd`

Danach im Browser öffnen:
- Landingpage: `http://localhost:8000`
- Anwendung: `http://localhost:8000/app`
- Im Netzwerk (z. B. Smartphone): `http://<IP-des-Rechners>:8000/app`

## Docker (Server ohne VPN)

Diese Variante ist für deinen aktuellen Wunsch geeignet: öffentlich erreichbar ohne VPN.

### Docker-only Betrieb (empfohlen für Webserver)

Wenn auf dem Webserver **nur Docker laufen soll**, nutze die image-basierte Compose-Datei statt lokalem Build.

1) Vorlage übernehmen:

```bash
cp .env.example .env
```

2) Optional Werte in `.env` anpassen:

```dotenv
PDF_TO_ICS_IMAGE=ghcr.io/webfarben/pdf_to_ics:v1.0.0
WEB_AUTH_USER=
WEB_AUTH_PASSWORD=
```

3) Starten:

```bash
docker compose -f docker-compose.deploy.yml up -d
```

Kurzvariante für Erststart:

```bash
./deploy.sh
```

4) Update:

```bash
git pull
# in .env auf neues Release setzen, z. B. v1.1.0
docker compose -f docker-compose.deploy.yml pull
docker compose -f docker-compose.deploy.yml up -d
```

Kurzvariante mit Helper-Skript:

```bash
./update.sh
```

Hinweis: Für ein neues Release vorher den Tag in `.env` anpassen.

Damit entfallen lokale Python/venv-Abhängigkeiten auf dem Host vollständig.
Mit festem Tag bleiben Deployments reproduzierbar und Updates kontrolliert.

### Schlanker Checkout auf dem Server (Sparse)

Für einen neuen Server-Checkout kannst du den Arbeitsbaum klein halten:

```bash
git clone --filter=blob:none --sparse <REPO_URL> pdf_to_ics
cd pdf_to_ics
git sparse-checkout set docker-compose.deploy.yml .env.example deploy.sh update.sh WEB_README.md
```

Optional zusätzlich aufnehmen:

```bash
git sparse-checkout add README.md
```

Hinweis: Ein bestehender Voll-Clone wird dadurch nicht automatisch klein; dafür einmal neu klonen.

### 1) Starten

```bash
docker compose up -d --build
```

Aufruf:
- Landingpage: `http://<SERVER-IP>:8000`
- Anwendung: `http://<SERVER-IP>:8000/app`
- Oder mit Domain über Reverse Proxy (empfohlen)

### 2) Status und Logs

```bash
docker compose ps
docker compose logs -f pdf-to-ics-web
```

### 3) Stoppen / Update

```bash
docker compose down
git pull
docker compose up -d --build
```

### 4) Optional: App-Login aktivieren

In `docker-compose.yml` die beiden Variablen aktivieren:

```yaml
environment:
	- WEB_AUTH_USER=kalender
	- WEB_AUTH_PASSWORD=BitteSicheresPasswortSetzen
```

Dann neu starten:

```bash
docker compose up -d --build
```

Hinweis: Ohne VPN ist mindestens HTTPS + Basic Auth empfohlen, wenn die App öffentlich im Internet hängt.

## Funktionen

- PDF-Datei hochladen
- Optional Ruhetage ausschließen
- Optional Urlaub ausschließen
- ICS-Datei direkt herunterladen

## Hinweise für mobile Nutzung

- Smartphone und Server müssen im gleichen Netzwerk sein (lokaler Betrieb)
- Bei Internet-Betrieb sollte HTTPS und ein Reverse Proxy (z. B. Nginx) genutzt werden
- Hochgeladene Dateien werden nur temporär verarbeitet

## Technischer Aufbau

- `web/app.py` – FastAPI-Backend + Upload/Download-Endpunkte
- `web/templates/index.html` – mobile Web-Oberfläche
- `web/requirements-web.txt` – Web-spezifische Abhängigkeiten

## Produktion (Kurz)

Beispiel mit Uvicorn direkt:
```bash
.venv/bin/python -m uvicorn web.app:app --host 0.0.0.0 --port 8000
```

Optional mit App-Auth (zusätzliche Schutzschicht):
```bash
WEB_AUTH_USER=kalender WEB_AUTH_PASSWORD='StarkesPasswort' \
.venv/bin/python -m uvicorn web.app:app --host 0.0.0.0 --port 8000
```

Empfohlen für Internet-Betrieb:
- Uvicorn hinter Nginx
- HTTPS aktivieren
- Upload-Größenlimit setzen
- Zugriff absichern (z. B. Basic Auth oder Login)

## App-Auth (optional, zusätzlich zu Nginx)

Wenn `WEB_AUTH_USER` und `WEB_AUTH_PASSWORD` gesetzt sind, schützt die App alle Endpunkte per HTTP Basic Auth.

Linux/macOS Beispiel:
```bash
export WEB_AUTH_USER=kalender
export WEB_AUTH_PASSWORD='StarkesPasswort'
./start_web.sh
```

Windows (PowerShell) Beispiel:
```powershell
$env:WEB_AUTH_USER='kalender'
$env:WEB_AUTH_PASSWORD='StarkesPasswort'
./start_web.cmd
```

Hinweis: Für öffentlich erreichbare Server weiterhin Nginx + HTTPS verwenden.

## Öffentliches Deployment (HTTPS)

Beispiel für Ubuntu-Server mit Domain `ics.example.de`.

### 1) App als Service starten

`/etc/systemd/system/pdf-to-ics-web.service`

```ini
[Unit]
Description=PDF to ICS Web
After=network.target

[Service]
User=www-data
WorkingDirectory=/opt/pdf_to_ics
ExecStart=/opt/pdf_to_ics/.venv/bin/python -m uvicorn web.app:app --host 127.0.0.1 --port 8000
Restart=always
RestartSec=3

[Install]
WantedBy=multi-user.target
```

Aktivieren:

```bash
sudo systemctl daemon-reload
sudo systemctl enable --now pdf-to-ics-web
sudo systemctl status pdf-to-ics-web
```

### 2) Nginx als Reverse Proxy

`/etc/nginx/sites-available/pdf-to-ics`

```nginx
server {
	listen 80;
	server_name ics.example.de;

	client_max_body_size 10M;
	auth_basic "Geschuetzter Bereich";
	auth_basic_user_file /etc/nginx/.htpasswd-pdf-to-ics;

	location / {
		proxy_pass http://127.0.0.1:8000;
		proxy_set_header Host $host;
		proxy_set_header X-Real-IP $remote_addr;
		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
		proxy_set_header X-Forwarded-Proto $scheme;
	}
}
```

Aktivieren:

```bash
sudo ln -s /etc/nginx/sites-available/pdf-to-ics /etc/nginx/sites-enabled/pdf-to-ics
sudo nginx -t
sudo systemctl reload nginx
```

### 2b) Basic Auth einrichten (empfohlen)

```bash
sudo apt-get update
sudo apt-get install -y apache2-utils
sudo htpasswd -c /etc/nginx/.htpasswd-pdf-to-ics kalender
sudo nginx -t
sudo systemctl reload nginx
```

Weitere Nutzer hinzufügen (ohne `-c`):

```bash
sudo htpasswd /etc/nginx/.htpasswd-pdf-to-ics weiterer_user
```

Schnelltest:

```bash
curl -I https://ics.example.de
```

Erwartung: zuerst `401 Unauthorized`, mit Login im Browser dann Zugriff.

### 2c) IP-Whitelist (optional, zusätzlich)

Wenn nur bestimmte Netze zugreifen sollen, kann Nginx den Zugriff auf IP-Bereiche begrenzen.

Beispiel (lokales Netz + einzelne feste IP):

```nginx
location / {
	allow 192.168.178.0/24;
	allow 203.0.113.10;
	deny all;

	proxy_pass http://127.0.0.1:8000;
	proxy_set_header Host $host;
	proxy_set_header X-Real-IP $remote_addr;
	proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
	proxy_set_header X-Forwarded-Proto $scheme;
}
```

Danach prüfen und neu laden:

```bash
sudo nginx -t
sudo systemctl reload nginx
```

Kombiniert mit Basic Auth ist das eine robuste Mindestabsicherung.

### 3) HTTPS mit Let's Encrypt

```bash
sudo apt-get update
sudo apt-get install -y certbot python3-certbot-nginx
sudo certbot --nginx -d ics.example.de
```

Test der Erneuerung:

```bash
sudo certbot renew --dry-run
```

### 4) Mindest-Sicherheit

- Zugriffe absichern (mindestens Basic Auth)
- Optional zusätzlich per IP-Whitelist einschränken
- Upload-Limit klein halten (`client_max_body_size`)
- Server und Pakete regelmäßig aktualisieren