# Zeitkonto

Eine kleine Web-App zur Arbeitszeiterfassung. Du trägst pro Tag Start-,
End- und Pausenzeit ein, die App berechnet daraus automatisch deine
Über- bzw. Minusstunden (dein "Zeitkonto") — pro Tag, pro Monat und als
laufenden Gesamtsaldo.

**Stack:** Node.js / Express / EJS, Daten werden in MongoDB gespeichert.
Login ist über einen einzelnen Benutzer geschützt (Zugangsdaten per
Umgebungsvariable).

## Funktionen

- Tägliche Buchung von Start-, Endzeit und Pause → automatische Berechnung
  der geleisteten Stunden
- Soll-Stunden pro Tag und Arbeitstage frei einstellbar (z. B. 8 h, Mo–Fr)
- Lauf­ender Gesamtsaldo (Überstunden/Minusstunden), inkl. optionalem
  Start-Guthaben für bereits bestehende Überstunden
- Monatsübersicht
- Bearbeiten und Löschen einzelner Buchungen
- Einfacher Login-Schutz (ein Benutzer, Zugangsdaten per Env-Variable)

## Lokal testen

Voraussetzung: Docker und Docker Compose.

```bash
cp .env.example .env
# .env nach Bedarf anpassen (APP_PASSWORD, SESSION_SECRET ...)

docker compose up --build
```

Die App ist danach unter `http://localhost:3000` erreichbar. Login mit den
Werten aus `APP_USERNAME` / `APP_PASSWORD` (Standard: `admin` / siehe
`.env.example`).

## Deployment in Coolify

Die App bringt ein fertiges `docker-compose.yml` mit (App + MongoDB inkl.
Volume für die Datenbank), das sich als ein einziges Coolify-Projekt
deployen lässt.

1. **Code in ein Git-Repository pushen** (GitHub, GitLab, Gitea, Bitbucket
   — egal, Coolify unterstützt alle gängigen Anbieter, auch selbst
   gehostete).
2. In Coolify: **New Resource → Docker Compose** und das Repository
   auswählen bzw. die URL eingeben. Coolify erkennt die `docker-compose.yml`
   automatisch (Build Pack: *Docker Compose*).
3. **Umgebungsvariablen setzen** (Tab *Environment Variables* der
   Resource): mindestens
   - `APP_USERNAME`
   - `APP_PASSWORD`
   - `SESSION_SECRET` (langer zufälliger String)

   `MONGODB_URI` und `PORT` sind in der `docker-compose.yml` bereits fest
   auf die interne Mongo-Verbindung gesetzt und müssen nicht verändert
   werden.
4. **Domain für die App vergeben.** Dafür zwei Möglichkeiten:
   - Im Coolify-UI bei der Resource den Service `app` öffnen und unter
     *Domains* eine Domain (oder Coolifys generierte `sslip.io`-Domain)
     eintragen, **oder**
   - in der `docker-compose.yml` die Zeile `# - SERVICE_FQDN_APP_3000`
     einkommentieren — Coolify generiert dann automatisch eine Domain auf
     Basis deiner Wildcard-Domain.
5. **Deploy** klicken. Coolify baut das Image, startet MongoDB und die App
   im selben internen Docker-Netzwerk und richtet automatisch HTTPS
   (Let's Encrypt) für die vergebene Domain ein.

Die MongoDB ist dabei **nicht** öffentlich erreichbar — sie läuft nur im
internen Netzwerk und ist für die App über den Service-Namen `mongo`
ansprechbar. Die Daten liegen in einem persistenten Volume (`mongo_data`)
und bleiben bei Redeploys erhalten.

### Alternative: Coolifys eigene Mongo-Datenbank nutzen

Statt MongoDB im `docker-compose.yml` mitlaufen zu lassen, kannst du in
Coolify auch **New Resource → Database → MongoDB** als eigene, separat
verwaltete Datenbank anlegen und die App stattdessen per `Dockerfile` als
normale *Application*-Resource deployen. Trag in diesem Fall die von
Coolify angezeigte Connection-String als `MONGODB_URI` in den
Umgebungsvariablen der App ein. Das `docker-compose.yml` brauchst du dann
nicht.

## Einstellungen nach dem ersten Login

Unter **Einstellungen** legst du fest:

- Soll-Arbeitszeit pro Arbeitstag (z. B. 8 Stunden)
- An welchen Wochentagen überhaupt gearbeitet wird
- Ein optionales Start-Guthaben in Stunden, falls du schon vor der
  Nutzung dieser App ein Über- oder Minusstunden-Konto hattest

Diese Werte wirken sich nur auf **neue** Buchungen aus — bereits
gespeicherte Tage behalten den Saldo, der zum Zeitpunkt ihrer Erfassung
berechnet wurde.

## Projektstruktur

```
zeitkonto/
├── server.js                 Einstiegspunkt (Express-App)
├── src/
│   ├── db.js                 MongoDB-Verbindung (mit Retry)
│   ├── middleware/auth.js    Login-Schutz
│   ├── models/                Mongoose-Schemas (TimeEntry, Settings)
│   ├── routes/                Login, Dashboard/Buchungen, Einstellungen
│   └── utils/time.js         Zeit-/Saldoberechnungen
├── views/                     EJS-Templates
├── public/css/style.css      Styling
├── Dockerfile
├── docker-compose.yml         App + MongoDB für Coolify/lokal
└── .env.example
```

## Sicherheitshinweis

Der Login schützt mit einem einzelnen Benutzernamen/Passwort-Paar aus den
Umgebungsvariablen. Das reicht für ein persönliches Tool hinter HTTPS
(Coolify richtet das automatisch ein), ersetzt aber kein vollwertiges
Mehrbenutzer-Auth-System. Setze in jedem Fall ein eigenes, starkes
`APP_PASSWORD` und einen zufälligen `SESSION_SECRET`, bevor du die App
öffentlich erreichbar machst.