# Ressourcenplanung

Leichtgewichtige App zur Planung von Projekten, Aufgaben, Mitarbeitern und Teams –
mit Zeitplan (Gantt), Auslastungs-Heatmap und Team-Verwaltung. Daten liegen in SQLite.

## Aufbau

```
ressourcenplanung/
├── server/        Node/Express + SQLite (better-sqlite3)
│   ├── schema.sql     Tabellen & Beziehungen
│   ├── db.js          DB-Init + Beispieldaten
│   └── index.js       REST-API (CRUD + Auslastungsberechnung)
└── client/        Vue 3 + Vite
    └── src/
        ├── App.vue              Tab-Navigation
        ├── SchedulePanel.vue     Gantt-Zeitplan
        ├── UtilizationPanel.vue  Auslastungs-Heatmap
        ├── ProjectsPanel.vue     Projekte/Aufgaben inkl. Zuweisungen
        ├── EmployeesPanel.vue    Mitarbeiter
        ├── TeamsPanel.vue        Teams (n:m-Mitgliedschaft)
        ├── store.js              Reaktiver State + CRUD gegen die API
        ├── api.js                API-Client
        └── helpers.js            Datum-/Gantt-/Farbberechnung
```

## Lokale Entwicklung

Zwei Terminals.

**1) Backend**
```bash
cd server
npm install
npm run dev          # startet auf http://localhost:8080
```
Beim ersten Start wird `server/data/data.db` angelegt und mit Beispieldaten befüllt.

**2) Frontend**
```bash
cd client
npm install
npm run dev          # startet auf http://localhost:5173
```

Browser auf http://localhost:5173 öffnen. Vite leitet `/api` und `/health`
per Proxy an das Backend weiter.

## Deployment (Docker)

Die App läuft als ein Container: Das Backend serviert die REST-API und das
gebaute Frontend über denselben Port 8080.

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

Danach ist die App unter http://localhost:8080 erreichbar. Die SQLite-Datenbank
liegt im Docker-Volume `data`.

## Deployment in Coolify

1. **Repository verbinden**: Dieses Repo (`admin/ressourcenplanung` auf Gitea)
   in Coolify als neue Ressource hinzufügen (New Resource → Application →
   Gitea-Repo auswählen).
2. **Build-Pack**: **Docker Compose** wählen. Das mitgelieferte
   `docker-compose.yml` baut das `Dockerfile` (Multi-Stage: Vue-Build +
   Node-Server) und startet einen einzelnen Container.
3. **Port**: Der Container lauscht auf Port `8080`. In Coolify unter
   "Domains"/der Port-Konfiguration der Ressource **muss dieser Port (8080)
   explizit eingetragen werden** — das passiert nicht automatisch. Falls
   Port 8080 auf dem Host bereits von einer anderen Coolify-Ressource belegt
   ist, in `docker-compose.yml` den Host-Port anpassen (z. B. `"8081:8080"`)
   und die Coolify-Konfiguration entsprechend nachziehen.
4. **Persistenz**: Das Docker-Volume `data` sichert `server/data/data.db`
   (SQLite). Bei Redeploys bleiben die Daten erhalten, solange das Volume
   nicht gelöscht wird. Coolifys eingebaute Volume-Backup-Funktion kann
   dafür verwendet werden.
5. **Healthcheck**: Das Image bringt einen `HEALTHCHECK` gegen `/health`
   mit; Coolify nutzt ihn automatisch, um den Container-Status anzuzeigen.
6. **Deploy** klicken. Beim allerersten Start legt der Server automatisch
   `data.db` an und befüllt sie mit Beispieldaten.