Compare commits
46
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
b4a1856f79 | ||
|
|
9e6a542289 | ||
|
|
c7d283c0c9 | ||
|
|
d826524789 | ||
|
|
548d733048 | ||
|
|
6845397866 | ||
|
|
2df70b2a6b | ||
|
|
85f48907a4 | ||
|
|
c40b30737a | ||
|
|
961f905279 | ||
|
|
3f4ef75463 | ||
|
|
4886f00826 | ||
|
|
518e417b1d | ||
|
|
115d975335 | ||
|
|
e10e9d7eb9 | ||
|
|
b6f8b11685 | ||
|
|
64d1b9bf7b | ||
|
|
a0660e7a40 | ||
|
|
0797a8f55c | ||
|
|
47a268f426 | ||
|
|
f7f7f745b1 | ||
|
|
8e25b54cc2 | ||
|
|
1db780858b | ||
|
|
3d58a2db8e | ||
|
|
36f334aba7 | ||
|
|
8390c7f510 | ||
|
|
79a951ce92 | ||
|
|
9fbedb6c4b | ||
|
|
124df01983 | ||
|
|
7758bbf12e | ||
|
|
d15ec056b4 | ||
|
|
39a7b1be78 | ||
|
|
d2c578de83 | ||
|
|
6f0f1ae9b4 | ||
|
|
ad433a470f | ||
|
|
627eb8e265 | ||
|
|
67b00b941e | ||
|
|
ec3c279e11 | ||
|
|
56edd16368 | ||
|
|
0a871fea22 | ||
|
|
c4cead9e27 | ||
|
|
c36085daa4 | ||
|
|
4a6dc37854 | ||
|
|
eadc0ea39c | ||
|
|
1d169b1228 | ||
|
|
b409a22322 |
No files matched your search
+6
-6
@@ -1,9 +1,9 @@
|
||||
# ── Datenbank ──────────────────────────────────────────────────
|
||||
# v9 (PostgreSQL):
|
||||
DB_PASSWORD=sicheres_passwort_hier
|
||||
|
||||
# v8 (SQLite, legacy):
|
||||
# DATA_DIR=/app/data
|
||||
# ── Datenbank (PostgreSQL v9b+) ────────────────────────────────
|
||||
DB_HOST=postgres
|
||||
DB_PORT=5432
|
||||
DB_NAME=mitai
|
||||
DB_USER=mitai
|
||||
DB_PASSWORD=mitaiDB-PostgreSQL-Neckar-strong
|
||||
|
||||
# ── KI ─────────────────────────────────────────────────────────
|
||||
# OpenRouter (empfohlen):
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
name: Deploy Development
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [develop]
|
||||
|
||||
jobs:
|
||||
deploy:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Deploy to Development
|
||||
run: |
|
||||
set -e
|
||||
echo "=== Deploying to DEVELOPMENT ==="
|
||||
cd /home/lars/docker/bodytrack-dev
|
||||
git pull origin develop
|
||||
docker compose -f docker-compose.dev-env.yml build --no-cache
|
||||
docker compose -f docker-compose.dev-env.yml up -d
|
||||
sleep 5
|
||||
curl -sf http://localhost:8099/api/auth/status && echo "✓ DEV API healthy"
|
||||
echo "=== DEV Deploy complete ==="
|
||||
@@ -0,0 +1,21 @@
|
||||
name: Deploy Production
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [main]
|
||||
|
||||
jobs:
|
||||
deploy:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Deploy to Production
|
||||
run: |
|
||||
set -e
|
||||
echo "=== Deploying to PRODUCTION ==="
|
||||
cd /home/lars/docker/bodytrack
|
||||
git pull origin main
|
||||
docker compose -f docker-compose.yml build --no-cache
|
||||
docker compose -f docker-compose.yml up -d
|
||||
sleep 5
|
||||
curl -sf http://localhost:8002/api/auth/status && echo "✓ PROD API healthy"
|
||||
echo "=== PROD Deploy complete ==="
|
||||
@@ -1,38 +0,0 @@
|
||||
name: Deploy to Raspberry Pi
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [main]
|
||||
|
||||
jobs:
|
||||
deploy:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v3
|
||||
|
||||
- name: Deploy via SSH
|
||||
uses: appleboy/ssh-action@v1.0.0
|
||||
with:
|
||||
host: ${{ secrets.DEPLOY_HOST }}
|
||||
username: ${{ secrets.DEPLOY_USER }}
|
||||
key: ${{ secrets.DEPLOY_SSH_KEY }}
|
||||
script: |
|
||||
set -e
|
||||
cd /home/lars/docker/mitai
|
||||
|
||||
echo "=== Pulling latest code ==="
|
||||
git pull origin main
|
||||
|
||||
echo "=== Rebuilding containers ==="
|
||||
docker compose build --no-cache
|
||||
|
||||
echo "=== Restarting ==="
|
||||
docker compose up -d
|
||||
|
||||
echo "=== Health check ==="
|
||||
sleep 5
|
||||
docker ps | grep jinkendo
|
||||
curl -sf http://localhost:8002/api/auth/status | python3 -c "import sys,json; d=json.load(sys.stdin); print('✓ API healthy')" || echo "⚠ API check failed"
|
||||
|
||||
echo "=== Deploy complete ==="
|
||||
+14
-23
@@ -3,31 +3,22 @@ name: Build Test
|
||||
on:
|
||||
push:
|
||||
branches: [main, develop]
|
||||
pull_request:
|
||||
branches: [main]
|
||||
|
||||
jobs:
|
||||
build-frontend:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v3
|
||||
- uses: actions/setup-node@v3
|
||||
with:
|
||||
node-version: '20'
|
||||
- name: Install & Build
|
||||
working-directory: ./frontend
|
||||
run: |
|
||||
npm install
|
||||
npm run build
|
||||
- name: Check build output
|
||||
run: ls -la frontend/dist/
|
||||
|
||||
lint-backend:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v3
|
||||
- uses: actions/setup-python@v4
|
||||
with:
|
||||
python-version: '3.12'
|
||||
- name: Check syntax
|
||||
run: python3 -m py_compile backend/main.py && echo "✓ Backend syntax OK"
|
||||
- name: Check backend syntax
|
||||
run: |
|
||||
python3 -m py_compile /home/lars/docker/bodytrack/backend/main.py
|
||||
echo "✓ Backend syntax OK"
|
||||
|
||||
build-frontend:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Build frontend
|
||||
run: |
|
||||
cd /home/lars/docker/bodytrack/frontend
|
||||
npm install
|
||||
npm run build
|
||||
echo "✓ Frontend build OK"
|
||||
@@ -58,3 +58,7 @@ coverage/
|
||||
# Temp
|
||||
tmp/
|
||||
*.tmp
|
||||
|
||||
#.claude Konfiguration
|
||||
.claude/
|
||||
.claude/settings.local.json
|
||||
@@ -1,33 +1,50 @@
|
||||
# Mitai Jinkendo – Entwickler-Kontext für Claude Code
|
||||
|
||||
## Projekt-Übersicht
|
||||
**Mitai Jinkendo** ist eine selbst-gehostete PWA für Körper-Tracking (Gewicht, Körperfett, Umfänge, Ernährung, Aktivität) mit KI-Auswertung. Teil der **Jinkendo**-App-Familie (人拳道 – Der menschliche Weg der Kampfkunst).
|
||||
**Mitai Jinkendo** (身体 Jinkendo) ist eine selbst-gehostete PWA für Körper-Tracking (Gewicht, Körperfett, Umfänge, Ernährung, Aktivität) mit KI-Auswertung. Teil der **Jinkendo**-App-Familie (人拳道 – Der menschliche Weg der Kampfkunst).
|
||||
|
||||
**Produktfamilie:** body · fight · guard · train · mind (alle unter jinkendo.de)
|
||||
**Produktfamilie:** mitai · miken · ikigai · shinkan · kenkou (alle unter jinkendo.de)
|
||||
|
||||
## Tech-Stack
|
||||
| Komponente | Technologie | Version |
|
||||
|-----------|-------------|---------|
|
||||
| Frontend | React 18 + Vite + PWA | Node 20 |
|
||||
| Backend | FastAPI (Python) | Python 3.12 |
|
||||
| Datenbank | PostgreSQL | 16 (Ziel: v9) / SQLite (aktuell: v8) |
|
||||
| Datenbank | PostgreSQL 16 (Alpine) | v9b |
|
||||
| Container | Docker + Docker Compose | - |
|
||||
| Webserver | nginx (Reverse Proxy + HTTPS) | Alpine |
|
||||
| Auth | Token-basiert (eigene Impl.) | - |
|
||||
| Webserver | nginx (Reverse Proxy) | Alpine |
|
||||
| Auth | Token-basiert + bcrypt | - |
|
||||
| KI | OpenRouter API (claude-sonnet-4) | - |
|
||||
|
||||
## Ports
|
||||
| Service | Intern | Extern (Dev) |
|
||||
|---------|--------|-------------|
|
||||
| Frontend | 80 (nginx) | 3002 |
|
||||
| Backend | 8000 (uvicorn) | 8002 |
|
||||
| PostgreSQL | 5432 | nicht exponiert |
|
||||
| Service | Prod | Dev |
|
||||
|---------|------|-----|
|
||||
| Frontend | 3002 | 3099 |
|
||||
| Backend | 8002 | 8099 |
|
||||
|
||||
## Verzeichnisstruktur
|
||||
```
|
||||
mitai-jinkendo/
|
||||
├── backend/
|
||||
│ ├── main.py # FastAPI App, alle Endpoints
|
||||
│ ├── main.py # FastAPI App Setup + Router Registration (~75 Zeilen)
|
||||
│ ├── db.py # PostgreSQL Connection Pool + Helpers
|
||||
│ ├── auth.py # Auth Functions (hash, verify, sessions)
|
||||
│ ├── models.py # Pydantic Models (11 Models)
|
||||
│ ├── routers/ # Modular Endpoint Structure (14 Router)
|
||||
│ │ ├── auth.py # Login, Logout, Password Reset (7 Endpoints)
|
||||
│ │ ├── profiles.py # Profile CRUD + Current User (7 Endpoints)
|
||||
│ │ ├── weight.py # Weight Tracking (5 Endpoints)
|
||||
│ │ ├── circumference.py # Body Measurements (4 Endpoints)
|
||||
│ │ ├── caliper.py # Skinfold Tracking (4 Endpoints)
|
||||
│ │ ├── activity.py # Workout Logging + CSV Import (6 Endpoints)
|
||||
│ │ ├── nutrition.py # Nutrition + FDDB Import (4 Endpoints)
|
||||
│ │ ├── photos.py # Progress Photos (3 Endpoints)
|
||||
│ │ ├── insights.py # AI Analysis + Pipeline (8 Endpoints)
|
||||
│ │ ├── prompts.py # AI Prompt Management (2 Endpoints)
|
||||
│ │ ├── admin.py # User Management (7 Endpoints)
|
||||
│ │ ├── stats.py # Dashboard Stats (1 Endpoint)
|
||||
│ │ ├── exportdata.py # CSV/JSON/ZIP Export (3 Endpoints)
|
||||
│ │ └── importdata.py # ZIP Import (1 Endpoint)
|
||||
│ ├── requirements.txt
|
||||
│ └── Dockerfile
|
||||
├── frontend/
|
||||
@@ -38,113 +55,160 @@ mitai-jinkendo/
|
||||
│ │ │ ├── AuthContext.jsx # Session, Login, Logout
|
||||
│ │ │ └── ProfileContext.jsx # Aktives Profil
|
||||
│ │ ├── pages/ # Alle Screens
|
||||
│ │ ├── utils/
|
||||
│ │ │ ├── api.js # Alle API-Calls (injiziert Token + ProfileId)
|
||||
│ │ │ ├── calc.js # Körperfett-Formeln
|
||||
│ │ │ ├── interpret.js # Regelbasierte Auswertung
|
||||
│ │ │ ├── Markdown.jsx # Eigener MD-Renderer
|
||||
│ │ │ └── guideData.js # Messanleitungen
|
||||
│ │ └── main.jsx
|
||||
│ ├── public/ # Icons (Jinkendo Ensō-Logo)
|
||||
│ ├── index.html
|
||||
│ ├── vite.config.js
|
||||
│ └── Dockerfile
|
||||
├── nginx/
|
||||
│ └── nginx.conf
|
||||
├── docker-compose.yml # Produktion
|
||||
├── docker-compose.dev.yml # Entwicklung (Hot-Reload)
|
||||
├── .env.example
|
||||
└── CLAUDE.md # Diese Datei
|
||||
│ │ └── utils/
|
||||
│ │ ├── api.js # Alle API-Calls (injiziert Token automatisch)
|
||||
│ │ ├── calc.js # Körperfett-Formeln
|
||||
│ │ ├── interpret.js # Regelbasierte Auswertung
|
||||
│ │ ├── Markdown.jsx # Eigener MD-Renderer
|
||||
│ │ └── guideData.js # Messanleitungen
|
||||
│ └── public/ # Icons (Jinkendo Ensō-Logo)
|
||||
├── .gitea/workflows/
|
||||
│ ├── deploy-prod.yml # Auto-Deploy bei Push auf main
|
||||
│ ├── deploy-dev.yml # Auto-Deploy bei Push auf develop
|
||||
│ └── test.yml # Build-Test bei jedem Push
|
||||
├── docker-compose.yml # Produktion (Ports 3002/8002)
|
||||
├── docker-compose.dev-env.yml # Development (Ports 3099/8099)
|
||||
└── CLAUDE.md # Diese Datei
|
||||
```
|
||||
|
||||
## Aktuelle Version: v8
|
||||
## Aktuelle Version: v9b
|
||||
|
||||
### Was implementiert ist:
|
||||
- ✅ Multi-User mit PIN/Passwort-Auth + Token-Sessions
|
||||
- ✅ Multi-User mit E-Mail + Passwort Login (bcrypt)
|
||||
- ✅ Auth-Middleware auf ALLE Endpoints (60+ Endpoints geschützt)
|
||||
- ✅ Rate Limiting (Login: 5/min, Reset: 3/min)
|
||||
- ✅ CORS konfigurierbar via ALLOWED_ORIGINS in .env
|
||||
- ✅ Admin/User Rollen, KI-Limits, Export-Berechtigungen
|
||||
- ✅ Gewicht, Umfänge, Caliper (4 Formeln), Ernährung, Aktivität
|
||||
- ✅ FDDB CSV-Import (Ernährung), Apple Health CSV-Import (Aktivität)
|
||||
- ✅ KI-Analyse: 6 Einzel-Prompts + 3-stufige Pipeline (parallel)
|
||||
- ✅ Konfigurierbare Prompts mit Template-Variablen
|
||||
- ✅ Konfigurierbare Prompts mit Template-Variablen (Admin kann bearbeiten)
|
||||
- ✅ Verlauf mit 5 Tabs + Zeitraumfilter + KI pro Sektion
|
||||
- ✅ Dashboard mit Kennzahlen, Zielfortschritt, Combo-Chart
|
||||
- ✅ Assistent-Modus (Schritt-für-Schritt Messung)
|
||||
- ✅ PWA (iPhone Home Screen), Jinkendo-Icon
|
||||
- ✅ PWA (iPhone Home Screen), Jinkendo Ensō-Logo
|
||||
- ✅ E-Mail (SMTP) für Password-Recovery
|
||||
- ✅ Admin-Panel: User verwalten, KI-Limits, E-Mail-Test
|
||||
- ✅ Admin-Panel: User verwalten, KI-Limits, E-Mail-Test, PIN/Email setzen
|
||||
- ✅ Multi-Environment: Prod (mitai.jinkendo.de) + Dev (dev.mitai.jinkendo.de)
|
||||
- ✅ Gitea CI/CD mit Auto-Deploy auf Raspberry Pi 5
|
||||
- ✅ PostgreSQL 16 Migration (vollständig von SQLite migriert)
|
||||
- ✅ Export: CSV, JSON, ZIP (mit Fotos)
|
||||
- ✅ Automatische SQLite→PostgreSQL Migration bei Container-Start
|
||||
- ✅ **Modulare Backend-Architektur**: 14 Router-Module, main.py von 1878→75 Zeilen (-96%)
|
||||
|
||||
### Was in v9 kommt:
|
||||
- 🔲 PostgreSQL Migration (aktuell: SQLite)
|
||||
- 🔲 Auth-Middleware auf ALLE Endpoints
|
||||
- 🔲 bcrypt statt SHA256
|
||||
- 🔲 Rate Limiting
|
||||
- 🔲 CORS auf Domain beschränken
|
||||
### Was in v9c kommt:
|
||||
- 🔲 Selbst-Registrierung mit E-Mail-Bestätigung
|
||||
- 🔲 Freemium Tier-System (free/basic/premium/selfhosted)
|
||||
- 🔲 Login via E-Mail statt Profil-Liste
|
||||
- 🔲 nginx + Let's Encrypt
|
||||
- 🔲 14-Tage Trial automatisch
|
||||
- 🔲 Einladungslinks für Beta-Nutzer
|
||||
- 🔲 Admin kann Tiers manuell setzen
|
||||
|
||||
## Datenbank-Schema (SQLite, v8)
|
||||
### Was in v9d kommt:
|
||||
- 🔲 OAuth2-Grundgerüst für Fitness-Connectoren
|
||||
- 🔲 Strava Connector
|
||||
- 🔲 Withings Connector (Waage)
|
||||
- 🔲 Garmin Connector
|
||||
|
||||
## Deployment
|
||||
|
||||
### Infrastruktur
|
||||
```
|
||||
Internet → privat.stommer.com (Fritz!Box DynDNS)
|
||||
→ Synology NAS (Reverse Proxy + Let's Encrypt)
|
||||
→ Raspberry Pi 5 (192.168.2.49, Docker)
|
||||
```
|
||||
|
||||
### Git Workflow
|
||||
```
|
||||
develop branch → Auto-Deploy → dev.mitai.jinkendo.de (Port 3099/8099)
|
||||
main branch → Auto-Deploy → mitai.jinkendo.de (Port 3002/8002)
|
||||
```
|
||||
|
||||
### Deployment-Befehle (manuell falls nötig)
|
||||
```bash
|
||||
# Prod
|
||||
cd /home/lars/docker/bodytrack
|
||||
docker compose -f docker-compose.yml build --no-cache
|
||||
docker compose -f docker-compose.yml up -d
|
||||
|
||||
# Dev
|
||||
cd /home/lars/docker/bodytrack-dev
|
||||
docker compose -f docker-compose.dev-env.yml build --no-cache
|
||||
docker compose -f docker-compose.dev-env.yml up -d
|
||||
```
|
||||
|
||||
## Datenbank-Schema (PostgreSQL 16, v9b)
|
||||
### Wichtige Tabellen:
|
||||
- `profiles` – Nutzer mit Auth (role, pin_hash, auth_type, ai_enabled, export_enabled)
|
||||
- `profiles` – Nutzer (role, pin_hash/bcrypt, email, auth_type, ai_enabled, tier)
|
||||
- `sessions` – Auth-Tokens mit Ablaufdatum
|
||||
- `weight_log` – Gewichtseinträge (profile_id, date, weight)
|
||||
- `circumference_log` – 8 Umfangspunkte
|
||||
- `caliper_log` – Hautfaltenmessung, 4 Methoden
|
||||
- `nutrition_log` – Kalorien + Makros (aus FDDB-CSV)
|
||||
- `activity_log` – Training (aus Apple Health oder manuell)
|
||||
- `photos` – Progress Photos
|
||||
- `ai_insights` – KI-Auswertungen (scope = prompt-slug)
|
||||
- `ai_prompts` – Konfigurierbare Prompts mit Templates
|
||||
- `ai_prompts` – Konfigurierbare Prompts mit Templates (11 Prompts)
|
||||
- `ai_usage` – KI-Calls pro Tag pro Profil
|
||||
|
||||
## Auth-Flow (aktuell v8)
|
||||
**Schema-Datei:** `backend/schema.sql` (vollständiges PostgreSQL-Schema)
|
||||
**Migration-Script:** `backend/migrate_to_postgres.py` (SQLite→PostgreSQL, automatisch)
|
||||
|
||||
## Auth-Flow (v9b)
|
||||
```
|
||||
Login-Screen → Profil-Liste → PIN/Passwort → Token im localStorage
|
||||
Login-Screen → E-Mail + Passwort → Token im localStorage
|
||||
Token → X-Auth-Token Header → Backend require_auth()
|
||||
Profile-Id → aus Session (nicht aus Header!)
|
||||
SHA256 Passwörter → automatisch zu bcrypt migriert beim Login
|
||||
```
|
||||
|
||||
## API-Konventionen
|
||||
- Alle Endpoints: `/api/...`
|
||||
- Auth-Header: `X-Auth-Token: <token>`
|
||||
- Profile-Header: `X-Profile-Id: <uuid>` (nur wo noch nicht migriert)
|
||||
- Responses: immer JSON
|
||||
- Fehler: `{"detail": "Fehlermeldung"}`
|
||||
- Rate Limit überschritten: HTTP 429
|
||||
|
||||
## Umgebungsvariablen (.env)
|
||||
```
|
||||
OPENROUTER_API_KEY= # KI-Calls
|
||||
# Database (PostgreSQL)
|
||||
DB_HOST=postgres
|
||||
DB_PORT=5432
|
||||
DB_NAME=mitai_prod
|
||||
DB_USER=mitai_prod
|
||||
DB_PASSWORD= # REQUIRED
|
||||
|
||||
# AI
|
||||
OPENROUTER_API_KEY= # KI-Calls (optional, alternativ ANTHROPIC_API_KEY)
|
||||
OPENROUTER_MODEL=anthropic/claude-sonnet-4
|
||||
ANTHROPIC_API_KEY= # Alternative zu OpenRouter
|
||||
SMTP_HOST= # E-Mail
|
||||
ANTHROPIC_API_KEY= # Direkte Anthropic API (optional)
|
||||
|
||||
# Email
|
||||
SMTP_HOST= # E-Mail (für Recovery)
|
||||
SMTP_PORT=587
|
||||
SMTP_USER=
|
||||
SMTP_PASS=
|
||||
SMTP_FROM=
|
||||
APP_URL= # Für Links in E-Mails
|
||||
DATA_DIR=/app/data # SQLite-Pfad (v8)
|
||||
PHOTOS_DIR=/app/photos
|
||||
# v9 (PostgreSQL):
|
||||
DATABASE_URL=postgresql://jinkendo:password@db/jinkendo
|
||||
DB_PASSWORD=
|
||||
```
|
||||
|
||||
## Deployment (aktuell)
|
||||
```bash
|
||||
# Heimserver (Raspberry Pi 5, lars@raspberrypi5)
|
||||
cd /home/lars/docker/bodytrack
|
||||
docker compose build --no-cache [frontend|backend]
|
||||
docker compose up -d
|
||||
docker logs mitai-api --tail 30
|
||||
# App
|
||||
APP_URL=https://mitai.jinkendo.de
|
||||
ALLOWED_ORIGINS=https://mitai.jinkendo.de
|
||||
DATA_DIR=/app/data
|
||||
PHOTOS_DIR=/app/photos
|
||||
ENVIRONMENT=production
|
||||
```
|
||||
|
||||
## Wichtige Hinweise für Claude Code
|
||||
1. **Ports immer 3002/8002** – nie ändern
|
||||
1. **Ports immer 3002/8002 (Prod) oder 3099/8099 (Dev)** – nie ändern
|
||||
2. **npm install** (nicht npm ci) – kein package-lock.json vorhanden
|
||||
3. **SQLite safe_alters** – neue Spalten immer via _safe_alters() hinzufügen
|
||||
3. **PostgreSQL-Migrations** – Schema-Änderungen in `backend/schema.sql`, dann Container neu bauen
|
||||
4. **Pipeline-Prompts** haben slug-Prefix `pipeline_` – nie als Einzelanalyse zeigen
|
||||
5. **dayjs.week()** braucht Plugin – stattdessen native JS Wochenberechnung
|
||||
6. **useNavigate()** nur in React-Komponenten (Großbuchstabe), nicht in Helper-Functions
|
||||
7. **Bar fill=function** in Recharts nicht unterstützt – nur statische Farben
|
||||
5. **dayjs.week()** braucht Plugin – stattdessen native JS ISO-Wochenberechnung
|
||||
6. **useNavigate()** nur in React-Komponenten, nicht in Helper-Functions
|
||||
7. **api.js nutzen** für alle API-Calls – injiziert Token automatisch
|
||||
8. **bcrypt** für alle neuen Passwort-Operationen verwenden
|
||||
9. **session=Depends(require_auth)** als separater Parameter – nie in Header() einbetten
|
||||
10. **RealDictCursor verwenden** – `get_cursor(conn)` statt `conn.cursor()` für dict-like row access
|
||||
|
||||
## Code-Style
|
||||
- React: Functional Components, Hooks
|
||||
@@ -152,3 +216,453 @@ docker logs mitai-api --tail 30
|
||||
- API-Calls: immer über `api.js` (injiziert Token automatisch)
|
||||
- Kein TypeScript (bewusst, für Einfachheit)
|
||||
- Python: keine Type-Hints Pflicht, aber bei neuen Funktionen erwünscht
|
||||
|
||||
## Design-System
|
||||
|
||||
### Farben (CSS-Variablen)
|
||||
```css
|
||||
--accent: #1D9E75 /* Jinkendo Grün – Buttons, Links, Akzente */
|
||||
--accent-dark: #085041 /* Dunkelgrün – Icon-Hintergrund, Header */
|
||||
--accent-light: #E1F5EE /* Hellgrün – Hintergründe, Badges */
|
||||
--bg: /* Seitenhintergrund (hell/dunkel auto) */
|
||||
--surface: /* Card-Hintergrund */
|
||||
--surface2: /* Sekundäre Fläche */
|
||||
--border: /* Rahmen */
|
||||
--text1: /* Primärer Text */
|
||||
--text2: /* Sekundärer Text */
|
||||
--text3: /* Muted Text, Labels */
|
||||
--danger: #D85A30 /* Fehler, Warnungen */
|
||||
```
|
||||
|
||||
### CSS-Klassen
|
||||
```css
|
||||
.card /* Weißer Container, border-radius 12px, box-shadow */
|
||||
.btn /* Basis-Button */
|
||||
.btn-primary /* Grüner Button (#1D9E75) */
|
||||
.btn-secondary /* Grauer Button */
|
||||
.btn-full /* 100% Breite */
|
||||
.form-input /* Eingabefeld, volle Breite */
|
||||
.form-label /* Feldbezeichnung, klein, uppercase */
|
||||
.form-row /* Label + Input + Unit nebeneinander */
|
||||
.form-unit /* Einheit rechts (kg, cm, etc.) */
|
||||
.section-gap /* margin-bottom zwischen Sektionen */
|
||||
.spinner /* Ladekreis, animiert */
|
||||
```
|
||||
|
||||
### Abstände & Größen
|
||||
```
|
||||
Seiten-Padding: 16px seitlich
|
||||
Card-Padding: 16-20px
|
||||
Border-Radius: 12px (Cards), 8px (Buttons/Inputs), 50% (Avatare)
|
||||
Icon-Größe: 16-20px inline, 24px standalone
|
||||
Font-Größe: 12px (Labels), 14px (Body), 16-18px (Subtitel), 20-24px (Titel)
|
||||
Font-Weight: 400 (normal), 600 (semi-bold), 700 (bold)
|
||||
Bottom-Padding: 80px (für Mobile-Navigation)
|
||||
```
|
||||
|
||||
### Komponenten-Muster
|
||||
|
||||
**Titelzeile einer Seite:**
|
||||
```jsx
|
||||
<div style={{display:'flex',alignItems:'center',
|
||||
justifyContent:'space-between',marginBottom:20}}>
|
||||
<div style={{fontSize:20,fontWeight:700,color:'var(--text1)'}}>
|
||||
Seitentitel
|
||||
</div>
|
||||
<button className="btn btn-primary">Aktion</button>
|
||||
</div>
|
||||
```
|
||||
|
||||
**Ladezustand:**
|
||||
```jsx
|
||||
if (loading) return (
|
||||
<div style={{display:'flex',justifyContent:'center',padding:40}}>
|
||||
<div className="spinner"/>
|
||||
</div>
|
||||
)
|
||||
```
|
||||
|
||||
**Fehlerzustand:**
|
||||
```jsx
|
||||
if (error) return (
|
||||
<div style={{color:'var(--danger)',padding:16,textAlign:'center'}}>
|
||||
{error}
|
||||
</div>
|
||||
)
|
||||
```
|
||||
|
||||
**Leerer Zustand:**
|
||||
```jsx
|
||||
{items.length === 0 && (
|
||||
<div style={{textAlign:'center',padding:40,color:'var(--text3)'}}>
|
||||
<div style={{fontSize:32,marginBottom:8}}>📭</div>
|
||||
<div>Noch keine Einträge</div>
|
||||
</div>
|
||||
)}
|
||||
```
|
||||
|
||||
**Metric Card:**
|
||||
```jsx
|
||||
<div className="card" style={{padding:16,textAlign:'center'}}>
|
||||
<div style={{fontSize:12,color:'var(--text3)',marginBottom:4}}>LABEL</div>
|
||||
<div style={{fontSize:24,fontWeight:700,color:'var(--accent)'}}>
|
||||
{value}
|
||||
</div>
|
||||
<div style={{fontSize:12,color:'var(--text3)'}}>Einheit</div>
|
||||
</div>
|
||||
```
|
||||
|
||||
### Jinkendo Logo-System
|
||||
```
|
||||
Grundelement: Ensō-Kreis (offen, Lücke 4-5 Uhr)
|
||||
Farbe Ensō: #1D9E75
|
||||
Hintergrund: #085041 (dunkelgrün)
|
||||
Kern-Symbol: #5DCAA5 (mintgrün)
|
||||
Wortmarke: Jin(light) + ken(bold #1D9E75) + do(light)
|
||||
```
|
||||
|
||||
### Verfügbare Custom Commands
|
||||
```
|
||||
/deploy → Commit + Push vorbereiten
|
||||
/merge-to-prod → develop → main mergen
|
||||
/test → Manuelle Tests durchführen
|
||||
/new-feature → Neues Feature-Template
|
||||
/ui-component → Neue Komponente erstellen
|
||||
/ui-page → Neue Seite erstellen
|
||||
/fix-bug → Bug analysieren und beheben
|
||||
/add-endpoint → Neuen API-Endpoint hinzufügen
|
||||
/db-add-column → Neue DB-Spalte hinzufügen
|
||||
```
|
||||
|
||||
## Jinkendo App-Familie & Markenarchitektur
|
||||
|
||||
### Philosophie
|
||||
**Jinkendo** (人拳道) = Jin (人 Mensch) + Ken (拳 Faust) + Do (道 Weg)
|
||||
"Der menschliche Weg der Kampfkunst" – ruhig aber kraftvoll, Selbstwahrnehmung, Meditation, Zielorientiert
|
||||
|
||||
### App-Familie (Subdomain-Architektur)
|
||||
```
|
||||
mitai.jinkendo.de → Körper-Tracker (身体 = eigener Körper) ← DIESE APP
|
||||
miken.jinkendo.de → Meditation (眉間 = drittes Auge)
|
||||
ikigai.jinkendo.de → Lebenssinn/Ziele (生き甲斐)
|
||||
shinkan.jinkendo.de → Kampfsport (真観 = wahre Wahrnehmung)
|
||||
kenkou.jinkendo.de → Gesundheit allgemein (健康) – für später aufsparen
|
||||
```
|
||||
|
||||
### Registrierte Domains
|
||||
- jinkendo.de, jinkendo.com, jinkendo.life – alle registriert bei Strato
|
||||
|
||||
## v9b Detailplan – Freemium Tier-System
|
||||
|
||||
### Tier-Modell
|
||||
```
|
||||
free → Selbst-Registrierung, 14-Tage Trial, eingeschränkt
|
||||
basic → Kernfunktionen (Abo Stufe 1)
|
||||
premium → Alles inkl. KI und Connectoren (Abo Stufe 2)
|
||||
selfhosted → Lars' Heimversion, keine Einschränkungen
|
||||
```
|
||||
|
||||
### Geplante DB-Erweiterungen (profiles Tabelle)
|
||||
```sql
|
||||
tier TEXT DEFAULT 'free'
|
||||
trial_ends_at TEXT -- ISO datetime
|
||||
sub_valid_until TEXT -- ISO datetime
|
||||
email_verified INTEGER DEFAULT 0
|
||||
email_verify_token TEXT
|
||||
invited_by TEXT -- profile_id FK
|
||||
invitation_token TEXT
|
||||
```
|
||||
|
||||
### Tier-Limits (geplant)
|
||||
| Feature | free | basic | premium | selfhosted |
|
||||
|---------|------|-------|---------|------------|
|
||||
| Gewicht-Einträge | 30 | unbegrenzt | unbegrenzt | unbegrenzt |
|
||||
| KI-Analysen/Monat | 0 | 3 | unbegrenzt | unbegrenzt |
|
||||
| Ernährung Import | ❌ | ✅ | ✅ | ✅ |
|
||||
| Export | ❌ | ✅ | ✅ | ✅ |
|
||||
| Fitness-Connectoren | ❌ | ❌ | ✅ | ✅ |
|
||||
|
||||
### Registrierungs-Flow (geplant)
|
||||
```
|
||||
1. Selbst-Registrierung: Name + E-Mail + Passwort
|
||||
2. Auto-Trial: tier='free', trial_ends_at=now+14d
|
||||
3. E-Mail-Bestätigung → email_verified=1
|
||||
4. Trial läuft ab → Upgrade-Prompt
|
||||
5. Einladungslinks: Admin generiert Token → direkt basic-Tier
|
||||
6. Stripe Integration: später (v9b ohne Stripe, nur Tier-Logik)
|
||||
```
|
||||
|
||||
## Infrastruktur Details
|
||||
|
||||
### Heimnetzwerk
|
||||
```
|
||||
Internet
|
||||
→ Fritz!Box 7530 AX (DynDNS: privat.stommer.com)
|
||||
→ Synology NAS (192.168.2.63, Reverse Proxy + Let's Encrypt)
|
||||
→ Raspberry Pi 5 (192.168.2.49, Docker)
|
||||
→ MiniPC (192.168.2.144, Gitea auf Port 3000)
|
||||
```
|
||||
|
||||
### Synology Reverse Proxy Regeln
|
||||
```
|
||||
mitai.jinkendo.de → HTTP 192.168.2.49:3002 (Prod Frontend)
|
||||
dev.mitai.jinkendo.de → HTTP 192.168.2.49:3099 (Dev Frontend)
|
||||
```
|
||||
|
||||
### AdGuard DNS Rewrites (für internes Routing)
|
||||
```
|
||||
mitai.jinkendo.de → 192.168.2.63
|
||||
dev.mitai.jinkendo.de → 192.168.2.63
|
||||
```
|
||||
|
||||
### Fritz!Box DNS-Rebind Ausnahmen
|
||||
```
|
||||
jinkendo.de
|
||||
mitai.jinkendo.de
|
||||
```
|
||||
|
||||
### Pi Verzeichnisstruktur
|
||||
```
|
||||
/home/lars/docker/
|
||||
├── bodytrack/ → Prod (main branch, docker-compose.yml)
|
||||
└── bodytrack-dev/ → Dev (develop branch, docker-compose.dev-env.yml)
|
||||
```
|
||||
|
||||
### Gitea Runner
|
||||
```
|
||||
Runner: raspberry-pi (auf Pi installiert)
|
||||
Service: /etc/systemd/system/gitea-runner.service
|
||||
Binary: /home/lars/gitea-runner/act_runner
|
||||
```
|
||||
|
||||
### Container Namen
|
||||
```
|
||||
Prod: mitai-api, mitai-ui
|
||||
Dev: dev-mitai-api, dev-mitai-ui
|
||||
```
|
||||
|
||||
## Bekannte Probleme & Lösungen
|
||||
|
||||
### dayjs.week() – NIEMALS verwenden
|
||||
```javascript
|
||||
// ❌ Falsch:
|
||||
const week = dayjs(date).week()
|
||||
|
||||
// ✅ Richtig (ISO 8601):
|
||||
const weekNum = (() => {
|
||||
const dt = new Date(date)
|
||||
dt.setHours(0,0,0,0)
|
||||
dt.setDate(dt.getDate()+4-(dt.getDay()||7))
|
||||
const y = new Date(dt.getFullYear(),0,1)
|
||||
return Math.ceil(((dt-y)/86400000+1)/7)
|
||||
})()
|
||||
```
|
||||
|
||||
### session=Depends(require_auth) – Korrekte Platzierung
|
||||
```python
|
||||
# ❌ Falsch (führt zu NameError oder ungeschütztem Endpoint):
|
||||
def endpoint(x_profile_id: Optional[str] = Header(default=None, session=Depends(require_auth))):
|
||||
|
||||
# ✅ Richtig (separater Parameter):
|
||||
def endpoint(x_profile_id: Optional[str] = Header(default=None),
|
||||
session: dict = Depends(require_auth)):
|
||||
```
|
||||
|
||||
### Recharts Bar fill=function – nicht unterstützt
|
||||
```jsx
|
||||
// ❌ Falsch:
|
||||
<Bar fill={(entry) => entry.color}/>
|
||||
|
||||
// ✅ Richtig:
|
||||
<Bar fill="#1D9E75"/>
|
||||
```
|
||||
|
||||
### PostgreSQL Boolean-Syntax
|
||||
```python
|
||||
# ❌ Falsch (SQLite-Syntax):
|
||||
cur.execute("SELECT * FROM ai_prompts WHERE active=1")
|
||||
|
||||
# ✅ Richtig (PostgreSQL):
|
||||
cur.execute("SELECT * FROM ai_prompts WHERE active=true")
|
||||
```
|
||||
|
||||
### RealDictCursor für dict-like row access
|
||||
```python
|
||||
# ❌ Falsch:
|
||||
cur = conn.cursor()
|
||||
cur.execute("SELECT COUNT(*) FROM weight_log")
|
||||
count = cur.fetchone()[0] # Tuple index
|
||||
|
||||
# ✅ Richtig:
|
||||
cur = get_cursor(conn) # Returns RealDictCursor
|
||||
cur.execute("SELECT COUNT(*) as count FROM weight_log")
|
||||
count = cur.fetchone()['count'] # Dict key
|
||||
```
|
||||
|
||||
## v9b Migration – Lessons Learned
|
||||
|
||||
### PostgreSQL Migration (SQLite → PostgreSQL)
|
||||
**Problem:** Docker Build hing 30+ Minuten bei `apt-get install postgresql-client`
|
||||
**Lösung:** Alle apt-get dependencies entfernt, reine Python-Lösung mit psycopg2-binary
|
||||
|
||||
**Problem:** Leere date-Strings (`''`) führten zu PostgreSQL-Fehlern
|
||||
**Lösung:** Migration-Script konvertiert leere Strings zu NULL für DATE-Spalten
|
||||
|
||||
**Problem:** Boolean-Felder (SQLite INTEGER 0/1 vs PostgreSQL BOOLEAN)
|
||||
**Lösung:** Migration konvertiert automatisch, Backend nutzt `active=true` statt `active=1`
|
||||
|
||||
### API Endpoint Consistency (März 2026)
|
||||
**Problem:** 11 kritische Endpoint-Mismatches zwischen Frontend und Backend gefunden
|
||||
**Gelöst:**
|
||||
- AI-Endpoints konsistent: `/api/insights/run/{slug}`, `/api/insights/pipeline`
|
||||
- Password-Reset: `/api/auth/forgot-password`, `/api/auth/reset-password`
|
||||
- Admin-Endpoints: `/permissions`, `/email`, `/pin` Sub-Routes
|
||||
- Export: JSON + ZIP Endpoints hinzugefügt
|
||||
- Prompt-Bearbeitung: PUT-Endpoint für Admins
|
||||
|
||||
**Tool:** Vollständiger Audit via Explore-Agent empfohlen bei größeren Änderungen
|
||||
|
||||
## Export/Import Spezifikation (v9c)
|
||||
|
||||
### ZIP-Export Struktur
|
||||
```
|
||||
mitai-export-{name}-{YYYY-MM-DD}.zip
|
||||
├── README.txt ← Erklärung des Formats + Versionsnummer
|
||||
├── profile.json ← Profildaten (ohne Passwort-Hash)
|
||||
├── data/
|
||||
│ ├── weight.csv ← Gewichtsverlauf
|
||||
│ ├── circumferences.csv ← Umfänge (8 Messpunkte)
|
||||
│ ├── caliper.csv ← Caliper-Messungen
|
||||
│ ├── nutrition.csv ← Ernährungsdaten
|
||||
│ └── activity.csv ← Aktivitäten
|
||||
├── insights/
|
||||
│ └── ai_insights.json ← KI-Auswertungen (alle gespeicherten)
|
||||
└── photos/
|
||||
├── {date}_{id}.jpg ← Progress-Fotos
|
||||
└── ...
|
||||
```
|
||||
|
||||
### CSV Format (alle Dateien)
|
||||
```
|
||||
- Trennzeichen: Semikolon (;) – Excel/LibreOffice kompatibel
|
||||
- Encoding: UTF-8 mit BOM (für Windows Excel)
|
||||
- Datumsformat: YYYY-MM-DD
|
||||
- Dezimaltrennzeichen: Punkt (.)
|
||||
- Erste Zeile: Header
|
||||
- Nullwerte: leer (nicht "null" oder "NULL")
|
||||
```
|
||||
|
||||
### weight.csv Spalten
|
||||
```
|
||||
id;date;weight;note;source;created
|
||||
```
|
||||
|
||||
### circumferences.csv Spalten
|
||||
```
|
||||
id;date;waist;hip;chest;neck;upper_arm;thigh;calf;forearm;note;created
|
||||
```
|
||||
|
||||
### caliper.csv Spalten
|
||||
```
|
||||
id;date;chest;abdomen;thigh;tricep;subscapular;suprailiac;midaxillary;method;bf_percent;note;created
|
||||
```
|
||||
|
||||
### nutrition.csv Spalten
|
||||
```
|
||||
id;date;meal_name;kcal;protein;fat;carbs;fiber;note;source;created
|
||||
```
|
||||
|
||||
### activity.csv Spalten
|
||||
```
|
||||
id;date;name;type;duration_min;kcal;heart_rate_avg;heart_rate_max;distance_km;note;source;created
|
||||
```
|
||||
|
||||
### profile.json Struktur
|
||||
```json
|
||||
{
|
||||
"export_version": "2",
|
||||
"export_date": "2026-03-18",
|
||||
"app": "Mitai Jinkendo",
|
||||
"profile": {
|
||||
"name": "Lars",
|
||||
"email": "lars@stommer.com",
|
||||
"sex": "m",
|
||||
"height": 178,
|
||||
"birth_year": 1980,
|
||||
"goal_weight": 82,
|
||||
"goal_bf_pct": 14,
|
||||
"avatar_color": "#1D9E75",
|
||||
"auth_type": "password",
|
||||
"session_days": 30,
|
||||
"ai_enabled": true,
|
||||
"tier": "selfhosted"
|
||||
},
|
||||
"stats": {
|
||||
"weight_entries": 150,
|
||||
"nutrition_entries": 300,
|
||||
"activity_entries": 45,
|
||||
"photos": 12
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### ai_insights.json Struktur
|
||||
```json
|
||||
[
|
||||
{
|
||||
"id": "uuid",
|
||||
"scope": "gesamt",
|
||||
"created": "2026-03-18T10:00:00",
|
||||
"result": "KI-Analyse Text..."
|
||||
}
|
||||
]
|
||||
```
|
||||
|
||||
### README.txt Inhalt
|
||||
```
|
||||
Mitai Jinkendo – Datenexport
|
||||
Version: 2
|
||||
Exportiert am: YYYY-MM-DD
|
||||
Profil: {name}
|
||||
|
||||
Inhalt:
|
||||
- profile.json: Profildaten und Einstellungen
|
||||
- data/*.csv: Messdaten (Semikolon-getrennt, UTF-8)
|
||||
- insights/: KI-Auswertungen (JSON)
|
||||
- photos/: Progress-Fotos (JPEG)
|
||||
|
||||
Import:
|
||||
Dieser Export kann in Mitai Jinkendo unter
|
||||
Einstellungen → Import → "Mitai Backup importieren"
|
||||
wieder eingespielt werden.
|
||||
|
||||
Format-Version 2 (ab v9b):
|
||||
Alle CSV-Dateien sind UTF-8 mit BOM kodiert.
|
||||
Trennzeichen: Semikolon (;)
|
||||
Datumsformat: YYYY-MM-DD
|
||||
```
|
||||
|
||||
### Import-Funktion (zu implementieren)
|
||||
**Endpoint:** `POST /api/import/zip`
|
||||
**Verhalten:**
|
||||
- Akzeptiert ZIP-Datei (multipart/form-data)
|
||||
- Erkennt export_version aus profile.json
|
||||
- Importiert nur fehlende Einträge (kein Duplikat)
|
||||
- Fotos werden nicht überschrieben falls bereits vorhanden
|
||||
- Gibt Zusammenfassung zurück: wie viele Einträge je Kategorie importiert
|
||||
- Bei Fehler: vollständiger Rollback (alle oder nichts)
|
||||
|
||||
**Duplikat-Erkennung:**
|
||||
```python
|
||||
# INSERT ... ON CONFLICT (profile_id, date) DO NOTHING
|
||||
# weight: UNIQUE (profile_id, date)
|
||||
# nutrition: UNIQUE (profile_id, date, meal_name)
|
||||
# activity: UNIQUE (profile_id, date, name)
|
||||
# caliper: UNIQUE (profile_id, date)
|
||||
# circumferences: UNIQUE (profile_id, date)
|
||||
```
|
||||
|
||||
**Frontend:** Neuer Button in SettingsPage:
|
||||
```
|
||||
[ZIP exportieren] [JSON exportieren] [Backup importieren]
|
||||
```
|
||||
+15
-1
@@ -1,7 +1,21 @@
|
||||
FROM python:3.12-slim
|
||||
|
||||
# No system packages needed - we use Python (psycopg2-binary) for PostgreSQL checks
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
# Install Python dependencies
|
||||
COPY requirements.txt .
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
|
||||
# Copy application code
|
||||
COPY . .
|
||||
|
||||
# Create directories
|
||||
RUN mkdir -p /app/data /app/photos
|
||||
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
|
||||
|
||||
# Make startup script executable
|
||||
RUN chmod +x /app/startup.sh
|
||||
|
||||
# Use startup script instead of direct uvicorn
|
||||
CMD ["/app/startup.sh"]
|
||||
+116
@@ -0,0 +1,116 @@
|
||||
"""
|
||||
Authentication and Authorization for Mitai Jinkendo
|
||||
|
||||
Provides password hashing, session management, and auth dependencies
|
||||
for FastAPI endpoints.
|
||||
"""
|
||||
import hashlib
|
||||
import secrets
|
||||
from typing import Optional
|
||||
from fastapi import Header, Query, HTTPException
|
||||
import bcrypt
|
||||
|
||||
from db import get_db, get_cursor
|
||||
|
||||
|
||||
def hash_pin(pin: str) -> str:
|
||||
"""Hash password with bcrypt. Falls back gracefully from legacy SHA256."""
|
||||
return bcrypt.hashpw(pin.encode(), bcrypt.gensalt()).decode()
|
||||
|
||||
|
||||
def verify_pin(pin: str, stored_hash: str) -> bool:
|
||||
"""Verify password - supports both bcrypt and legacy SHA256."""
|
||||
if not stored_hash:
|
||||
return False
|
||||
# Detect bcrypt hash (starts with $2b$ or $2a$)
|
||||
if stored_hash.startswith('$2'):
|
||||
try:
|
||||
return bcrypt.checkpw(pin.encode(), stored_hash.encode())
|
||||
except Exception:
|
||||
return False
|
||||
# Legacy SHA256 support (auto-upgrade to bcrypt on next login)
|
||||
return stored_hash == hashlib.sha256(pin.encode()).hexdigest()
|
||||
|
||||
|
||||
def make_token() -> str:
|
||||
"""Generate a secure random token for sessions."""
|
||||
return secrets.token_urlsafe(32)
|
||||
|
||||
|
||||
def get_session(token: str):
|
||||
"""
|
||||
Get session data for a given token.
|
||||
|
||||
Returns session dict with profile info, or None if invalid/expired.
|
||||
"""
|
||||
if not token:
|
||||
return None
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute(
|
||||
"SELECT s.*, p.role, p.name, p.ai_enabled, p.ai_limit_day, p.export_enabled "
|
||||
"FROM sessions s JOIN profiles p ON s.profile_id=p.id "
|
||||
"WHERE s.token=%s AND s.expires_at > CURRENT_TIMESTAMP",
|
||||
(token,)
|
||||
)
|
||||
return cur.fetchone()
|
||||
|
||||
|
||||
def require_auth(x_auth_token: Optional[str] = Header(default=None)):
|
||||
"""
|
||||
FastAPI dependency - requires valid authentication.
|
||||
|
||||
Usage:
|
||||
@app.get("/api/endpoint")
|
||||
def endpoint(session: dict = Depends(require_auth)):
|
||||
profile_id = session['profile_id']
|
||||
...
|
||||
|
||||
Raises:
|
||||
HTTPException 401 if not authenticated
|
||||
"""
|
||||
session = get_session(x_auth_token)
|
||||
if not session:
|
||||
raise HTTPException(401, "Nicht eingeloggt")
|
||||
return session
|
||||
|
||||
|
||||
def require_auth_flexible(x_auth_token: Optional[str] = Header(default=None), token: Optional[str] = Query(default=None)):
|
||||
"""
|
||||
FastAPI dependency - auth via header OR query parameter.
|
||||
|
||||
Used for endpoints accessed by <img> tags that can't send headers.
|
||||
|
||||
Usage:
|
||||
@app.get("/api/photos/{id}")
|
||||
def get_photo(id: str, session: dict = Depends(require_auth_flexible)):
|
||||
...
|
||||
|
||||
Raises:
|
||||
HTTPException 401 if not authenticated
|
||||
"""
|
||||
session = get_session(x_auth_token or token)
|
||||
if not session:
|
||||
raise HTTPException(401, "Nicht eingeloggt")
|
||||
return session
|
||||
|
||||
|
||||
def require_admin(x_auth_token: Optional[str] = Header(default=None)):
|
||||
"""
|
||||
FastAPI dependency - requires admin authentication.
|
||||
|
||||
Usage:
|
||||
@app.put("/api/admin/endpoint")
|
||||
def admin_endpoint(session: dict = Depends(require_admin)):
|
||||
...
|
||||
|
||||
Raises:
|
||||
HTTPException 401 if not authenticated
|
||||
HTTPException 403 if not admin
|
||||
"""
|
||||
session = get_session(x_auth_token)
|
||||
if not session:
|
||||
raise HTTPException(401, "Nicht eingeloggt")
|
||||
if session['role'] != 'admin':
|
||||
raise HTTPException(403, "Nur für Admins")
|
||||
return session
|
||||
+195
@@ -0,0 +1,195 @@
|
||||
"""
|
||||
PostgreSQL Database Connector for Mitai Jinkendo (v9b)
|
||||
|
||||
Provides connection pooling and helper functions for database operations.
|
||||
Compatible drop-in replacement for the previous SQLite get_db() pattern.
|
||||
"""
|
||||
import os
|
||||
from contextlib import contextmanager
|
||||
from typing import Optional, Dict, Any, List
|
||||
import psycopg2
|
||||
from psycopg2.extras import RealDictCursor
|
||||
import psycopg2.pool
|
||||
|
||||
|
||||
# Global connection pool
|
||||
_pool: Optional[psycopg2.pool.SimpleConnectionPool] = None
|
||||
|
||||
|
||||
def init_pool():
|
||||
"""Initialize PostgreSQL connection pool."""
|
||||
global _pool
|
||||
if _pool is None:
|
||||
_pool = psycopg2.pool.SimpleConnectionPool(
|
||||
minconn=1,
|
||||
maxconn=10,
|
||||
host=os.getenv("DB_HOST", "postgres"),
|
||||
port=int(os.getenv("DB_PORT", "5432")),
|
||||
database=os.getenv("DB_NAME", "mitai"),
|
||||
user=os.getenv("DB_USER", "mitai"),
|
||||
password=os.getenv("DB_PASSWORD", "")
|
||||
)
|
||||
print(f"✓ PostgreSQL connection pool initialized ({os.getenv('DB_HOST', 'postgres')}:{os.getenv('DB_PORT', '5432')})")
|
||||
|
||||
|
||||
@contextmanager
|
||||
def get_db():
|
||||
"""
|
||||
Context manager for database connections.
|
||||
|
||||
Usage:
|
||||
with get_db() as conn:
|
||||
cur = conn.cursor()
|
||||
cur.execute("SELECT * FROM profiles")
|
||||
rows = cur.fetchall()
|
||||
|
||||
Auto-commits on success, auto-rolls back on exception.
|
||||
"""
|
||||
if _pool is None:
|
||||
init_pool()
|
||||
|
||||
conn = _pool.getconn()
|
||||
try:
|
||||
yield conn
|
||||
conn.commit()
|
||||
except Exception:
|
||||
conn.rollback()
|
||||
raise
|
||||
finally:
|
||||
_pool.putconn(conn)
|
||||
|
||||
|
||||
def get_cursor(conn):
|
||||
"""
|
||||
Get cursor with RealDictCursor for dict-like row access.
|
||||
|
||||
Returns rows as dictionaries: {'column_name': value, ...}
|
||||
Compatible with previous sqlite3.Row behavior.
|
||||
"""
|
||||
return conn.cursor(cursor_factory=RealDictCursor)
|
||||
|
||||
|
||||
def r2d(row) -> Optional[Dict[str, Any]]:
|
||||
"""
|
||||
Convert row to dict (compatibility helper).
|
||||
|
||||
Args:
|
||||
row: RealDictRow from psycopg2
|
||||
|
||||
Returns:
|
||||
Dictionary or None if row is None
|
||||
"""
|
||||
return dict(row) if row else None
|
||||
|
||||
|
||||
def execute_one(conn, query: str, params: tuple = ()) -> Optional[Dict[str, Any]]:
|
||||
"""
|
||||
Execute query and return one row as dict.
|
||||
|
||||
Args:
|
||||
conn: Database connection from get_db()
|
||||
query: SQL query with %s placeholders
|
||||
params: Tuple of parameters
|
||||
|
||||
Returns:
|
||||
Dictionary with column:value pairs, or None if no row found
|
||||
|
||||
Example:
|
||||
profile = execute_one(conn, "SELECT * FROM profiles WHERE id=%s", (pid,))
|
||||
if profile:
|
||||
print(profile['name'])
|
||||
"""
|
||||
with get_cursor(conn) as cur:
|
||||
cur.execute(query, params)
|
||||
row = cur.fetchone()
|
||||
return r2d(row)
|
||||
|
||||
|
||||
def execute_all(conn, query: str, params: tuple = ()) -> List[Dict[str, Any]]:
|
||||
"""
|
||||
Execute query and return all rows as list of dicts.
|
||||
|
||||
Args:
|
||||
conn: Database connection from get_db()
|
||||
query: SQL query with %s placeholders
|
||||
params: Tuple of parameters
|
||||
|
||||
Returns:
|
||||
List of dictionaries (one per row)
|
||||
|
||||
Example:
|
||||
weights = execute_all(conn,
|
||||
"SELECT * FROM weight_log WHERE profile_id=%s ORDER BY date DESC",
|
||||
(pid,)
|
||||
)
|
||||
for w in weights:
|
||||
print(w['date'], w['weight'])
|
||||
"""
|
||||
with get_cursor(conn) as cur:
|
||||
cur.execute(query, params)
|
||||
rows = cur.fetchall()
|
||||
return [r2d(r) for r in rows]
|
||||
|
||||
|
||||
def execute_write(conn, query: str, params: tuple = ()) -> None:
|
||||
"""
|
||||
Execute INSERT/UPDATE/DELETE query.
|
||||
|
||||
Args:
|
||||
conn: Database connection from get_db()
|
||||
query: SQL query with %s placeholders
|
||||
params: Tuple of parameters
|
||||
|
||||
Example:
|
||||
execute_write(conn,
|
||||
"UPDATE profiles SET name=%s WHERE id=%s",
|
||||
("New Name", pid)
|
||||
)
|
||||
"""
|
||||
with get_cursor(conn) as cur:
|
||||
cur.execute(query, params)
|
||||
|
||||
|
||||
def init_db():
|
||||
"""
|
||||
Initialize database with required data.
|
||||
|
||||
Ensures critical data exists (e.g., pipeline master prompt).
|
||||
Safe to call multiple times - checks before inserting.
|
||||
Called automatically on app startup.
|
||||
"""
|
||||
try:
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
|
||||
# Check if table exists first
|
||||
cur.execute("""
|
||||
SELECT EXISTS (
|
||||
SELECT FROM information_schema.tables
|
||||
WHERE table_schema = 'public'
|
||||
AND table_name = 'ai_prompts'
|
||||
) as table_exists
|
||||
""")
|
||||
if not cur.fetchone()['table_exists']:
|
||||
print("⚠️ ai_prompts table doesn't exist yet - skipping pipeline prompt creation")
|
||||
return
|
||||
|
||||
# Ensure "pipeline" master prompt exists
|
||||
cur.execute("SELECT COUNT(*) as count FROM ai_prompts WHERE slug='pipeline'")
|
||||
if cur.fetchone()['count'] == 0:
|
||||
cur.execute("""
|
||||
INSERT INTO ai_prompts (slug, name, description, template, active, sort_order)
|
||||
VALUES (
|
||||
'pipeline',
|
||||
'Mehrstufige Gesamtanalyse',
|
||||
'Master-Schalter für die gesamte Pipeline. Deaktiviere diese Analyse, um die Pipeline komplett zu verstecken.',
|
||||
'PIPELINE_MASTER',
|
||||
true,
|
||||
-10
|
||||
)
|
||||
""")
|
||||
conn.commit()
|
||||
print("✓ Pipeline master prompt created")
|
||||
except Exception as e:
|
||||
print(f"⚠️ Could not create pipeline prompt: {e}")
|
||||
# Don't fail startup - prompt can be created manually
|
||||
@@ -0,0 +1,135 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Database initialization script for PostgreSQL.
|
||||
Replaces psql commands in startup.sh with pure Python.
|
||||
"""
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
import psycopg2
|
||||
from psycopg2 import OperationalError
|
||||
|
||||
DB_HOST = os.getenv("DB_HOST", "localhost")
|
||||
DB_PORT = os.getenv("DB_PORT", "5432")
|
||||
DB_NAME = os.getenv("DB_NAME", "mitai_dev")
|
||||
DB_USER = os.getenv("DB_USER", "mitai_dev")
|
||||
DB_PASSWORD = os.getenv("DB_PASSWORD", "")
|
||||
|
||||
def get_connection():
|
||||
"""Get PostgreSQL connection."""
|
||||
return psycopg2.connect(
|
||||
host=DB_HOST,
|
||||
port=DB_PORT,
|
||||
database=DB_NAME,
|
||||
user=DB_USER,
|
||||
password=DB_PASSWORD
|
||||
)
|
||||
|
||||
def wait_for_postgres(max_retries=30):
|
||||
"""Wait for PostgreSQL to be ready."""
|
||||
print("\nChecking PostgreSQL connection...")
|
||||
for i in range(1, max_retries + 1):
|
||||
try:
|
||||
conn = get_connection()
|
||||
conn.close()
|
||||
print("✓ PostgreSQL ready")
|
||||
return True
|
||||
except OperationalError:
|
||||
print(f" Waiting for PostgreSQL... (attempt {i}/{max_retries})")
|
||||
time.sleep(2)
|
||||
|
||||
print(f"✗ PostgreSQL not ready after {max_retries} attempts")
|
||||
return False
|
||||
|
||||
def check_table_exists(table_name="profiles"):
|
||||
"""Check if a table exists."""
|
||||
try:
|
||||
conn = get_connection()
|
||||
cur = conn.cursor()
|
||||
cur.execute("""
|
||||
SELECT COUNT(*)
|
||||
FROM information_schema.tables
|
||||
WHERE table_schema='public' AND table_name=%s
|
||||
""", (table_name,))
|
||||
count = cur.fetchone()[0]
|
||||
cur.close()
|
||||
conn.close()
|
||||
return count > 0
|
||||
except Exception as e:
|
||||
print(f"Error checking table: {e}")
|
||||
return False
|
||||
|
||||
def load_schema(schema_file="/app/schema.sql"):
|
||||
"""Load schema from SQL file."""
|
||||
try:
|
||||
with open(schema_file, 'r') as f:
|
||||
schema_sql = f.read()
|
||||
|
||||
conn = get_connection()
|
||||
cur = conn.cursor()
|
||||
cur.execute(schema_sql)
|
||||
conn.commit()
|
||||
cur.close()
|
||||
conn.close()
|
||||
print("✓ Schema loaded from schema.sql")
|
||||
return True
|
||||
except Exception as e:
|
||||
print(f"✗ Error loading schema: {e}")
|
||||
return False
|
||||
|
||||
def get_profile_count():
|
||||
"""Get number of profiles in database."""
|
||||
try:
|
||||
conn = get_connection()
|
||||
cur = conn.cursor()
|
||||
cur.execute("SELECT COUNT(*) FROM profiles")
|
||||
count = cur.fetchone()[0]
|
||||
cur.close()
|
||||
conn.close()
|
||||
return count
|
||||
except Exception as e:
|
||||
print(f"Error getting profile count: {e}")
|
||||
return -1
|
||||
|
||||
if __name__ == "__main__":
|
||||
print("═══════════════════════════════════════════════════════════")
|
||||
print("MITAI JINKENDO - Database Initialization (v9b)")
|
||||
print("═══════════════════════════════════════════════════════════")
|
||||
|
||||
# Wait for PostgreSQL
|
||||
if not wait_for_postgres():
|
||||
sys.exit(1)
|
||||
|
||||
# Check schema
|
||||
print("\nChecking database schema...")
|
||||
if not check_table_exists("profiles"):
|
||||
print(" Schema not found, initializing...")
|
||||
if not load_schema():
|
||||
sys.exit(1)
|
||||
else:
|
||||
print("✓ Schema already exists")
|
||||
|
||||
# Check for migration
|
||||
print("\nChecking for SQLite data migration...")
|
||||
sqlite_db = "/app/data/bodytrack.db"
|
||||
profile_count = get_profile_count()
|
||||
|
||||
if os.path.exists(sqlite_db) and profile_count == 0:
|
||||
print(" SQLite database found and PostgreSQL is empty")
|
||||
print(" Starting automatic migration...")
|
||||
# Import and run migration
|
||||
try:
|
||||
from migrate_to_postgres import main as migrate
|
||||
migrate()
|
||||
except Exception as e:
|
||||
print(f"✗ Migration failed: {e}")
|
||||
sys.exit(1)
|
||||
elif os.path.exists(sqlite_db) and profile_count > 0:
|
||||
print(f"⚠ SQLite DB exists but PostgreSQL already has {profile_count} profiles")
|
||||
print(" Skipping migration (already migrated)")
|
||||
elif not os.path.exists(sqlite_db):
|
||||
print("✓ No SQLite database found (fresh install or already migrated)")
|
||||
else:
|
||||
print("✓ No migration needed")
|
||||
|
||||
print("\n✓ Database initialization complete")
|
||||
+47
-2050
File diff suppressed because it is too large.
Load diff
+1878
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,388 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
SQLite → PostgreSQL Migration Script für Mitai Jinkendo (v9a → v9b)
|
||||
|
||||
Migrates all data from SQLite to PostgreSQL with type conversions and validation.
|
||||
|
||||
Usage:
|
||||
# Inside Docker container:
|
||||
python migrate_to_postgres.py
|
||||
|
||||
# Or locally with custom paths:
|
||||
DATA_DIR=./data DB_HOST=localhost python migrate_to_postgres.py
|
||||
|
||||
Environment Variables:
|
||||
SQLite Source:
|
||||
DATA_DIR (default: ./data)
|
||||
|
||||
PostgreSQL Target:
|
||||
DB_HOST (default: postgres)
|
||||
DB_PORT (default: 5432)
|
||||
DB_NAME (default: mitai)
|
||||
DB_USER (default: mitai)
|
||||
DB_PASSWORD (required)
|
||||
"""
|
||||
import os
|
||||
import sys
|
||||
import sqlite3
|
||||
from pathlib import Path
|
||||
from typing import Dict, Any, List, Optional
|
||||
import psycopg2
|
||||
from psycopg2.extras import execute_values, RealDictCursor
|
||||
|
||||
|
||||
# ================================================================
|
||||
# CONFIGURATION
|
||||
# ================================================================
|
||||
|
||||
# SQLite Source
|
||||
DATA_DIR = Path(os.getenv("DATA_DIR", "./data"))
|
||||
SQLITE_DB = DATA_DIR / "bodytrack.db"
|
||||
|
||||
# PostgreSQL Target
|
||||
PG_CONFIG = {
|
||||
'host': os.getenv("DB_HOST", "postgres"),
|
||||
'port': int(os.getenv("DB_PORT", "5432")),
|
||||
'database': os.getenv("DB_NAME", "mitai"),
|
||||
'user': os.getenv("DB_USER", "mitai"),
|
||||
'password': os.getenv("DB_PASSWORD", "")
|
||||
}
|
||||
|
||||
# Tables to migrate (in order - respects foreign keys)
|
||||
TABLES = [
|
||||
'profiles',
|
||||
'sessions',
|
||||
'ai_usage',
|
||||
'ai_prompts',
|
||||
'weight_log',
|
||||
'circumference_log',
|
||||
'caliper_log',
|
||||
'nutrition_log',
|
||||
'activity_log',
|
||||
'photos',
|
||||
'ai_insights',
|
||||
]
|
||||
|
||||
# Columns that need INTEGER (0/1) → BOOLEAN conversion
|
||||
BOOLEAN_COLUMNS = {
|
||||
'profiles': ['ai_enabled', 'export_enabled'],
|
||||
'ai_prompts': ['active'],
|
||||
}
|
||||
|
||||
# Column whitelist for tables that have schema differences
|
||||
# Only these columns will be migrated (filters out legacy columns)
|
||||
COLUMN_WHITELIST = {
|
||||
'ai_insights': ['id', 'profile_id', 'scope', 'content', 'created'],
|
||||
}
|
||||
|
||||
|
||||
# ================================================================
|
||||
# CONVERSION HELPERS
|
||||
# ================================================================
|
||||
|
||||
def convert_value(value: Any, column: str, table: str) -> Any:
|
||||
"""
|
||||
Convert SQLite value to PostgreSQL-compatible format.
|
||||
|
||||
Args:
|
||||
value: Raw value from SQLite
|
||||
column: Column name
|
||||
table: Table name
|
||||
|
||||
Returns:
|
||||
Converted value suitable for PostgreSQL
|
||||
"""
|
||||
# NULL values pass through
|
||||
if value is None:
|
||||
return None
|
||||
|
||||
# Empty string → NULL for DATE columns (PostgreSQL doesn't accept '' for DATE type)
|
||||
if isinstance(value, str) and value.strip() == '' and column == 'date':
|
||||
return None
|
||||
|
||||
# INTEGER → BOOLEAN conversion
|
||||
if table in BOOLEAN_COLUMNS and column in BOOLEAN_COLUMNS[table]:
|
||||
return bool(value)
|
||||
|
||||
# All other values pass through
|
||||
# (PostgreSQL handles TEXT timestamps, UUIDs, and numerics automatically)
|
||||
return value
|
||||
|
||||
|
||||
def convert_row(row: Dict[str, Any], table: str) -> Dict[str, Any]:
|
||||
"""
|
||||
Convert entire row from SQLite to PostgreSQL format.
|
||||
|
||||
Args:
|
||||
row: Dictionary with column:value pairs from SQLite
|
||||
table: Table name
|
||||
|
||||
Returns:
|
||||
Converted dictionary
|
||||
"""
|
||||
return {
|
||||
column: convert_value(value, column, table)
|
||||
for column, value in row.items()
|
||||
}
|
||||
|
||||
|
||||
# ================================================================
|
||||
# MIGRATION LOGIC
|
||||
# ================================================================
|
||||
|
||||
def get_sqlite_rows(table: str) -> List[Dict[str, Any]]:
|
||||
"""
|
||||
Fetch all rows from SQLite table.
|
||||
|
||||
Args:
|
||||
table: Table name
|
||||
|
||||
Returns:
|
||||
List of dictionaries (one per row)
|
||||
"""
|
||||
conn = sqlite3.connect(SQLITE_DB)
|
||||
conn.row_factory = sqlite3.Row
|
||||
cur = conn.cursor()
|
||||
|
||||
try:
|
||||
rows = cur.execute(f"SELECT * FROM {table}").fetchall()
|
||||
return [dict(row) for row in rows]
|
||||
except sqlite3.OperationalError as e:
|
||||
# Table doesn't exist in SQLite (OK, might be new in v9b)
|
||||
print(f" ⚠ Table '{table}' not found in SQLite: {e}")
|
||||
return []
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
|
||||
def migrate_table(pg_conn, table: str) -> Dict[str, int]:
|
||||
"""
|
||||
Migrate one table from SQLite to PostgreSQL.
|
||||
|
||||
Args:
|
||||
pg_conn: PostgreSQL connection
|
||||
table: Table name
|
||||
|
||||
Returns:
|
||||
Dictionary with stats: {'sqlite_count': N, 'postgres_count': M}
|
||||
"""
|
||||
print(f" Migrating '{table}'...", end=' ', flush=True)
|
||||
|
||||
# Fetch from SQLite
|
||||
sqlite_rows = get_sqlite_rows(table)
|
||||
sqlite_count = len(sqlite_rows)
|
||||
|
||||
if sqlite_count == 0:
|
||||
print("(empty)")
|
||||
return {'sqlite_count': 0, 'postgres_count': 0}
|
||||
|
||||
# Convert rows
|
||||
converted_rows = [convert_row(row, table) for row in sqlite_rows]
|
||||
|
||||
# Get column names - filter if whitelist exists for this table
|
||||
if table in COLUMN_WHITELIST:
|
||||
allowed_columns = COLUMN_WHITELIST[table]
|
||||
# Filter rows to only include allowed columns
|
||||
converted_rows = [
|
||||
{k: v for k, v in row.items() if k in allowed_columns}
|
||||
for row in converted_rows
|
||||
]
|
||||
columns = allowed_columns
|
||||
else:
|
||||
columns = list(converted_rows[0].keys())
|
||||
cols_str = ', '.join(columns)
|
||||
placeholders = ', '.join(['%s'] * len(columns))
|
||||
|
||||
# Insert into PostgreSQL
|
||||
pg_cur = pg_conn.cursor()
|
||||
|
||||
# Build INSERT query
|
||||
query = f"INSERT INTO {table} ({cols_str}) VALUES %s"
|
||||
|
||||
# Prepare values (list of tuples)
|
||||
values = [
|
||||
tuple(row[col] for col in columns)
|
||||
for row in converted_rows
|
||||
]
|
||||
|
||||
# Batch insert with execute_values (faster than executemany)
|
||||
try:
|
||||
execute_values(pg_cur, query, values, page_size=100)
|
||||
except psycopg2.Error as e:
|
||||
print(f"\n ✗ Insert failed: {e}")
|
||||
raise
|
||||
|
||||
# Verify row count
|
||||
pg_cur.execute(f"SELECT COUNT(*) FROM {table}")
|
||||
postgres_count = pg_cur.fetchone()[0]
|
||||
|
||||
print(f"✓ {sqlite_count} rows → {postgres_count} rows")
|
||||
|
||||
return {
|
||||
'sqlite_count': sqlite_count,
|
||||
'postgres_count': postgres_count
|
||||
}
|
||||
|
||||
|
||||
def verify_migration(pg_conn, stats: Dict[str, Dict[str, int]]):
|
||||
"""
|
||||
Verify migration integrity.
|
||||
|
||||
Args:
|
||||
pg_conn: PostgreSQL connection
|
||||
stats: Migration stats per table
|
||||
"""
|
||||
print("\n═══════════════════════════════════════════════════════════")
|
||||
print("VERIFICATION")
|
||||
print("═══════════════════════════════════════════════════════════")
|
||||
|
||||
all_ok = True
|
||||
|
||||
for table, counts in stats.items():
|
||||
sqlite_count = counts['sqlite_count']
|
||||
postgres_count = counts['postgres_count']
|
||||
|
||||
status = "✓" if sqlite_count == postgres_count else "✗"
|
||||
print(f" {status} {table:20s} SQLite: {sqlite_count:5d} → PostgreSQL: {postgres_count:5d}")
|
||||
|
||||
if sqlite_count != postgres_count:
|
||||
all_ok = False
|
||||
|
||||
# Sample some data
|
||||
print("\n───────────────────────────────────────────────────────────")
|
||||
print("SAMPLE DATA (first profile)")
|
||||
print("───────────────────────────────────────────────────────────")
|
||||
|
||||
cur = pg_conn.cursor(cursor_factory=RealDictCursor)
|
||||
cur.execute("SELECT * FROM profiles LIMIT 1")
|
||||
profile = cur.fetchone()
|
||||
|
||||
if profile:
|
||||
for key, value in dict(profile).items():
|
||||
print(f" {key:20s} = {value}")
|
||||
else:
|
||||
print(" (no profiles found)")
|
||||
|
||||
print("\n───────────────────────────────────────────────────────────")
|
||||
print("SAMPLE DATA (latest weight entry)")
|
||||
print("───────────────────────────────────────────────────────────")
|
||||
|
||||
cur.execute("SELECT * FROM weight_log ORDER BY date DESC LIMIT 1")
|
||||
weight = cur.fetchone()
|
||||
|
||||
if weight:
|
||||
for key, value in dict(weight).items():
|
||||
print(f" {key:20s} = {value}")
|
||||
else:
|
||||
print(" (no weight entries found)")
|
||||
|
||||
print("\n═══════════════════════════════════════════════════════════")
|
||||
|
||||
if all_ok:
|
||||
print("✓ MIGRATION SUCCESSFUL - All row counts match!")
|
||||
else:
|
||||
print("✗ MIGRATION FAILED - Row count mismatch detected!")
|
||||
sys.exit(1)
|
||||
|
||||
|
||||
# ================================================================
|
||||
# MAIN
|
||||
# ================================================================
|
||||
|
||||
def main():
|
||||
print("═══════════════════════════════════════════════════════════")
|
||||
print("MITAI JINKENDO - SQLite → PostgreSQL Migration (v9a → v9b)")
|
||||
print("═══════════════════════════════════════════════════════════\n")
|
||||
|
||||
# Check SQLite DB exists
|
||||
if not SQLITE_DB.exists():
|
||||
print(f"✗ SQLite database not found: {SQLITE_DB}")
|
||||
print(f" Set DATA_DIR environment variable if needed.")
|
||||
sys.exit(1)
|
||||
|
||||
print(f"✓ SQLite source: {SQLITE_DB}")
|
||||
print(f"✓ PostgreSQL target: {PG_CONFIG['user']}@{PG_CONFIG['host']}:{PG_CONFIG['port']}/{PG_CONFIG['database']}\n")
|
||||
|
||||
# Check PostgreSQL password
|
||||
if not PG_CONFIG['password']:
|
||||
print("✗ DB_PASSWORD environment variable not set!")
|
||||
sys.exit(1)
|
||||
|
||||
# Connect to PostgreSQL
|
||||
print("Connecting to PostgreSQL...", end=' ', flush=True)
|
||||
try:
|
||||
pg_conn = psycopg2.connect(**PG_CONFIG)
|
||||
print("✓")
|
||||
except psycopg2.Error as e:
|
||||
print(f"\n✗ Connection failed: {e}")
|
||||
print("\nTroubleshooting:")
|
||||
print(" - Is PostgreSQL running? (docker compose ps)")
|
||||
print(" - Is DB_PASSWORD correct?")
|
||||
print(" - Is the schema initialized? (schema.sql loaded?)")
|
||||
sys.exit(1)
|
||||
|
||||
# Check if schema is initialized
|
||||
print("Checking PostgreSQL schema...", end=' ', flush=True)
|
||||
cur = pg_conn.cursor()
|
||||
cur.execute("""
|
||||
SELECT COUNT(*) FROM information_schema.tables
|
||||
WHERE table_schema = 'public' AND table_name = 'profiles'
|
||||
""")
|
||||
if cur.fetchone()[0] == 0:
|
||||
print("\n✗ Schema not initialized!")
|
||||
print("\nRun this first:")
|
||||
print(" docker compose exec backend python -c \"from main import init_db; init_db()\"")
|
||||
print(" Or manually load schema.sql")
|
||||
sys.exit(1)
|
||||
print("✓")
|
||||
|
||||
# Check if PostgreSQL is empty
|
||||
print("Checking if PostgreSQL is empty...", end=' ', flush=True)
|
||||
cur.execute("SELECT COUNT(*) FROM profiles")
|
||||
existing_profiles = cur.fetchone()[0]
|
||||
if existing_profiles > 0:
|
||||
print(f"\n⚠ WARNING: PostgreSQL already has {existing_profiles} profiles!")
|
||||
response = input(" Continue anyway? This will create duplicates! (yes/no): ")
|
||||
if response.lower() != 'yes':
|
||||
print("Migration cancelled.")
|
||||
sys.exit(0)
|
||||
else:
|
||||
print("✓")
|
||||
|
||||
print("\n───────────────────────────────────────────────────────────")
|
||||
print("MIGRATION")
|
||||
print("───────────────────────────────────────────────────────────")
|
||||
|
||||
stats = {}
|
||||
|
||||
try:
|
||||
for table in TABLES:
|
||||
stats[table] = migrate_table(pg_conn, table)
|
||||
|
||||
# Commit all changes
|
||||
pg_conn.commit()
|
||||
print("\n✓ All changes committed to PostgreSQL")
|
||||
|
||||
except Exception as e:
|
||||
print(f"\n✗ Migration failed: {e}")
|
||||
print("Rolling back...")
|
||||
pg_conn.rollback()
|
||||
pg_conn.close()
|
||||
sys.exit(1)
|
||||
|
||||
# Verification
|
||||
verify_migration(pg_conn, stats)
|
||||
|
||||
# Cleanup
|
||||
pg_conn.close()
|
||||
|
||||
print("\n✓ Migration complete!")
|
||||
print("\nNext steps:")
|
||||
print(" 1. Test login with existing credentials")
|
||||
print(" 2. Check Dashboard (weight chart, stats)")
|
||||
print(" 3. Verify KI-Analysen work")
|
||||
print(" 4. If everything works: commit + push to develop")
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -0,0 +1,119 @@
|
||||
"""
|
||||
Pydantic Models for Mitai Jinkendo API
|
||||
|
||||
Data validation schemas for request/response bodies.
|
||||
"""
|
||||
from typing import Optional
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
# ── Profile Models ────────────────────────────────────────────────────────────
|
||||
|
||||
class ProfileCreate(BaseModel):
|
||||
name: str
|
||||
avatar_color: Optional[str] = '#1D9E75'
|
||||
sex: Optional[str] = 'm'
|
||||
dob: Optional[str] = None
|
||||
height: Optional[float] = 178
|
||||
goal_weight: Optional[float] = None
|
||||
goal_bf_pct: Optional[float] = None
|
||||
|
||||
|
||||
class ProfileUpdate(BaseModel):
|
||||
name: Optional[str] = None
|
||||
avatar_color: Optional[str] = None
|
||||
sex: Optional[str] = None
|
||||
dob: Optional[str] = None
|
||||
height: Optional[float] = None
|
||||
goal_weight: Optional[float] = None
|
||||
goal_bf_pct: Optional[float] = None
|
||||
|
||||
|
||||
# ── Tracking Models ───────────────────────────────────────────────────────────
|
||||
|
||||
class WeightEntry(BaseModel):
|
||||
date: str
|
||||
weight: float
|
||||
note: Optional[str] = None
|
||||
|
||||
|
||||
class CircumferenceEntry(BaseModel):
|
||||
date: str
|
||||
c_neck: Optional[float] = None
|
||||
c_chest: Optional[float] = None
|
||||
c_waist: Optional[float] = None
|
||||
c_belly: Optional[float] = None
|
||||
c_hip: Optional[float] = None
|
||||
c_thigh: Optional[float] = None
|
||||
c_calf: Optional[float] = None
|
||||
c_arm: Optional[float] = None
|
||||
notes: Optional[str] = None
|
||||
photo_id: Optional[str] = None
|
||||
|
||||
|
||||
class CaliperEntry(BaseModel):
|
||||
date: str
|
||||
sf_method: Optional[str] = 'jackson3'
|
||||
sf_chest: Optional[float] = None
|
||||
sf_axilla: Optional[float] = None
|
||||
sf_triceps: Optional[float] = None
|
||||
sf_subscap: Optional[float] = None
|
||||
sf_suprailiac: Optional[float] = None
|
||||
sf_abdomen: Optional[float] = None
|
||||
sf_thigh: Optional[float] = None
|
||||
sf_calf_med: Optional[float] = None
|
||||
sf_lowerback: Optional[float] = None
|
||||
sf_biceps: Optional[float] = None
|
||||
body_fat_pct: Optional[float] = None
|
||||
lean_mass: Optional[float] = None
|
||||
fat_mass: Optional[float] = None
|
||||
notes: Optional[str] = None
|
||||
|
||||
|
||||
class ActivityEntry(BaseModel):
|
||||
date: str
|
||||
start_time: Optional[str] = None
|
||||
end_time: Optional[str] = None
|
||||
activity_type: str
|
||||
duration_min: Optional[float] = None
|
||||
kcal_active: Optional[float] = None
|
||||
kcal_resting: Optional[float] = None
|
||||
hr_avg: Optional[float] = None
|
||||
hr_max: Optional[float] = None
|
||||
distance_km: Optional[float] = None
|
||||
rpe: Optional[int] = None
|
||||
source: Optional[str] = 'manual'
|
||||
notes: Optional[str] = None
|
||||
|
||||
|
||||
class NutritionDay(BaseModel):
|
||||
date: str
|
||||
kcal: Optional[float] = None
|
||||
protein_g: Optional[float] = None
|
||||
fat_g: Optional[float] = None
|
||||
carbs_g: Optional[float] = None
|
||||
|
||||
|
||||
# ── Auth Models ───────────────────────────────────────────────────────────────
|
||||
|
||||
class LoginRequest(BaseModel):
|
||||
email: str
|
||||
password: str
|
||||
|
||||
|
||||
class PasswordResetRequest(BaseModel):
|
||||
email: str
|
||||
|
||||
|
||||
class PasswordResetConfirm(BaseModel):
|
||||
token: str
|
||||
new_password: str
|
||||
|
||||
|
||||
# ── Admin Models ──────────────────────────────────────────────────────────────
|
||||
|
||||
class AdminProfileUpdate(BaseModel):
|
||||
role: Optional[str] = None
|
||||
ai_enabled: Optional[int] = None
|
||||
ai_limit_day: Optional[int] = None
|
||||
export_enabled: Optional[int] = None
|
||||
@@ -7,3 +7,4 @@ aiofiles==23.2.1
|
||||
pydantic==2.7.1
|
||||
bcrypt==4.1.3
|
||||
slowapi==0.1.9
|
||||
psycopg2-binary==2.9.9
|
||||
Whitespace-only changes.
@@ -0,0 +1,137 @@
|
||||
"""
|
||||
Activity Tracking Endpoints for Mitai Jinkendo
|
||||
|
||||
Handles workout/activity logging, statistics, and Apple Health CSV import.
|
||||
"""
|
||||
import csv
|
||||
import io
|
||||
import uuid
|
||||
from typing import Optional
|
||||
|
||||
from fastapi import APIRouter, HTTPException, UploadFile, File, Header, Depends
|
||||
|
||||
from db import get_db, get_cursor, r2d
|
||||
from auth import require_auth
|
||||
from models import ActivityEntry
|
||||
from routers.profiles import get_pid
|
||||
|
||||
router = APIRouter(prefix="/api/activity", tags=["activity"])
|
||||
|
||||
|
||||
@router.get("")
|
||||
def list_activity(limit: int=200, x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Get activity entries for current profile."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute(
|
||||
"SELECT * FROM activity_log WHERE profile_id=%s ORDER BY date DESC, start_time DESC LIMIT %s", (pid,limit))
|
||||
return [r2d(r) for r in cur.fetchall()]
|
||||
|
||||
|
||||
@router.post("")
|
||||
def create_activity(e: ActivityEntry, x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Create new activity entry."""
|
||||
pid = get_pid(x_profile_id)
|
||||
eid = str(uuid.uuid4())
|
||||
d = e.model_dump()
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("""INSERT INTO activity_log
|
||||
(id,profile_id,date,start_time,end_time,activity_type,duration_min,kcal_active,kcal_resting,
|
||||
hr_avg,hr_max,distance_km,rpe,source,notes,created)
|
||||
VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,CURRENT_TIMESTAMP)""",
|
||||
(eid,pid,d['date'],d['start_time'],d['end_time'],d['activity_type'],d['duration_min'],
|
||||
d['kcal_active'],d['kcal_resting'],d['hr_avg'],d['hr_max'],d['distance_km'],
|
||||
d['rpe'],d['source'],d['notes']))
|
||||
return {"id":eid,"date":e.date}
|
||||
|
||||
|
||||
@router.put("/{eid}")
|
||||
def update_activity(eid: str, e: ActivityEntry, x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Update existing activity entry."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
d = e.model_dump()
|
||||
cur = get_cursor(conn)
|
||||
cur.execute(f"UPDATE activity_log SET {', '.join(f'{k}=%s' for k in d)} WHERE id=%s AND profile_id=%s",
|
||||
list(d.values())+[eid,pid])
|
||||
return {"id":eid}
|
||||
|
||||
|
||||
@router.delete("/{eid}")
|
||||
def delete_activity(eid: str, x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Delete activity entry."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("DELETE FROM activity_log WHERE id=%s AND profile_id=%s", (eid,pid))
|
||||
return {"ok":True}
|
||||
|
||||
|
||||
@router.get("/stats")
|
||||
def activity_stats(x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Get activity statistics (last 30 entries)."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute(
|
||||
"SELECT * FROM activity_log WHERE profile_id=%s ORDER BY date DESC LIMIT 30", (pid,))
|
||||
rows = [r2d(r) for r in cur.fetchall()]
|
||||
if not rows: return {"count":0,"total_kcal":0,"total_min":0,"by_type":{}}
|
||||
total_kcal=sum(float(r.get('kcal_active') or 0) for r in rows)
|
||||
total_min=sum(float(r.get('duration_min') or 0) for r in rows)
|
||||
by_type={}
|
||||
for r in rows:
|
||||
t=r['activity_type']; by_type.setdefault(t,{'count':0,'kcal':0,'min':0})
|
||||
by_type[t]['count']+=1
|
||||
by_type[t]['kcal']+=float(r.get('kcal_active') or 0)
|
||||
by_type[t]['min']+=float(r.get('duration_min') or 0)
|
||||
return {"count":len(rows),"total_kcal":round(total_kcal),"total_min":round(total_min),"by_type":by_type}
|
||||
|
||||
|
||||
@router.post("/import-csv")
|
||||
async def import_activity_csv(file: UploadFile=File(...), x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Import Apple Health workout CSV."""
|
||||
pid = get_pid(x_profile_id)
|
||||
raw = await file.read()
|
||||
try: text = raw.decode('utf-8')
|
||||
except: text = raw.decode('latin-1')
|
||||
if text.startswith('\ufeff'): text = text[1:]
|
||||
if not text.strip(): raise HTTPException(400,"Leere Datei")
|
||||
reader = csv.DictReader(io.StringIO(text))
|
||||
inserted = skipped = 0
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
for row in reader:
|
||||
wtype = row.get('Workout Type','').strip()
|
||||
start = row.get('Start','').strip()
|
||||
if not wtype or not start: continue
|
||||
try: date = start[:10]
|
||||
except: continue
|
||||
dur = row.get('Duration','').strip()
|
||||
duration_min = None
|
||||
if dur:
|
||||
try:
|
||||
p = dur.split(':')
|
||||
duration_min = round(int(p[0])*60+int(p[1])+int(p[2])/60,1)
|
||||
except: pass
|
||||
def kj(v):
|
||||
try: return round(float(v)/4.184) if v else None
|
||||
except: return None
|
||||
def tf(v):
|
||||
try: return round(float(v),1) if v else None
|
||||
except: return None
|
||||
try:
|
||||
cur.execute("""INSERT INTO activity_log
|
||||
(id,profile_id,date,start_time,end_time,activity_type,duration_min,kcal_active,kcal_resting,
|
||||
hr_avg,hr_max,distance_km,source,created)
|
||||
VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,'apple_health',CURRENT_TIMESTAMP)""",
|
||||
(str(uuid.uuid4()),pid,date,start,row.get('End',''),wtype,duration_min,
|
||||
kj(row.get('Aktive Energie (kJ)','')),kj(row.get('Ruheeinträge (kJ)','')),
|
||||
tf(row.get('Durchschn. Herzfrequenz (count/min)','')),
|
||||
tf(row.get('Max. Herzfrequenz (count/min)','')),
|
||||
tf(row.get('Distanz (km)',''))))
|
||||
inserted+=1
|
||||
except: skipped+=1
|
||||
return {"inserted":inserted,"skipped":skipped,"message":f"{inserted} Trainings importiert"}
|
||||
@@ -0,0 +1,157 @@
|
||||
"""
|
||||
Admin Management Endpoints for Mitai Jinkendo
|
||||
|
||||
Handles user management, permissions, and email testing (admin-only).
|
||||
"""
|
||||
import os
|
||||
import smtplib
|
||||
from email.mime.text import MIMEText
|
||||
from datetime import datetime
|
||||
|
||||
from fastapi import APIRouter, HTTPException, Depends
|
||||
|
||||
from db import get_db, get_cursor, r2d
|
||||
from auth import require_admin, hash_pin
|
||||
from models import AdminProfileUpdate
|
||||
|
||||
router = APIRouter(prefix="/api/admin", tags=["admin"])
|
||||
|
||||
|
||||
@router.get("/profiles")
|
||||
def admin_list_profiles(session: dict=Depends(require_admin)):
|
||||
"""Admin: List all profiles with stats."""
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT * FROM profiles ORDER BY created")
|
||||
profs = [r2d(r) for r in cur.fetchall()]
|
||||
|
||||
for p in profs:
|
||||
pid = p['id']
|
||||
cur.execute("SELECT COUNT(*) as count FROM weight_log WHERE profile_id=%s", (pid,))
|
||||
p['weight_count'] = cur.fetchone()['count']
|
||||
cur.execute("SELECT COUNT(*) as count FROM ai_insights WHERE profile_id=%s", (pid,))
|
||||
p['ai_insights_count'] = cur.fetchone()['count']
|
||||
|
||||
today = datetime.now().date().isoformat()
|
||||
cur.execute("SELECT call_count FROM ai_usage WHERE profile_id=%s AND date=%s", (pid, today))
|
||||
usage = cur.fetchone()
|
||||
p['ai_usage_today'] = usage['call_count'] if usage else 0
|
||||
|
||||
return profs
|
||||
|
||||
|
||||
@router.put("/profiles/{pid}")
|
||||
def admin_update_profile(pid: str, data: AdminProfileUpdate, session: dict=Depends(require_admin)):
|
||||
"""Admin: Update profile settings."""
|
||||
with get_db() as conn:
|
||||
updates = {k:v for k,v in data.model_dump().items() if v is not None}
|
||||
if not updates:
|
||||
return {"ok": True}
|
||||
|
||||
cur = get_cursor(conn)
|
||||
cur.execute(f"UPDATE profiles SET {', '.join(f'{k}=%s' for k in updates)} WHERE id=%s",
|
||||
list(updates.values()) + [pid])
|
||||
|
||||
return {"ok": True}
|
||||
|
||||
|
||||
@router.put("/profiles/{pid}/permissions")
|
||||
def admin_set_permissions(pid: str, data: dict, session: dict=Depends(require_admin)):
|
||||
"""Admin: Set profile permissions."""
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
updates = []
|
||||
values = []
|
||||
if 'ai_enabled' in data:
|
||||
updates.append('ai_enabled=%s')
|
||||
values.append(data['ai_enabled'])
|
||||
if 'ai_limit_day' in data:
|
||||
updates.append('ai_limit_day=%s')
|
||||
values.append(data['ai_limit_day'])
|
||||
if 'export_enabled' in data:
|
||||
updates.append('export_enabled=%s')
|
||||
values.append(data['export_enabled'])
|
||||
if 'role' in data:
|
||||
updates.append('role=%s')
|
||||
values.append(data['role'])
|
||||
|
||||
if updates:
|
||||
cur.execute(f"UPDATE profiles SET {', '.join(updates)} WHERE id=%s", values + [pid])
|
||||
|
||||
return {"ok": True}
|
||||
|
||||
|
||||
@router.put("/profiles/{pid}/email")
|
||||
def admin_set_email(pid: str, data: dict, session: dict=Depends(require_admin)):
|
||||
"""Admin: Set profile email."""
|
||||
email = data.get('email', '').strip().lower()
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("UPDATE profiles SET email=%s WHERE id=%s", (email if email else None, pid))
|
||||
|
||||
return {"ok": True}
|
||||
|
||||
|
||||
@router.put("/profiles/{pid}/pin")
|
||||
def admin_set_pin(pid: str, data: dict, session: dict=Depends(require_admin)):
|
||||
"""Admin: Set profile PIN/password."""
|
||||
new_pin = data.get('pin', '')
|
||||
if len(new_pin) < 4:
|
||||
raise HTTPException(400, "PIN/Passwort muss mind. 4 Zeichen haben")
|
||||
|
||||
new_hash = hash_pin(new_pin)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("UPDATE profiles SET pin_hash=%s WHERE id=%s", (new_hash, pid))
|
||||
|
||||
return {"ok": True}
|
||||
|
||||
|
||||
@router.get("/email/status")
|
||||
def admin_email_status(session: dict=Depends(require_admin)):
|
||||
"""Admin: Check email configuration status."""
|
||||
smtp_host = os.getenv("SMTP_HOST")
|
||||
smtp_user = os.getenv("SMTP_USER")
|
||||
smtp_pass = os.getenv("SMTP_PASS")
|
||||
app_url = os.getenv("APP_URL", "http://localhost:3002")
|
||||
|
||||
configured = bool(smtp_host and smtp_user and smtp_pass)
|
||||
|
||||
return {
|
||||
"configured": configured,
|
||||
"smtp_host": smtp_host or "",
|
||||
"smtp_user": smtp_user or "",
|
||||
"app_url": app_url
|
||||
}
|
||||
|
||||
|
||||
@router.post("/email/test")
|
||||
def admin_test_email(data: dict, session: dict=Depends(require_admin)):
|
||||
"""Admin: Send test email."""
|
||||
email = data.get('to', '')
|
||||
if not email:
|
||||
raise HTTPException(400, "E-Mail-Adresse fehlt")
|
||||
|
||||
try:
|
||||
smtp_host = os.getenv("SMTP_HOST")
|
||||
smtp_port = int(os.getenv("SMTP_PORT", 587))
|
||||
smtp_user = os.getenv("SMTP_USER")
|
||||
smtp_pass = os.getenv("SMTP_PASS")
|
||||
smtp_from = os.getenv("SMTP_FROM")
|
||||
|
||||
if not smtp_host or not smtp_user or not smtp_pass:
|
||||
raise HTTPException(500, "SMTP nicht konfiguriert")
|
||||
|
||||
msg = MIMEText("Dies ist eine Test-E-Mail von Mitai Jinkendo.")
|
||||
msg['Subject'] = "Test-E-Mail"
|
||||
msg['From'] = smtp_from
|
||||
msg['To'] = email
|
||||
|
||||
with smtplib.SMTP(smtp_host, smtp_port) as server:
|
||||
server.starttls()
|
||||
server.login(smtp_user, smtp_pass)
|
||||
server.send_message(msg)
|
||||
|
||||
return {"ok": True, "message": f"Test-E-Mail an {email} gesendet"}
|
||||
except Exception as e:
|
||||
raise HTTPException(500, f"Fehler beim Senden: {str(e)}")
|
||||
@@ -0,0 +1,176 @@
|
||||
"""
|
||||
Authentication Endpoints for Mitai Jinkendo
|
||||
|
||||
Handles login, logout, password reset, and profile authentication.
|
||||
"""
|
||||
import os
|
||||
import secrets
|
||||
import smtplib
|
||||
from typing import Optional
|
||||
from datetime import datetime, timedelta
|
||||
from email.mime.text import MIMEText
|
||||
|
||||
from fastapi import APIRouter, HTTPException, Header, Depends
|
||||
from starlette.requests import Request
|
||||
from slowapi import Limiter
|
||||
from slowapi.util import get_remote_address
|
||||
|
||||
from db import get_db, get_cursor
|
||||
from auth import hash_pin, verify_pin, make_token, require_auth
|
||||
from models import LoginRequest, PasswordResetRequest, PasswordResetConfirm
|
||||
|
||||
router = APIRouter(prefix="/api/auth", tags=["auth"])
|
||||
limiter = Limiter(key_func=get_remote_address)
|
||||
|
||||
|
||||
@router.post("/login")
|
||||
@limiter.limit("5/minute")
|
||||
async def login(req: LoginRequest, request: Request):
|
||||
"""Login with email + password."""
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT * FROM profiles WHERE email=%s", (req.email.lower().strip(),))
|
||||
prof = cur.fetchone()
|
||||
if not prof:
|
||||
raise HTTPException(401, "Ungültige Zugangsdaten")
|
||||
|
||||
# Verify password
|
||||
if not verify_pin(req.password, prof['pin_hash']):
|
||||
raise HTTPException(401, "Ungültige Zugangsdaten")
|
||||
|
||||
# Auto-upgrade from SHA256 to bcrypt
|
||||
if prof['pin_hash'] and not prof['pin_hash'].startswith('$2'):
|
||||
new_hash = hash_pin(req.password)
|
||||
cur.execute("UPDATE profiles SET pin_hash=%s WHERE id=%s", (new_hash, prof['id']))
|
||||
|
||||
# Create session
|
||||
token = make_token()
|
||||
session_days = prof.get('session_days', 30)
|
||||
expires = datetime.now() + timedelta(days=session_days)
|
||||
cur.execute("INSERT INTO sessions (token, profile_id, expires_at, created) VALUES (%s,%s,%s,CURRENT_TIMESTAMP)",
|
||||
(token, prof['id'], expires.isoformat()))
|
||||
|
||||
return {
|
||||
"token": token,
|
||||
"profile_id": prof['id'],
|
||||
"name": prof['name'],
|
||||
"role": prof['role'],
|
||||
"expires_at": expires.isoformat()
|
||||
}
|
||||
|
||||
|
||||
@router.post("/logout")
|
||||
def logout(x_auth_token: Optional[str]=Header(default=None)):
|
||||
"""Logout (delete session)."""
|
||||
if x_auth_token:
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("DELETE FROM sessions WHERE token=%s", (x_auth_token,))
|
||||
return {"ok": True}
|
||||
|
||||
|
||||
@router.get("/me")
|
||||
def get_me(session: dict=Depends(require_auth)):
|
||||
"""Get current user info."""
|
||||
pid = session['profile_id']
|
||||
# Import here to avoid circular dependency
|
||||
from routers.profiles import get_profile
|
||||
return get_profile(pid, session)
|
||||
|
||||
|
||||
@router.get("/status")
|
||||
def auth_status():
|
||||
"""Health check endpoint."""
|
||||
return {"status": "ok", "service": "mitai-jinkendo", "version": "v9b"}
|
||||
|
||||
|
||||
@router.put("/pin")
|
||||
def change_pin(req: dict, session: dict=Depends(require_auth)):
|
||||
"""Change PIN/password for current user."""
|
||||
pid = session['profile_id']
|
||||
new_pin = req.get('pin', '')
|
||||
if len(new_pin) < 4:
|
||||
raise HTTPException(400, "PIN/Passwort muss mind. 4 Zeichen haben")
|
||||
|
||||
new_hash = hash_pin(new_pin)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("UPDATE profiles SET pin_hash=%s WHERE id=%s", (new_hash, pid))
|
||||
|
||||
return {"ok": True}
|
||||
|
||||
|
||||
@router.post("/forgot-password")
|
||||
@limiter.limit("3/minute")
|
||||
async def password_reset_request(req: PasswordResetRequest, request: Request):
|
||||
"""Request password reset email."""
|
||||
email = req.email.lower().strip()
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT id, name FROM profiles WHERE email=%s", (email,))
|
||||
prof = cur.fetchone()
|
||||
if not prof:
|
||||
# Don't reveal if email exists
|
||||
return {"ok": True, "message": "Falls die E-Mail existiert, wurde ein Reset-Link gesendet."}
|
||||
|
||||
# Generate reset token
|
||||
token = secrets.token_urlsafe(32)
|
||||
expires = datetime.now() + timedelta(hours=1)
|
||||
|
||||
# Store in sessions table (reuse mechanism)
|
||||
cur.execute("INSERT INTO sessions (token, profile_id, expires_at, created) VALUES (%s,%s,%s,CURRENT_TIMESTAMP)",
|
||||
(f"reset_{token}", prof['id'], expires.isoformat()))
|
||||
|
||||
# Send email
|
||||
try:
|
||||
smtp_host = os.getenv("SMTP_HOST")
|
||||
smtp_port = int(os.getenv("SMTP_PORT", 587))
|
||||
smtp_user = os.getenv("SMTP_USER")
|
||||
smtp_pass = os.getenv("SMTP_PASS")
|
||||
smtp_from = os.getenv("SMTP_FROM")
|
||||
app_url = os.getenv("APP_URL", "https://mitai.jinkendo.de")
|
||||
|
||||
if smtp_host and smtp_user and smtp_pass:
|
||||
msg = MIMEText(f"""Hallo {prof['name']},
|
||||
|
||||
Du hast einen Passwort-Reset angefordert.
|
||||
|
||||
Reset-Link: {app_url}/reset-password?token={token}
|
||||
|
||||
Der Link ist 1 Stunde gültig.
|
||||
|
||||
Falls du diese Anfrage nicht gestellt hast, ignoriere diese E-Mail.
|
||||
|
||||
Dein Mitai Jinkendo Team
|
||||
""")
|
||||
msg['Subject'] = "Passwort zurücksetzen – Mitai Jinkendo"
|
||||
msg['From'] = smtp_from
|
||||
msg['To'] = email
|
||||
|
||||
with smtplib.SMTP(smtp_host, smtp_port) as server:
|
||||
server.starttls()
|
||||
server.login(smtp_user, smtp_pass)
|
||||
server.send_message(msg)
|
||||
except Exception as e:
|
||||
print(f"Email error: {e}")
|
||||
|
||||
return {"ok": True, "message": "Falls die E-Mail existiert, wurde ein Reset-Link gesendet."}
|
||||
|
||||
|
||||
@router.post("/reset-password")
|
||||
def password_reset_confirm(req: PasswordResetConfirm):
|
||||
"""Confirm password reset with token."""
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT profile_id FROM sessions WHERE token=%s AND expires_at > CURRENT_TIMESTAMP",
|
||||
(f"reset_{req.token}",))
|
||||
sess = cur.fetchone()
|
||||
if not sess:
|
||||
raise HTTPException(400, "Ungültiger oder abgelaufener Reset-Link")
|
||||
|
||||
pid = sess['profile_id']
|
||||
new_hash = hash_pin(req.new_password)
|
||||
cur.execute("UPDATE profiles SET pin_hash=%s WHERE id=%s", (new_hash, pid))
|
||||
cur.execute("DELETE FROM sessions WHERE token=%s", (f"reset_{req.token}",))
|
||||
|
||||
return {"ok": True, "message": "Passwort erfolgreich zurückgesetzt"}
|
||||
@@ -0,0 +1,75 @@
|
||||
"""
|
||||
Caliper/Skinfold Tracking Endpoints for Mitai Jinkendo
|
||||
|
||||
Handles body fat measurements via skinfold caliper (4 methods supported).
|
||||
"""
|
||||
import uuid
|
||||
from typing import Optional
|
||||
|
||||
from fastapi import APIRouter, Header, Depends
|
||||
|
||||
from db import get_db, get_cursor, r2d
|
||||
from auth import require_auth
|
||||
from models import CaliperEntry
|
||||
from routers.profiles import get_pid
|
||||
|
||||
router = APIRouter(prefix="/api/caliper", tags=["caliper"])
|
||||
|
||||
|
||||
@router.get("")
|
||||
def list_caliper(limit: int=100, x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Get caliper entries for current profile."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute(
|
||||
"SELECT * FROM caliper_log WHERE profile_id=%s ORDER BY date DESC LIMIT %s", (pid,limit))
|
||||
return [r2d(r) for r in cur.fetchall()]
|
||||
|
||||
|
||||
@router.post("")
|
||||
def upsert_caliper(e: CaliperEntry, x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Create or update caliper entry (upsert by date)."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT id FROM caliper_log WHERE profile_id=%s AND date=%s", (pid,e.date))
|
||||
ex = cur.fetchone()
|
||||
d = e.model_dump()
|
||||
if ex:
|
||||
eid = ex['id']
|
||||
sets = ', '.join(f"{k}=%s" for k in d if k!='date')
|
||||
cur.execute(f"UPDATE caliper_log SET {sets} WHERE id=%s",
|
||||
[v for k,v in d.items() if k!='date']+[eid])
|
||||
else:
|
||||
eid = str(uuid.uuid4())
|
||||
cur.execute("""INSERT INTO caliper_log
|
||||
(id,profile_id,date,sf_method,sf_chest,sf_axilla,sf_triceps,sf_subscap,sf_suprailiac,
|
||||
sf_abdomen,sf_thigh,sf_calf_med,sf_lowerback,sf_biceps,body_fat_pct,lean_mass,fat_mass,notes,created)
|
||||
VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,CURRENT_TIMESTAMP)""",
|
||||
(eid,pid,d['date'],d['sf_method'],d['sf_chest'],d['sf_axilla'],d['sf_triceps'],
|
||||
d['sf_subscap'],d['sf_suprailiac'],d['sf_abdomen'],d['sf_thigh'],d['sf_calf_med'],
|
||||
d['sf_lowerback'],d['sf_biceps'],d['body_fat_pct'],d['lean_mass'],d['fat_mass'],d['notes']))
|
||||
return {"id":eid,"date":e.date}
|
||||
|
||||
|
||||
@router.put("/{eid}")
|
||||
def update_caliper(eid: str, e: CaliperEntry, x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Update existing caliper entry."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
d = e.model_dump()
|
||||
cur = get_cursor(conn)
|
||||
cur.execute(f"UPDATE caliper_log SET {', '.join(f'{k}=%s' for k in d)} WHERE id=%s AND profile_id=%s",
|
||||
list(d.values())+[eid,pid])
|
||||
return {"id":eid}
|
||||
|
||||
|
||||
@router.delete("/{eid}")
|
||||
def delete_caliper(eid: str, x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Delete caliper entry."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("DELETE FROM caliper_log WHERE id=%s AND profile_id=%s", (eid,pid))
|
||||
return {"ok":True}
|
||||
@@ -0,0 +1,73 @@
|
||||
"""
|
||||
Circumference Tracking Endpoints for Mitai Jinkendo
|
||||
|
||||
Handles body circumference measurements (8 measurement points).
|
||||
"""
|
||||
import uuid
|
||||
from typing import Optional
|
||||
|
||||
from fastapi import APIRouter, Header, Depends
|
||||
|
||||
from db import get_db, get_cursor, r2d
|
||||
from auth import require_auth
|
||||
from models import CircumferenceEntry
|
||||
from routers.profiles import get_pid
|
||||
|
||||
router = APIRouter(prefix="/api/circumferences", tags=["circumference"])
|
||||
|
||||
|
||||
@router.get("")
|
||||
def list_circs(limit: int=100, x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Get circumference entries for current profile."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute(
|
||||
"SELECT * FROM circumference_log WHERE profile_id=%s ORDER BY date DESC LIMIT %s", (pid,limit))
|
||||
return [r2d(r) for r in cur.fetchall()]
|
||||
|
||||
|
||||
@router.post("")
|
||||
def upsert_circ(e: CircumferenceEntry, x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Create or update circumference entry (upsert by date)."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT id FROM circumference_log WHERE profile_id=%s AND date=%s", (pid,e.date))
|
||||
ex = cur.fetchone()
|
||||
d = e.model_dump()
|
||||
if ex:
|
||||
eid = ex['id']
|
||||
sets = ', '.join(f"{k}=%s" for k in d if k!='date')
|
||||
cur.execute(f"UPDATE circumference_log SET {sets} WHERE id=%s",
|
||||
[v for k,v in d.items() if k!='date']+[eid])
|
||||
else:
|
||||
eid = str(uuid.uuid4())
|
||||
cur.execute("""INSERT INTO circumference_log
|
||||
(id,profile_id,date,c_neck,c_chest,c_waist,c_belly,c_hip,c_thigh,c_calf,c_arm,notes,photo_id,created)
|
||||
VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,CURRENT_TIMESTAMP)""",
|
||||
(eid,pid,d['date'],d['c_neck'],d['c_chest'],d['c_waist'],d['c_belly'],
|
||||
d['c_hip'],d['c_thigh'],d['c_calf'],d['c_arm'],d['notes'],d['photo_id']))
|
||||
return {"id":eid,"date":e.date}
|
||||
|
||||
|
||||
@router.put("/{eid}")
|
||||
def update_circ(eid: str, e: CircumferenceEntry, x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Update existing circumference entry."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
d = e.model_dump()
|
||||
cur = get_cursor(conn)
|
||||
cur.execute(f"UPDATE circumference_log SET {', '.join(f'{k}=%s' for k in d)} WHERE id=%s AND profile_id=%s",
|
||||
list(d.values())+[eid,pid])
|
||||
return {"id":eid}
|
||||
|
||||
|
||||
@router.delete("/{eid}")
|
||||
def delete_circ(eid: str, x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Delete circumference entry."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("DELETE FROM circumference_log WHERE id=%s AND profile_id=%s", (eid,pid))
|
||||
return {"ok":True}
|
||||
@@ -0,0 +1,304 @@
|
||||
"""
|
||||
Data Export Endpoints for Mitai Jinkendo
|
||||
|
||||
Handles CSV, JSON, and ZIP exports with photos.
|
||||
"""
|
||||
import os
|
||||
import csv
|
||||
import io
|
||||
import json
|
||||
import zipfile
|
||||
from pathlib import Path
|
||||
from typing import Optional
|
||||
from datetime import datetime
|
||||
from decimal import Decimal
|
||||
|
||||
from fastapi import APIRouter, HTTPException, Header, Depends
|
||||
from fastapi.responses import StreamingResponse, Response
|
||||
|
||||
from db import get_db, get_cursor, r2d
|
||||
from auth import require_auth
|
||||
from routers.profiles import get_pid
|
||||
|
||||
router = APIRouter(prefix="/api/export", tags=["export"])
|
||||
|
||||
PHOTOS_DIR = Path(os.getenv("PHOTOS_DIR", "./photos"))
|
||||
|
||||
|
||||
@router.get("/csv")
|
||||
def export_csv(x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Export all data as CSV."""
|
||||
pid = get_pid(x_profile_id)
|
||||
|
||||
# Check export permission
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT export_enabled FROM profiles WHERE id=%s", (pid,))
|
||||
prof = cur.fetchone()
|
||||
if not prof or not prof['export_enabled']:
|
||||
raise HTTPException(403, "Export ist für dieses Profil deaktiviert")
|
||||
|
||||
# Build CSV
|
||||
output = io.StringIO()
|
||||
writer = csv.writer(output)
|
||||
|
||||
# Header
|
||||
writer.writerow(["Typ", "Datum", "Wert", "Details"])
|
||||
|
||||
# Weight
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT date, weight, note FROM weight_log WHERE profile_id=%s ORDER BY date", (pid,))
|
||||
for r in cur.fetchall():
|
||||
writer.writerow(["Gewicht", r['date'], f"{float(r['weight'])}kg", r['note'] or ""])
|
||||
|
||||
# Circumferences
|
||||
cur.execute("SELECT date, c_waist, c_belly, c_hip FROM circumference_log WHERE profile_id=%s ORDER BY date", (pid,))
|
||||
for r in cur.fetchall():
|
||||
details = f"Taille:{float(r['c_waist'])}cm Bauch:{float(r['c_belly'])}cm Hüfte:{float(r['c_hip'])}cm"
|
||||
writer.writerow(["Umfänge", r['date'], "", details])
|
||||
|
||||
# Caliper
|
||||
cur.execute("SELECT date, body_fat_pct, lean_mass FROM caliper_log WHERE profile_id=%s ORDER BY date", (pid,))
|
||||
for r in cur.fetchall():
|
||||
writer.writerow(["Caliper", r['date'], f"{float(r['body_fat_pct'])}%", f"Magermasse:{float(r['lean_mass'])}kg"])
|
||||
|
||||
# Nutrition
|
||||
cur.execute("SELECT date, kcal, protein_g FROM nutrition_log WHERE profile_id=%s ORDER BY date", (pid,))
|
||||
for r in cur.fetchall():
|
||||
writer.writerow(["Ernährung", r['date'], f"{float(r['kcal'])}kcal", f"Protein:{float(r['protein_g'])}g"])
|
||||
|
||||
# Activity
|
||||
cur.execute("SELECT date, activity_type, duration_min, kcal_active FROM activity_log WHERE profile_id=%s ORDER BY date", (pid,))
|
||||
for r in cur.fetchall():
|
||||
writer.writerow(["Training", r['date'], r['activity_type'], f"{float(r['duration_min'])}min {float(r['kcal_active'])}kcal"])
|
||||
|
||||
output.seek(0)
|
||||
return StreamingResponse(
|
||||
iter([output.getvalue()]),
|
||||
media_type="text/csv",
|
||||
headers={"Content-Disposition": f"attachment; filename=mitai-export-{pid}.csv"}
|
||||
)
|
||||
|
||||
|
||||
@router.get("/json")
|
||||
def export_json(x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Export all data as JSON."""
|
||||
pid = get_pid(x_profile_id)
|
||||
|
||||
# Check export permission
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT export_enabled FROM profiles WHERE id=%s", (pid,))
|
||||
prof = cur.fetchone()
|
||||
if not prof or not prof['export_enabled']:
|
||||
raise HTTPException(403, "Export ist für dieses Profil deaktiviert")
|
||||
|
||||
# Collect all data
|
||||
data = {}
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
|
||||
cur.execute("SELECT * FROM profiles WHERE id=%s", (pid,))
|
||||
data['profile'] = r2d(cur.fetchone())
|
||||
|
||||
cur.execute("SELECT * FROM weight_log WHERE profile_id=%s ORDER BY date", (pid,))
|
||||
data['weight'] = [r2d(r) for r in cur.fetchall()]
|
||||
|
||||
cur.execute("SELECT * FROM circumference_log WHERE profile_id=%s ORDER BY date", (pid,))
|
||||
data['circumferences'] = [r2d(r) for r in cur.fetchall()]
|
||||
|
||||
cur.execute("SELECT * FROM caliper_log WHERE profile_id=%s ORDER BY date", (pid,))
|
||||
data['caliper'] = [r2d(r) for r in cur.fetchall()]
|
||||
|
||||
cur.execute("SELECT * FROM nutrition_log WHERE profile_id=%s ORDER BY date", (pid,))
|
||||
data['nutrition'] = [r2d(r) for r in cur.fetchall()]
|
||||
|
||||
cur.execute("SELECT * FROM activity_log WHERE profile_id=%s ORDER BY date", (pid,))
|
||||
data['activity'] = [r2d(r) for r in cur.fetchall()]
|
||||
|
||||
cur.execute("SELECT * FROM ai_insights WHERE profile_id=%s ORDER BY created DESC", (pid,))
|
||||
data['insights'] = [r2d(r) for r in cur.fetchall()]
|
||||
|
||||
def decimal_handler(obj):
|
||||
if isinstance(obj, Decimal):
|
||||
return float(obj)
|
||||
return str(obj)
|
||||
|
||||
json_str = json.dumps(data, indent=2, default=decimal_handler)
|
||||
return Response(
|
||||
content=json_str,
|
||||
media_type="application/json",
|
||||
headers={"Content-Disposition": f"attachment; filename=mitai-export-{pid}.json"}
|
||||
)
|
||||
|
||||
|
||||
@router.get("/zip")
|
||||
def export_zip(x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Export all data as ZIP (CSV + JSON + photos) per specification."""
|
||||
pid = get_pid(x_profile_id)
|
||||
|
||||
# Check export permission & get profile
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT * FROM profiles WHERE id=%s", (pid,))
|
||||
prof = r2d(cur.fetchone())
|
||||
if not prof or not prof.get('export_enabled'):
|
||||
raise HTTPException(403, "Export ist für dieses Profil deaktiviert")
|
||||
|
||||
# Helper: CSV writer with UTF-8 BOM + semicolon
|
||||
def write_csv(zf, filename, rows, columns):
|
||||
if not rows:
|
||||
return
|
||||
output = io.StringIO()
|
||||
writer = csv.writer(output, delimiter=';')
|
||||
writer.writerow(columns)
|
||||
for r in rows:
|
||||
writer.writerow([
|
||||
'' if r.get(col) is None else
|
||||
(float(r[col]) if isinstance(r.get(col), Decimal) else r[col])
|
||||
for col in columns
|
||||
])
|
||||
# UTF-8 with BOM for Excel
|
||||
csv_bytes = '\ufeff'.encode('utf-8') + output.getvalue().encode('utf-8')
|
||||
zf.writestr(f"data/{filename}", csv_bytes)
|
||||
|
||||
# Create ZIP
|
||||
zip_buffer = io.BytesIO()
|
||||
export_date = datetime.now().strftime('%Y-%m-%d')
|
||||
profile_name = prof.get('name', 'export')
|
||||
|
||||
with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zf:
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
|
||||
# 1. README.txt
|
||||
readme = f"""Mitai Jinkendo – Datenexport
|
||||
Version: 2
|
||||
Exportiert am: {export_date}
|
||||
Profil: {profile_name}
|
||||
|
||||
Inhalt:
|
||||
- profile.json: Profildaten und Einstellungen
|
||||
- data/*.csv: Messdaten (Semikolon-getrennt, UTF-8)
|
||||
- insights/: KI-Auswertungen (JSON)
|
||||
- photos/: Progress-Fotos (JPEG)
|
||||
|
||||
Import:
|
||||
Dieser Export kann in Mitai Jinkendo unter
|
||||
Einstellungen → Import → "Mitai Backup importieren"
|
||||
wieder eingespielt werden.
|
||||
|
||||
Format-Version 2 (ab v9b):
|
||||
Alle CSV-Dateien sind UTF-8 mit BOM kodiert.
|
||||
Trennzeichen: Semikolon (;)
|
||||
Datumsformat: YYYY-MM-DD
|
||||
"""
|
||||
zf.writestr("README.txt", readme.encode('utf-8'))
|
||||
|
||||
# 2. profile.json (ohne Passwort-Hash)
|
||||
cur.execute("SELECT COUNT(*) as c FROM weight_log WHERE profile_id=%s", (pid,))
|
||||
w_count = cur.fetchone()['c']
|
||||
cur.execute("SELECT COUNT(*) as c FROM nutrition_log WHERE profile_id=%s", (pid,))
|
||||
n_count = cur.fetchone()['c']
|
||||
cur.execute("SELECT COUNT(*) as c FROM activity_log WHERE profile_id=%s", (pid,))
|
||||
a_count = cur.fetchone()['c']
|
||||
cur.execute("SELECT COUNT(*) as c FROM photos WHERE profile_id=%s", (pid,))
|
||||
p_count = cur.fetchone()['c']
|
||||
|
||||
profile_data = {
|
||||
"export_version": "2",
|
||||
"export_date": export_date,
|
||||
"app": "Mitai Jinkendo",
|
||||
"profile": {
|
||||
"name": prof.get('name'),
|
||||
"email": prof.get('email'),
|
||||
"sex": prof.get('sex'),
|
||||
"height": float(prof['height']) if prof.get('height') else None,
|
||||
"birth_year": prof['dob'].year if prof.get('dob') else None,
|
||||
"goal_weight": float(prof['goal_weight']) if prof.get('goal_weight') else None,
|
||||
"goal_bf_pct": float(prof['goal_bf_pct']) if prof.get('goal_bf_pct') else None,
|
||||
"avatar_color": prof.get('avatar_color'),
|
||||
"auth_type": prof.get('auth_type'),
|
||||
"session_days": prof.get('session_days'),
|
||||
"ai_enabled": prof.get('ai_enabled'),
|
||||
"tier": prof.get('tier')
|
||||
},
|
||||
"stats": {
|
||||
"weight_entries": w_count,
|
||||
"nutrition_entries": n_count,
|
||||
"activity_entries": a_count,
|
||||
"photos": p_count
|
||||
}
|
||||
}
|
||||
zf.writestr("profile.json", json.dumps(profile_data, indent=2, ensure_ascii=False).encode('utf-8'))
|
||||
|
||||
# 3-7. CSV exports (weight, circumferences, caliper, nutrition, activity)
|
||||
cur.execute("SELECT id, date, weight, note, source, created FROM weight_log WHERE profile_id=%s ORDER BY date", (pid,))
|
||||
write_csv(zf, "weight.csv", [r2d(r) for r in cur.fetchall()], ['id','date','weight','note','source','created'])
|
||||
|
||||
cur.execute("SELECT id, date, c_waist, c_hip, c_chest, c_neck, c_arm, c_thigh, c_calf, notes, created FROM circumference_log WHERE profile_id=%s ORDER BY date", (pid,))
|
||||
rows = [r2d(r) for r in cur.fetchall()]
|
||||
for r in rows:
|
||||
r['waist'] = r.pop('c_waist', None); r['hip'] = r.pop('c_hip', None)
|
||||
r['chest'] = r.pop('c_chest', None); r['neck'] = r.pop('c_neck', None)
|
||||
r['upper_arm'] = r.pop('c_arm', None); r['thigh'] = r.pop('c_thigh', None)
|
||||
r['calf'] = r.pop('c_calf', None); r['forearm'] = None; r['note'] = r.pop('notes', None)
|
||||
write_csv(zf, "circumferences.csv", rows, ['id','date','waist','hip','chest','neck','upper_arm','thigh','calf','forearm','note','created'])
|
||||
|
||||
cur.execute("SELECT id, date, sf_chest, sf_abdomen, sf_thigh, sf_triceps, sf_subscap, sf_suprailiac, sf_axilla, sf_method, body_fat_pct, notes, created FROM caliper_log WHERE profile_id=%s ORDER BY date", (pid,))
|
||||
rows = [r2d(r) for r in cur.fetchall()]
|
||||
for r in rows:
|
||||
r['chest'] = r.pop('sf_chest', None); r['abdomen'] = r.pop('sf_abdomen', None)
|
||||
r['thigh'] = r.pop('sf_thigh', None); r['tricep'] = r.pop('sf_triceps', None)
|
||||
r['subscapular'] = r.pop('sf_subscap', None); r['suprailiac'] = r.pop('sf_suprailiac', None)
|
||||
r['midaxillary'] = r.pop('sf_axilla', None); r['method'] = r.pop('sf_method', None)
|
||||
r['bf_percent'] = r.pop('body_fat_pct', None); r['note'] = r.pop('notes', None)
|
||||
write_csv(zf, "caliper.csv", rows, ['id','date','chest','abdomen','thigh','tricep','subscapular','suprailiac','midaxillary','method','bf_percent','note','created'])
|
||||
|
||||
cur.execute("SELECT id, date, kcal, protein_g, fat_g, carbs_g, source, created FROM nutrition_log WHERE profile_id=%s ORDER BY date", (pid,))
|
||||
rows = [r2d(r) for r in cur.fetchall()]
|
||||
for r in rows:
|
||||
r['meal_name'] = ''; r['protein'] = r.pop('protein_g', None)
|
||||
r['fat'] = r.pop('fat_g', None); r['carbs'] = r.pop('carbs_g', None)
|
||||
r['fiber'] = None; r['note'] = ''
|
||||
write_csv(zf, "nutrition.csv", rows, ['id','date','meal_name','kcal','protein','fat','carbs','fiber','note','source','created'])
|
||||
|
||||
cur.execute("SELECT id, date, activity_type, duration_min, kcal_active, hr_avg, hr_max, distance_km, notes, source, created FROM activity_log WHERE profile_id=%s ORDER BY date", (pid,))
|
||||
rows = [r2d(r) for r in cur.fetchall()]
|
||||
for r in rows:
|
||||
r['name'] = r['activity_type']; r['type'] = r.pop('activity_type', None)
|
||||
r['kcal'] = r.pop('kcal_active', None); r['heart_rate_avg'] = r.pop('hr_avg', None)
|
||||
r['heart_rate_max'] = r.pop('hr_max', None); r['note'] = r.pop('notes', None)
|
||||
write_csv(zf, "activity.csv", rows, ['id','date','name','type','duration_min','kcal','heart_rate_avg','heart_rate_max','distance_km','note','source','created'])
|
||||
|
||||
# 8. insights/ai_insights.json
|
||||
cur.execute("SELECT id, scope, content, created FROM ai_insights WHERE profile_id=%s ORDER BY created DESC", (pid,))
|
||||
insights = []
|
||||
for r in cur.fetchall():
|
||||
rd = r2d(r)
|
||||
insights.append({
|
||||
"id": rd['id'],
|
||||
"scope": rd['scope'],
|
||||
"created": rd['created'].isoformat() if hasattr(rd['created'], 'isoformat') else str(rd['created']),
|
||||
"result": rd['content']
|
||||
})
|
||||
if insights:
|
||||
zf.writestr("insights/ai_insights.json", json.dumps(insights, indent=2, ensure_ascii=False).encode('utf-8'))
|
||||
|
||||
# 9. photos/
|
||||
cur.execute("SELECT * FROM photos WHERE profile_id=%s ORDER BY date", (pid,))
|
||||
photos = [r2d(r) for r in cur.fetchall()]
|
||||
for i, photo in enumerate(photos):
|
||||
photo_path = Path(PHOTOS_DIR) / photo['path']
|
||||
if photo_path.exists():
|
||||
filename = f"{photo.get('date') or export_date}_{i+1}{photo_path.suffix}"
|
||||
zf.write(photo_path, f"photos/{filename}")
|
||||
|
||||
zip_buffer.seek(0)
|
||||
filename = f"mitai-export-{profile_name.replace(' ','-')}-{export_date}.zip"
|
||||
return StreamingResponse(
|
||||
iter([zip_buffer.getvalue()]),
|
||||
media_type="application/zip",
|
||||
headers={"Content-Disposition": f"attachment; filename={filename}"}
|
||||
)
|
||||
@@ -0,0 +1,267 @@
|
||||
"""
|
||||
Data Import Endpoints for Mitai Jinkendo
|
||||
|
||||
Handles ZIP import with validation and rollback support.
|
||||
"""
|
||||
import os
|
||||
import csv
|
||||
import io
|
||||
import json
|
||||
import uuid
|
||||
import zipfile
|
||||
from pathlib import Path
|
||||
from typing import Optional
|
||||
from datetime import datetime
|
||||
|
||||
from fastapi import APIRouter, HTTPException, UploadFile, File, Header, Depends
|
||||
|
||||
from db import get_db, get_cursor
|
||||
from auth import require_auth
|
||||
from routers.profiles import get_pid
|
||||
|
||||
router = APIRouter(prefix="/api/import", tags=["import"])
|
||||
|
||||
PHOTOS_DIR = Path(os.getenv("PHOTOS_DIR", "./photos"))
|
||||
|
||||
|
||||
@router.post("/zip")
|
||||
async def import_zip(
|
||||
file: UploadFile = File(...),
|
||||
x_profile_id: Optional[str] = Header(default=None),
|
||||
session: dict = Depends(require_auth)
|
||||
):
|
||||
"""
|
||||
Import data from ZIP export file.
|
||||
|
||||
- Validates export format
|
||||
- Imports missing entries only (ON CONFLICT DO NOTHING)
|
||||
- Imports photos
|
||||
- Returns import summary
|
||||
- Full rollback on error
|
||||
"""
|
||||
pid = get_pid(x_profile_id)
|
||||
|
||||
# Read uploaded file
|
||||
content = await file.read()
|
||||
zip_buffer = io.BytesIO(content)
|
||||
|
||||
try:
|
||||
with zipfile.ZipFile(zip_buffer, 'r') as zf:
|
||||
# 1. Validate profile.json
|
||||
if 'profile.json' not in zf.namelist():
|
||||
raise HTTPException(400, "Ungültiger Export: profile.json fehlt")
|
||||
|
||||
profile_data = json.loads(zf.read('profile.json').decode('utf-8'))
|
||||
export_version = profile_data.get('export_version', '1')
|
||||
|
||||
# Stats tracker
|
||||
stats = {
|
||||
'weight': 0,
|
||||
'circumferences': 0,
|
||||
'caliper': 0,
|
||||
'nutrition': 0,
|
||||
'activity': 0,
|
||||
'photos': 0,
|
||||
'insights': 0
|
||||
}
|
||||
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
|
||||
try:
|
||||
# 2. Import weight.csv
|
||||
if 'data/weight.csv' in zf.namelist():
|
||||
csv_data = zf.read('data/weight.csv').decode('utf-8-sig')
|
||||
reader = csv.DictReader(io.StringIO(csv_data), delimiter=';')
|
||||
for row in reader:
|
||||
cur.execute("""
|
||||
INSERT INTO weight_log (profile_id, date, weight, note, source, created)
|
||||
VALUES (%s, %s, %s, %s, %s, %s)
|
||||
ON CONFLICT (profile_id, date) DO NOTHING
|
||||
""", (
|
||||
pid,
|
||||
row['date'],
|
||||
float(row['weight']) if row['weight'] else None,
|
||||
row.get('note', ''),
|
||||
row.get('source', 'import'),
|
||||
row.get('created', datetime.now())
|
||||
))
|
||||
if cur.rowcount > 0:
|
||||
stats['weight'] += 1
|
||||
|
||||
# 3. Import circumferences.csv
|
||||
if 'data/circumferences.csv' in zf.namelist():
|
||||
csv_data = zf.read('data/circumferences.csv').decode('utf-8-sig')
|
||||
reader = csv.DictReader(io.StringIO(csv_data), delimiter=';')
|
||||
for row in reader:
|
||||
cur.execute("""
|
||||
INSERT INTO circumference_log (
|
||||
profile_id, date, c_waist, c_hip, c_chest, c_neck,
|
||||
c_arm, c_thigh, c_calf, notes, created
|
||||
)
|
||||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
|
||||
ON CONFLICT (profile_id, date) DO NOTHING
|
||||
""", (
|
||||
pid,
|
||||
row['date'],
|
||||
float(row['waist']) if row.get('waist') else None,
|
||||
float(row['hip']) if row.get('hip') else None,
|
||||
float(row['chest']) if row.get('chest') else None,
|
||||
float(row['neck']) if row.get('neck') else None,
|
||||
float(row['upper_arm']) if row.get('upper_arm') else None,
|
||||
float(row['thigh']) if row.get('thigh') else None,
|
||||
float(row['calf']) if row.get('calf') else None,
|
||||
row.get('note', ''),
|
||||
row.get('created', datetime.now())
|
||||
))
|
||||
if cur.rowcount > 0:
|
||||
stats['circumferences'] += 1
|
||||
|
||||
# 4. Import caliper.csv
|
||||
if 'data/caliper.csv' in zf.namelist():
|
||||
csv_data = zf.read('data/caliper.csv').decode('utf-8-sig')
|
||||
reader = csv.DictReader(io.StringIO(csv_data), delimiter=';')
|
||||
for row in reader:
|
||||
cur.execute("""
|
||||
INSERT INTO caliper_log (
|
||||
profile_id, date, sf_chest, sf_abdomen, sf_thigh,
|
||||
sf_triceps, sf_subscap, sf_suprailiac, sf_axilla,
|
||||
sf_method, body_fat_pct, notes, created
|
||||
)
|
||||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
|
||||
ON CONFLICT (profile_id, date) DO NOTHING
|
||||
""", (
|
||||
pid,
|
||||
row['date'],
|
||||
float(row['chest']) if row.get('chest') else None,
|
||||
float(row['abdomen']) if row.get('abdomen') else None,
|
||||
float(row['thigh']) if row.get('thigh') else None,
|
||||
float(row['tricep']) if row.get('tricep') else None,
|
||||
float(row['subscapular']) if row.get('subscapular') else None,
|
||||
float(row['suprailiac']) if row.get('suprailiac') else None,
|
||||
float(row['midaxillary']) if row.get('midaxillary') else None,
|
||||
row.get('method', 'jackson3'),
|
||||
float(row['bf_percent']) if row.get('bf_percent') else None,
|
||||
row.get('note', ''),
|
||||
row.get('created', datetime.now())
|
||||
))
|
||||
if cur.rowcount > 0:
|
||||
stats['caliper'] += 1
|
||||
|
||||
# 5. Import nutrition.csv
|
||||
if 'data/nutrition.csv' in zf.namelist():
|
||||
csv_data = zf.read('data/nutrition.csv').decode('utf-8-sig')
|
||||
reader = csv.DictReader(io.StringIO(csv_data), delimiter=';')
|
||||
for row in reader:
|
||||
cur.execute("""
|
||||
INSERT INTO nutrition_log (
|
||||
profile_id, date, kcal, protein_g, fat_g, carbs_g, source, created
|
||||
)
|
||||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
|
||||
ON CONFLICT (profile_id, date) DO NOTHING
|
||||
""", (
|
||||
pid,
|
||||
row['date'],
|
||||
float(row['kcal']) if row.get('kcal') else None,
|
||||
float(row['protein']) if row.get('protein') else None,
|
||||
float(row['fat']) if row.get('fat') else None,
|
||||
float(row['carbs']) if row.get('carbs') else None,
|
||||
row.get('source', 'import'),
|
||||
row.get('created', datetime.now())
|
||||
))
|
||||
if cur.rowcount > 0:
|
||||
stats['nutrition'] += 1
|
||||
|
||||
# 6. Import activity.csv
|
||||
if 'data/activity.csv' in zf.namelist():
|
||||
csv_data = zf.read('data/activity.csv').decode('utf-8-sig')
|
||||
reader = csv.DictReader(io.StringIO(csv_data), delimiter=';')
|
||||
for row in reader:
|
||||
cur.execute("""
|
||||
INSERT INTO activity_log (
|
||||
profile_id, date, activity_type, duration_min,
|
||||
kcal_active, hr_avg, hr_max, distance_km, notes, source, created
|
||||
)
|
||||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
|
||||
""", (
|
||||
pid,
|
||||
row['date'],
|
||||
row.get('type', 'Training'),
|
||||
float(row['duration_min']) if row.get('duration_min') else None,
|
||||
float(row['kcal']) if row.get('kcal') else None,
|
||||
float(row['heart_rate_avg']) if row.get('heart_rate_avg') else None,
|
||||
float(row['heart_rate_max']) if row.get('heart_rate_max') else None,
|
||||
float(row['distance_km']) if row.get('distance_km') else None,
|
||||
row.get('note', ''),
|
||||
row.get('source', 'import'),
|
||||
row.get('created', datetime.now())
|
||||
))
|
||||
if cur.rowcount > 0:
|
||||
stats['activity'] += 1
|
||||
|
||||
# 7. Import ai_insights.json
|
||||
if 'insights/ai_insights.json' in zf.namelist():
|
||||
insights_data = json.loads(zf.read('insights/ai_insights.json').decode('utf-8'))
|
||||
for insight in insights_data:
|
||||
cur.execute("""
|
||||
INSERT INTO ai_insights (profile_id, scope, content, created)
|
||||
VALUES (%s, %s, %s, %s)
|
||||
""", (
|
||||
pid,
|
||||
insight['scope'],
|
||||
insight['result'],
|
||||
insight.get('created', datetime.now())
|
||||
))
|
||||
stats['insights'] += 1
|
||||
|
||||
# 8. Import photos
|
||||
photo_files = [f for f in zf.namelist() if f.startswith('photos/') and not f.endswith('/')]
|
||||
for photo_file in photo_files:
|
||||
# Extract date from filename (format: YYYY-MM-DD_N.jpg)
|
||||
filename = Path(photo_file).name
|
||||
parts = filename.split('_')
|
||||
photo_date = parts[0] if len(parts) > 0 else datetime.now().strftime('%Y-%m-%d')
|
||||
|
||||
# Generate new ID and path
|
||||
photo_id = str(uuid.uuid4())
|
||||
ext = Path(filename).suffix
|
||||
new_filename = f"{photo_id}{ext}"
|
||||
target_path = PHOTOS_DIR / new_filename
|
||||
|
||||
# Check if photo already exists for this date
|
||||
cur.execute("""
|
||||
SELECT id FROM photos
|
||||
WHERE profile_id = %s AND date = %s
|
||||
""", (pid, photo_date))
|
||||
|
||||
if cur.fetchone() is None:
|
||||
# Write photo file
|
||||
with open(target_path, 'wb') as f:
|
||||
f.write(zf.read(photo_file))
|
||||
|
||||
# Insert DB record
|
||||
cur.execute("""
|
||||
INSERT INTO photos (id, profile_id, date, path, created)
|
||||
VALUES (%s, %s, %s, %s, %s)
|
||||
""", (photo_id, pid, photo_date, new_filename, datetime.now()))
|
||||
stats['photos'] += 1
|
||||
|
||||
# Commit transaction
|
||||
conn.commit()
|
||||
|
||||
except Exception as e:
|
||||
# Rollback on any error
|
||||
conn.rollback()
|
||||
raise HTTPException(500, f"Import fehlgeschlagen: {str(e)}")
|
||||
|
||||
return {
|
||||
"ok": True,
|
||||
"message": "Import erfolgreich",
|
||||
"stats": stats,
|
||||
"total": sum(stats.values())
|
||||
}
|
||||
|
||||
except zipfile.BadZipFile:
|
||||
raise HTTPException(400, "Ungültige ZIP-Datei")
|
||||
except Exception as e:
|
||||
raise HTTPException(500, f"Import-Fehler: {str(e)}")
|
||||
@@ -0,0 +1,460 @@
|
||||
"""
|
||||
AI Insights Endpoints for Mitai Jinkendo
|
||||
|
||||
Handles AI analysis execution, prompt management, and usage tracking.
|
||||
"""
|
||||
import os
|
||||
import json
|
||||
import uuid
|
||||
import httpx
|
||||
from typing import Optional
|
||||
from datetime import datetime
|
||||
|
||||
from fastapi import APIRouter, HTTPException, Header, Depends
|
||||
|
||||
from db import get_db, get_cursor, r2d
|
||||
from auth import require_auth, require_admin
|
||||
from routers.profiles import get_pid
|
||||
|
||||
router = APIRouter(prefix="/api", tags=["insights"])
|
||||
|
||||
OPENROUTER_KEY = os.getenv("OPENROUTER_API_KEY", "")
|
||||
OPENROUTER_MODEL = os.getenv("OPENROUTER_MODEL", "anthropic/claude-sonnet-4")
|
||||
ANTHROPIC_KEY = os.getenv("ANTHROPIC_API_KEY", "")
|
||||
|
||||
|
||||
# ── Helper Functions ──────────────────────────────────────────────────────────
|
||||
def check_ai_limit(pid: str):
|
||||
"""Check if profile has reached daily AI limit. Returns (allowed, limit, used)."""
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT ai_enabled, ai_limit_day FROM profiles WHERE id=%s", (pid,))
|
||||
prof = cur.fetchone()
|
||||
if not prof or not prof['ai_enabled']:
|
||||
raise HTTPException(403, "KI ist für dieses Profil deaktiviert")
|
||||
limit = prof['ai_limit_day']
|
||||
if limit is None:
|
||||
return (True, None, 0)
|
||||
today = datetime.now().date().isoformat()
|
||||
cur.execute("SELECT call_count FROM ai_usage WHERE profile_id=%s AND date=%s", (pid, today))
|
||||
usage = cur.fetchone()
|
||||
used = usage['call_count'] if usage else 0
|
||||
if used >= limit:
|
||||
raise HTTPException(429, f"Tägliches KI-Limit erreicht ({limit} Calls)")
|
||||
return (True, limit, used)
|
||||
|
||||
|
||||
def inc_ai_usage(pid: str):
|
||||
"""Increment AI usage counter for today."""
|
||||
today = datetime.now().date().isoformat()
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT id, call_count FROM ai_usage WHERE profile_id=%s AND date=%s", (pid, today))
|
||||
row = cur.fetchone()
|
||||
if row:
|
||||
cur.execute("UPDATE ai_usage SET call_count=%s WHERE id=%s", (row['call_count']+1, row['id']))
|
||||
else:
|
||||
cur.execute("INSERT INTO ai_usage (id, profile_id, date, call_count) VALUES (%s,%s,%s,1)",
|
||||
(str(uuid.uuid4()), pid, today))
|
||||
|
||||
|
||||
def _get_profile_data(pid: str):
|
||||
"""Fetch all relevant data for AI analysis."""
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT * FROM profiles WHERE id=%s", (pid,))
|
||||
prof = r2d(cur.fetchone())
|
||||
cur.execute("SELECT * FROM weight_log WHERE profile_id=%s ORDER BY date DESC LIMIT 90", (pid,))
|
||||
weight = [r2d(r) for r in cur.fetchall()]
|
||||
cur.execute("SELECT * FROM circumference_log WHERE profile_id=%s ORDER BY date DESC LIMIT 30", (pid,))
|
||||
circ = [r2d(r) for r in cur.fetchall()]
|
||||
cur.execute("SELECT * FROM caliper_log WHERE profile_id=%s ORDER BY date DESC LIMIT 30", (pid,))
|
||||
caliper = [r2d(r) for r in cur.fetchall()]
|
||||
cur.execute("SELECT * FROM nutrition_log WHERE profile_id=%s ORDER BY date DESC LIMIT 90", (pid,))
|
||||
nutrition = [r2d(r) for r in cur.fetchall()]
|
||||
cur.execute("SELECT * FROM activity_log WHERE profile_id=%s ORDER BY date DESC LIMIT 90", (pid,))
|
||||
activity = [r2d(r) for r in cur.fetchall()]
|
||||
return {
|
||||
"profile": prof,
|
||||
"weight": weight,
|
||||
"circumference": circ,
|
||||
"caliper": caliper,
|
||||
"nutrition": nutrition,
|
||||
"activity": activity
|
||||
}
|
||||
|
||||
|
||||
def _render_template(template: str, data: dict) -> str:
|
||||
"""Simple template variable replacement."""
|
||||
result = template
|
||||
for k, v in data.items():
|
||||
result = result.replace(f"{{{{{k}}}}}", str(v) if v is not None else "")
|
||||
return result
|
||||
|
||||
|
||||
def _prepare_template_vars(data: dict) -> dict:
|
||||
"""Prepare template variables from profile data."""
|
||||
prof = data['profile']
|
||||
weight = data['weight']
|
||||
circ = data['circumference']
|
||||
caliper = data['caliper']
|
||||
nutrition = data['nutrition']
|
||||
activity = data['activity']
|
||||
|
||||
vars = {
|
||||
"name": prof.get('name', 'Nutzer'),
|
||||
"geschlecht": "männlich" if prof.get('sex') == 'm' else "weiblich",
|
||||
"height": prof.get('height', 178),
|
||||
"goal_weight": float(prof.get('goal_weight')) if prof.get('goal_weight') else "nicht gesetzt",
|
||||
"goal_bf_pct": float(prof.get('goal_bf_pct')) if prof.get('goal_bf_pct') else "nicht gesetzt",
|
||||
"weight_aktuell": float(weight[0]['weight']) if weight else "keine Daten",
|
||||
"kf_aktuell": float(caliper[0]['body_fat_pct']) if caliper and caliper[0].get('body_fat_pct') else "unbekannt",
|
||||
}
|
||||
|
||||
# Calculate age from dob
|
||||
if prof.get('dob'):
|
||||
try:
|
||||
from datetime import date
|
||||
dob = datetime.strptime(prof['dob'], '%Y-%m-%d').date()
|
||||
today = date.today()
|
||||
age = today.year - dob.year - ((today.month, today.day) < (dob.month, dob.day))
|
||||
vars['age'] = age
|
||||
except:
|
||||
vars['age'] = "unbekannt"
|
||||
else:
|
||||
vars['age'] = "unbekannt"
|
||||
|
||||
# Weight trend summary
|
||||
if len(weight) >= 2:
|
||||
recent = weight[:30]
|
||||
delta = float(recent[0]['weight']) - float(recent[-1]['weight'])
|
||||
vars['weight_trend'] = f"{len(recent)} Einträge, Δ30d: {delta:+.1f}kg"
|
||||
else:
|
||||
vars['weight_trend'] = "zu wenig Daten"
|
||||
|
||||
# Caliper summary
|
||||
if caliper:
|
||||
c = caliper[0]
|
||||
bf = float(c.get('body_fat_pct')) if c.get('body_fat_pct') else '?'
|
||||
vars['caliper_summary'] = f"KF: {bf}%, Methode: {c.get('sf_method','?')}"
|
||||
else:
|
||||
vars['caliper_summary'] = "keine Daten"
|
||||
|
||||
# Circumference summary
|
||||
if circ:
|
||||
c = circ[0]
|
||||
parts = []
|
||||
for k in ['c_waist', 'c_belly', 'c_hip']:
|
||||
if c.get(k): parts.append(f"{k.split('_')[1]}: {float(c[k])}cm")
|
||||
vars['circ_summary'] = ", ".join(parts) if parts else "keine Daten"
|
||||
else:
|
||||
vars['circ_summary'] = "keine Daten"
|
||||
|
||||
# Nutrition summary
|
||||
if nutrition:
|
||||
n = len(nutrition)
|
||||
avg_kcal = sum(float(d.get('kcal',0) or 0) for d in nutrition) / n
|
||||
avg_prot = sum(float(d.get('protein_g',0) or 0) for d in nutrition) / n
|
||||
vars['nutrition_summary'] = f"{n} Tage, Ø {avg_kcal:.0f}kcal, {avg_prot:.0f}g Protein"
|
||||
vars['nutrition_detail'] = vars['nutrition_summary']
|
||||
vars['nutrition_days'] = n
|
||||
vars['kcal_avg'] = round(avg_kcal)
|
||||
vars['protein_avg'] = round(avg_prot,1)
|
||||
vars['fat_avg'] = round(sum(float(d.get('fat_g',0) or 0) for d in nutrition) / n,1)
|
||||
vars['carb_avg'] = round(sum(float(d.get('carbs_g',0) or 0) for d in nutrition) / n,1)
|
||||
else:
|
||||
vars['nutrition_summary'] = "keine Daten"
|
||||
vars['nutrition_detail'] = "keine Daten"
|
||||
vars['nutrition_days'] = 0
|
||||
vars['kcal_avg'] = 0
|
||||
vars['protein_avg'] = 0
|
||||
vars['fat_avg'] = 0
|
||||
vars['carb_avg'] = 0
|
||||
|
||||
# Protein targets
|
||||
w = weight[0]['weight'] if weight else prof.get('height',178) - 100
|
||||
w = float(w) # Convert Decimal to float for math operations
|
||||
vars['protein_ziel_low'] = round(w * 1.6)
|
||||
vars['protein_ziel_high'] = round(w * 2.2)
|
||||
|
||||
# Activity summary
|
||||
if activity:
|
||||
n = len(activity)
|
||||
total_kcal = sum(float(a.get('kcal_active',0) or 0) for a in activity)
|
||||
vars['activity_summary'] = f"{n} Trainings, {total_kcal:.0f}kcal gesamt"
|
||||
vars['activity_detail'] = vars['activity_summary']
|
||||
vars['activity_kcal_summary'] = f"Ø {total_kcal/n:.0f}kcal/Training"
|
||||
else:
|
||||
vars['activity_summary'] = "keine Daten"
|
||||
vars['activity_detail'] = "keine Daten"
|
||||
vars['activity_kcal_summary'] = "keine Daten"
|
||||
|
||||
return vars
|
||||
|
||||
|
||||
# ── Endpoints ─────────────────────────────────────────────────────────────────
|
||||
@router.get("/insights")
|
||||
def get_all_insights(x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Get all AI insights for profile."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT * FROM ai_insights WHERE profile_id=%s ORDER BY created DESC", (pid,))
|
||||
rows = cur.fetchall()
|
||||
return [r2d(r) for r in rows]
|
||||
|
||||
|
||||
@router.get("/insights/latest")
|
||||
def get_latest_insights(x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Get latest AI insights across all scopes."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT * FROM ai_insights WHERE profile_id=%s ORDER BY created DESC LIMIT 10", (pid,))
|
||||
rows = cur.fetchall()
|
||||
return [r2d(r) for r in rows]
|
||||
|
||||
|
||||
@router.get("/ai/insights/{scope}")
|
||||
def get_ai_insight(scope: str, x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Get latest insight for specific scope."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT * FROM ai_insights WHERE profile_id=%s AND scope=%s ORDER BY created DESC LIMIT 1", (pid,scope))
|
||||
row = cur.fetchone()
|
||||
if not row: return None
|
||||
return r2d(row)
|
||||
|
||||
|
||||
@router.delete("/insights/{insight_id}")
|
||||
def delete_insight_by_id(insight_id: str, x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Delete a specific insight by ID."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("DELETE FROM ai_insights WHERE id=%s AND profile_id=%s", (insight_id, pid))
|
||||
return {"ok":True}
|
||||
|
||||
|
||||
@router.delete("/ai/insights/{scope}")
|
||||
def delete_ai_insight(scope: str, x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Delete all insights for specific scope."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("DELETE FROM ai_insights WHERE profile_id=%s AND scope=%s", (pid,scope))
|
||||
return {"ok":True}
|
||||
|
||||
|
||||
@router.post("/insights/run/{slug}")
|
||||
async def analyze_with_prompt(slug: str, x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Run AI analysis with specified prompt template."""
|
||||
pid = get_pid(x_profile_id)
|
||||
check_ai_limit(pid)
|
||||
|
||||
# Get prompt template
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT * FROM ai_prompts WHERE slug=%s AND active=true", (slug,))
|
||||
prompt_row = cur.fetchone()
|
||||
if not prompt_row:
|
||||
raise HTTPException(404, f"Prompt '{slug}' nicht gefunden")
|
||||
|
||||
prompt_tmpl = prompt_row['template']
|
||||
data = _get_profile_data(pid)
|
||||
vars = _prepare_template_vars(data)
|
||||
final_prompt = _render_template(prompt_tmpl, vars)
|
||||
|
||||
# Call AI
|
||||
if ANTHROPIC_KEY:
|
||||
# Use Anthropic SDK
|
||||
import anthropic
|
||||
client = anthropic.Anthropic(api_key=ANTHROPIC_KEY)
|
||||
response = client.messages.create(
|
||||
model="claude-sonnet-4-20250514",
|
||||
max_tokens=2000,
|
||||
messages=[{"role": "user", "content": final_prompt}]
|
||||
)
|
||||
content = response.content[0].text
|
||||
elif OPENROUTER_KEY:
|
||||
async with httpx.AsyncClient() as client:
|
||||
resp = await client.post("https://openrouter.ai/api/v1/chat/completions",
|
||||
headers={"Authorization": f"Bearer {OPENROUTER_KEY}"},
|
||||
json={
|
||||
"model": OPENROUTER_MODEL,
|
||||
"messages": [{"role": "user", "content": final_prompt}],
|
||||
"max_tokens": 2000
|
||||
},
|
||||
timeout=60.0
|
||||
)
|
||||
if resp.status_code != 200:
|
||||
raise HTTPException(500, f"KI-Fehler: {resp.text}")
|
||||
content = resp.json()['choices'][0]['message']['content']
|
||||
else:
|
||||
raise HTTPException(500, "Keine KI-API konfiguriert")
|
||||
|
||||
# Save insight
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("DELETE FROM ai_insights WHERE profile_id=%s AND scope=%s", (pid, slug))
|
||||
cur.execute("INSERT INTO ai_insights (id, profile_id, scope, content, created) VALUES (%s,%s,%s,%s,CURRENT_TIMESTAMP)",
|
||||
(str(uuid.uuid4()), pid, slug, content))
|
||||
|
||||
inc_ai_usage(pid)
|
||||
return {"scope": slug, "content": content}
|
||||
|
||||
|
||||
@router.post("/insights/pipeline")
|
||||
async def analyze_pipeline(x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Run 3-stage pipeline analysis."""
|
||||
pid = get_pid(x_profile_id)
|
||||
check_ai_limit(pid)
|
||||
|
||||
data = _get_profile_data(pid)
|
||||
vars = _prepare_template_vars(data)
|
||||
|
||||
# Stage 1: Parallel JSON analyses
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT slug, template FROM ai_prompts WHERE slug LIKE 'pipeline_%' AND slug NOT IN ('pipeline_synthesis','pipeline_goals') AND active=true")
|
||||
stage1_prompts = [r2d(r) for r in cur.fetchall()]
|
||||
|
||||
stage1_results = {}
|
||||
for p in stage1_prompts:
|
||||
slug = p['slug']
|
||||
final_prompt = _render_template(p['template'], vars)
|
||||
|
||||
if ANTHROPIC_KEY:
|
||||
import anthropic
|
||||
client = anthropic.Anthropic(api_key=ANTHROPIC_KEY)
|
||||
response = client.messages.create(
|
||||
model="claude-sonnet-4-20250514",
|
||||
max_tokens=1000,
|
||||
messages=[{"role": "user", "content": final_prompt}]
|
||||
)
|
||||
content = response.content[0].text.strip()
|
||||
elif OPENROUTER_KEY:
|
||||
async with httpx.AsyncClient() as client:
|
||||
resp = await client.post("https://openrouter.ai/api/v1/chat/completions",
|
||||
headers={"Authorization": f"Bearer {OPENROUTER_KEY}"},
|
||||
json={
|
||||
"model": OPENROUTER_MODEL,
|
||||
"messages": [{"role": "user", "content": final_prompt}],
|
||||
"max_tokens": 1000
|
||||
},
|
||||
timeout=60.0
|
||||
)
|
||||
content = resp.json()['choices'][0]['message']['content'].strip()
|
||||
else:
|
||||
raise HTTPException(500, "Keine KI-API konfiguriert")
|
||||
|
||||
# Try to parse JSON, fallback to raw text
|
||||
try:
|
||||
stage1_results[slug] = json.loads(content)
|
||||
except:
|
||||
stage1_results[slug] = content
|
||||
|
||||
# Stage 2: Synthesis
|
||||
vars['stage1_body'] = json.dumps(stage1_results.get('pipeline_body', {}), ensure_ascii=False)
|
||||
vars['stage1_nutrition'] = json.dumps(stage1_results.get('pipeline_nutrition', {}), ensure_ascii=False)
|
||||
vars['stage1_activity'] = json.dumps(stage1_results.get('pipeline_activity', {}), ensure_ascii=False)
|
||||
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT template FROM ai_prompts WHERE slug='pipeline_synthesis' AND active=true")
|
||||
synth_row = cur.fetchone()
|
||||
if not synth_row:
|
||||
raise HTTPException(500, "Pipeline synthesis prompt not found")
|
||||
|
||||
synth_prompt = _render_template(synth_row['template'], vars)
|
||||
|
||||
if ANTHROPIC_KEY:
|
||||
import anthropic
|
||||
client = anthropic.Anthropic(api_key=ANTHROPIC_KEY)
|
||||
response = client.messages.create(
|
||||
model="claude-sonnet-4-20250514",
|
||||
max_tokens=2000,
|
||||
messages=[{"role": "user", "content": synth_prompt}]
|
||||
)
|
||||
synthesis = response.content[0].text
|
||||
elif OPENROUTER_KEY:
|
||||
async with httpx.AsyncClient() as client:
|
||||
resp = await client.post("https://openrouter.ai/api/v1/chat/completions",
|
||||
headers={"Authorization": f"Bearer {OPENROUTER_KEY}"},
|
||||
json={
|
||||
"model": OPENROUTER_MODEL,
|
||||
"messages": [{"role": "user", "content": synth_prompt}],
|
||||
"max_tokens": 2000
|
||||
},
|
||||
timeout=60.0
|
||||
)
|
||||
synthesis = resp.json()['choices'][0]['message']['content']
|
||||
else:
|
||||
raise HTTPException(500, "Keine KI-API konfiguriert")
|
||||
|
||||
# Stage 3: Goals (only if goals are set)
|
||||
goals_text = None
|
||||
prof = data['profile']
|
||||
if prof.get('goal_weight') or prof.get('goal_bf_pct'):
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT template FROM ai_prompts WHERE slug='pipeline_goals' AND active=true")
|
||||
goals_row = cur.fetchone()
|
||||
if goals_row:
|
||||
goals_prompt = _render_template(goals_row['template'], vars)
|
||||
|
||||
if ANTHROPIC_KEY:
|
||||
import anthropic
|
||||
client = anthropic.Anthropic(api_key=ANTHROPIC_KEY)
|
||||
response = client.messages.create(
|
||||
model="claude-sonnet-4-20250514",
|
||||
max_tokens=800,
|
||||
messages=[{"role": "user", "content": goals_prompt}]
|
||||
)
|
||||
goals_text = response.content[0].text
|
||||
elif OPENROUTER_KEY:
|
||||
async with httpx.AsyncClient() as client:
|
||||
resp = await client.post("https://openrouter.ai/api/v1/chat/completions",
|
||||
headers={"Authorization": f"Bearer {OPENROUTER_KEY}"},
|
||||
json={
|
||||
"model": OPENROUTER_MODEL,
|
||||
"messages": [{"role": "user", "content": goals_prompt}],
|
||||
"max_tokens": 800
|
||||
},
|
||||
timeout=60.0
|
||||
)
|
||||
goals_text = resp.json()['choices'][0]['message']['content']
|
||||
|
||||
# Combine synthesis + goals
|
||||
final_content = synthesis
|
||||
if goals_text:
|
||||
final_content += "\n\n" + goals_text
|
||||
|
||||
# Save as 'gesamt' scope
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("DELETE FROM ai_insights WHERE profile_id=%s AND scope='gesamt'", (pid,))
|
||||
cur.execute("INSERT INTO ai_insights (id, profile_id, scope, content, created) VALUES (%s,%s,'gesamt',%s,CURRENT_TIMESTAMP)",
|
||||
(str(uuid.uuid4()), pid, final_content))
|
||||
|
||||
inc_ai_usage(pid)
|
||||
return {"scope": "gesamt", "content": final_content, "stage1": stage1_results}
|
||||
|
||||
|
||||
@router.get("/ai/usage")
|
||||
def get_ai_usage(x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Get AI usage stats for current profile."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT ai_limit_day FROM profiles WHERE id=%s", (pid,))
|
||||
prof = cur.fetchone()
|
||||
limit = prof['ai_limit_day'] if prof else None
|
||||
|
||||
today = datetime.now().date().isoformat()
|
||||
cur.execute("SELECT call_count FROM ai_usage WHERE profile_id=%s AND date=%s", (pid, today))
|
||||
usage = cur.fetchone()
|
||||
used = usage['call_count'] if usage else 0
|
||||
|
||||
return {"limit": limit, "used": used, "remaining": (limit - used) if limit else None}
|
||||
@@ -0,0 +1,133 @@
|
||||
"""
|
||||
Nutrition Tracking Endpoints for Mitai Jinkendo
|
||||
|
||||
Handles nutrition data, FDDB CSV import, correlations, and weekly aggregates.
|
||||
"""
|
||||
import csv
|
||||
import io
|
||||
import uuid
|
||||
from typing import Optional
|
||||
from datetime import datetime
|
||||
|
||||
from fastapi import APIRouter, HTTPException, UploadFile, File, Header, Depends
|
||||
|
||||
from db import get_db, get_cursor, r2d
|
||||
from auth import require_auth
|
||||
from routers.profiles import get_pid
|
||||
|
||||
router = APIRouter(prefix="/api/nutrition", tags=["nutrition"])
|
||||
|
||||
|
||||
# ── Helper ────────────────────────────────────────────────────────────────────
|
||||
def _pf(s):
|
||||
"""Parse float from string (handles comma decimal separator)."""
|
||||
try: return float(str(s).replace(',','.').strip())
|
||||
except: return 0.0
|
||||
|
||||
|
||||
# ── Endpoints ─────────────────────────────────────────────────────────────────
|
||||
@router.post("/import-csv")
|
||||
async def import_nutrition_csv(file: UploadFile=File(...), x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Import FDDB nutrition CSV."""
|
||||
pid = get_pid(x_profile_id)
|
||||
raw = await file.read()
|
||||
try: text = raw.decode('utf-8')
|
||||
except: text = raw.decode('latin-1')
|
||||
if text.startswith('\ufeff'): text = text[1:]
|
||||
if not text.strip(): raise HTTPException(400,"Leere Datei")
|
||||
reader = csv.DictReader(io.StringIO(text), delimiter=';')
|
||||
days: dict = {}
|
||||
count = 0
|
||||
for row in reader:
|
||||
rd = row.get('datum_tag_monat_jahr_stunde_minute','').strip().strip('"')
|
||||
if not rd: continue
|
||||
try:
|
||||
p = rd.split(' ')[0].split('.')
|
||||
iso = f"{p[2]}-{p[1]}-{p[0]}"
|
||||
except: continue
|
||||
days.setdefault(iso,{'kcal':0,'fat_g':0,'carbs_g':0,'protein_g':0})
|
||||
days[iso]['kcal'] += _pf(row.get('kj',0))/4.184
|
||||
days[iso]['fat_g'] += _pf(row.get('fett_g',0))
|
||||
days[iso]['carbs_g'] += _pf(row.get('kh_g',0))
|
||||
days[iso]['protein_g'] += _pf(row.get('protein_g',0))
|
||||
count+=1
|
||||
inserted=0
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
for iso,vals in days.items():
|
||||
kcal=round(vals['kcal'],1); fat=round(vals['fat_g'],1)
|
||||
carbs=round(vals['carbs_g'],1); prot=round(vals['protein_g'],1)
|
||||
cur.execute("SELECT id FROM nutrition_log WHERE profile_id=%s AND date=%s",(pid,iso))
|
||||
if cur.fetchone():
|
||||
cur.execute("UPDATE nutrition_log SET kcal=%s,protein_g=%s,fat_g=%s,carbs_g=%s WHERE profile_id=%s AND date=%s",
|
||||
(kcal,prot,fat,carbs,pid,iso))
|
||||
else:
|
||||
cur.execute("INSERT INTO nutrition_log (id,profile_id,date,kcal,protein_g,fat_g,carbs_g,source,created) VALUES (%s,%s,%s,%s,%s,%s,%s,'csv',CURRENT_TIMESTAMP)",
|
||||
(str(uuid.uuid4()),pid,iso,kcal,prot,fat,carbs))
|
||||
inserted+=1
|
||||
return {"rows_parsed":count,"days_imported":inserted,
|
||||
"date_range":{"from":min(days) if days else None,"to":max(days) if days else None}}
|
||||
|
||||
|
||||
@router.get("")
|
||||
def list_nutrition(limit: int=365, x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Get nutrition entries for current profile."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute(
|
||||
"SELECT * FROM nutrition_log WHERE profile_id=%s ORDER BY date DESC LIMIT %s", (pid,limit))
|
||||
return [r2d(r) for r in cur.fetchall()]
|
||||
|
||||
|
||||
@router.get("/correlations")
|
||||
def nutrition_correlations(x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Get nutrition data correlated with weight and body fat."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT * FROM nutrition_log WHERE profile_id=%s ORDER BY date",(pid,))
|
||||
nutr={r['date']:r2d(r) for r in cur.fetchall()}
|
||||
cur.execute("SELECT date,weight FROM weight_log WHERE profile_id=%s ORDER BY date",(pid,))
|
||||
wlog={r['date']:r['weight'] for r in cur.fetchall()}
|
||||
cur.execute("SELECT date,lean_mass,body_fat_pct FROM caliper_log WHERE profile_id=%s ORDER BY date",(pid,))
|
||||
cals=sorted([r2d(r) for r in cur.fetchall()],key=lambda x:x['date'])
|
||||
all_dates=sorted(set(list(nutr)+list(wlog)))
|
||||
mi,last_cal,cal_by_date=0,{},{}
|
||||
for d in all_dates:
|
||||
while mi<len(cals) and cals[mi]['date']<=d: last_cal=cals[mi]; mi+=1
|
||||
if last_cal: cal_by_date[d]=last_cal
|
||||
result=[]
|
||||
for d in all_dates:
|
||||
if d not in nutr and d not in wlog: continue
|
||||
row={'date':d}
|
||||
if d in nutr: row.update({k:float(nutr[d][k]) if nutr[d][k] is not None else None for k in ['kcal','protein_g','fat_g','carbs_g']})
|
||||
if d in wlog: row['weight']=float(wlog[d])
|
||||
if d in cal_by_date:
|
||||
lm = cal_by_date[d].get('lean_mass')
|
||||
bf = cal_by_date[d].get('body_fat_pct')
|
||||
row['lean_mass']=float(lm) if lm is not None else None
|
||||
row['body_fat_pct']=float(bf) if bf is not None else None
|
||||
result.append(row)
|
||||
return result
|
||||
|
||||
|
||||
@router.get("/weekly")
|
||||
def nutrition_weekly(weeks: int=16, x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Get nutrition data aggregated by week."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT * FROM nutrition_log WHERE profile_id=%s ORDER BY date DESC LIMIT %s",(pid,weeks*7))
|
||||
rows=[r2d(r) for r in cur.fetchall()]
|
||||
if not rows: return []
|
||||
wm={}
|
||||
for d in rows:
|
||||
wk=datetime.strptime(d['date'],'%Y-%m-%d').strftime('%Y-W%V')
|
||||
wm.setdefault(wk,[]).append(d)
|
||||
result=[]
|
||||
for wk in sorted(wm):
|
||||
en=wm[wk]; n=len(en)
|
||||
def avg(k): return round(sum(float(e.get(k) or 0) for e in en)/n,1)
|
||||
result.append({'week':wk,'days':n,'kcal':avg('kcal'),'protein_g':avg('protein_g'),'fat_g':avg('fat_g'),'carbs_g':avg('carbs_g')})
|
||||
return result
|
||||
@@ -0,0 +1,63 @@
|
||||
"""
|
||||
Photo Management Endpoints for Mitai Jinkendo
|
||||
|
||||
Handles progress photo uploads and retrieval.
|
||||
"""
|
||||
import os
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
from typing import Optional
|
||||
|
||||
from fastapi import APIRouter, UploadFile, File, Header, HTTPException, Depends
|
||||
from fastapi.responses import FileResponse
|
||||
import aiofiles
|
||||
|
||||
from db import get_db, get_cursor, r2d
|
||||
from auth import require_auth, require_auth_flexible
|
||||
from routers.profiles import get_pid
|
||||
|
||||
router = APIRouter(prefix="/api/photos", tags=["photos"])
|
||||
|
||||
PHOTOS_DIR = Path(os.getenv("PHOTOS_DIR", "./photos"))
|
||||
PHOTOS_DIR.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
|
||||
@router.post("")
|
||||
async def upload_photo(file: UploadFile=File(...), date: str="",
|
||||
x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Upload progress photo."""
|
||||
pid = get_pid(x_profile_id)
|
||||
fid = str(uuid.uuid4())
|
||||
ext = Path(file.filename).suffix or '.jpg'
|
||||
path = PHOTOS_DIR / f"{fid}{ext}"
|
||||
async with aiofiles.open(path,'wb') as f: await f.write(await file.read())
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("INSERT INTO photos (id,profile_id,date,path,created) VALUES (%s,%s,%s,%s,CURRENT_TIMESTAMP)",
|
||||
(fid,pid,date,str(path)))
|
||||
return {"id":fid,"date":date}
|
||||
|
||||
|
||||
@router.get("/{fid}")
|
||||
def get_photo(fid: str, session: dict=Depends(require_auth_flexible)):
|
||||
"""Get photo by ID. Auth via header or query param (for <img> tags)."""
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT path FROM photos WHERE id=%s", (fid,))
|
||||
row = cur.fetchone()
|
||||
if not row: raise HTTPException(404, "Photo not found")
|
||||
photo_path = Path(PHOTOS_DIR) / row['path']
|
||||
if not photo_path.exists():
|
||||
raise HTTPException(404, "Photo file not found")
|
||||
return FileResponse(photo_path)
|
||||
|
||||
|
||||
@router.get("")
|
||||
def list_photos(x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Get all photos for current profile."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute(
|
||||
"SELECT * FROM photos WHERE profile_id=%s ORDER BY created DESC LIMIT 100", (pid,))
|
||||
return [r2d(r) for r in cur.fetchall()]
|
||||
@@ -0,0 +1,107 @@
|
||||
"""
|
||||
Profile Management Endpoints for Mitai Jinkendo
|
||||
|
||||
Handles profile CRUD operations for both admin and current user.
|
||||
"""
|
||||
import uuid
|
||||
from typing import Optional
|
||||
from datetime import datetime
|
||||
|
||||
from fastapi import APIRouter, HTTPException, Header, Depends
|
||||
|
||||
from db import get_db, get_cursor, r2d
|
||||
from auth import require_auth
|
||||
from models import ProfileCreate, ProfileUpdate
|
||||
|
||||
router = APIRouter(prefix="/api", tags=["profiles"])
|
||||
|
||||
|
||||
# ── Helper ────────────────────────────────────────────────────────────────────
|
||||
def get_pid(x_profile_id: Optional[str] = Header(default=None)) -> str:
|
||||
"""Get profile_id - from header for legacy endpoints."""
|
||||
if x_profile_id:
|
||||
return x_profile_id
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT id FROM profiles ORDER BY created LIMIT 1")
|
||||
row = cur.fetchone()
|
||||
if row: return row['id']
|
||||
raise HTTPException(400, "Kein Profil gefunden")
|
||||
|
||||
|
||||
# ── Admin Profile Management ──────────────────────────────────────────────────
|
||||
@router.get("/profiles")
|
||||
def list_profiles(session=Depends(require_auth)):
|
||||
"""List all profiles (admin)."""
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT * FROM profiles ORDER BY created")
|
||||
rows = cur.fetchall()
|
||||
return [r2d(r) for r in rows]
|
||||
|
||||
|
||||
@router.post("/profiles")
|
||||
def create_profile(p: ProfileCreate, session=Depends(require_auth)):
|
||||
"""Create new profile (admin)."""
|
||||
pid = str(uuid.uuid4())
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("""INSERT INTO profiles (id,name,avatar_color,sex,dob,height,goal_weight,goal_bf_pct,created,updated)
|
||||
VALUES (%s,%s,%s,%s,%s,%s,%s,%s,CURRENT_TIMESTAMP,CURRENT_TIMESTAMP)""",
|
||||
(pid,p.name,p.avatar_color,p.sex,p.dob,p.height,p.goal_weight,p.goal_bf_pct))
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT * FROM profiles WHERE id=%s", (pid,))
|
||||
return r2d(cur.fetchone())
|
||||
|
||||
|
||||
@router.get("/profiles/{pid}")
|
||||
def get_profile(pid: str, session=Depends(require_auth)):
|
||||
"""Get profile by ID."""
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT * FROM profiles WHERE id=%s", (pid,))
|
||||
row = cur.fetchone()
|
||||
if not row: raise HTTPException(404, "Profil nicht gefunden")
|
||||
return r2d(row)
|
||||
|
||||
|
||||
@router.put("/profiles/{pid}")
|
||||
def update_profile(pid: str, p: ProfileUpdate, session=Depends(require_auth)):
|
||||
"""Update profile by ID (admin)."""
|
||||
with get_db() as conn:
|
||||
data = {k:v for k,v in p.model_dump().items() if v is not None}
|
||||
data['updated'] = datetime.now().isoformat()
|
||||
cur = get_cursor(conn)
|
||||
cur.execute(f"UPDATE profiles SET {', '.join(f'{k}=%s' for k in data)} WHERE id=%s",
|
||||
list(data.values())+[pid])
|
||||
return get_profile(pid, session)
|
||||
|
||||
|
||||
@router.delete("/profiles/{pid}")
|
||||
def delete_profile(pid: str, session=Depends(require_auth)):
|
||||
"""Delete profile (admin)."""
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT COUNT(*) as count FROM profiles")
|
||||
count = cur.fetchone()['count']
|
||||
if count <= 1: raise HTTPException(400, "Letztes Profil kann nicht gelöscht werden")
|
||||
for table in ['weight_log','circumference_log','caliper_log','nutrition_log','activity_log','ai_insights']:
|
||||
cur.execute(f"DELETE FROM {table} WHERE profile_id=%s", (pid,))
|
||||
cur.execute("DELETE FROM profiles WHERE id=%s", (pid,))
|
||||
return {"ok": True}
|
||||
|
||||
|
||||
# ── Current User Profile ──────────────────────────────────────────────────────
|
||||
@router.get("/profile")
|
||||
def get_active_profile(x_profile_id: Optional[str] = Header(default=None), session: dict = Depends(require_auth)):
|
||||
"""Legacy endpoint – returns active profile."""
|
||||
pid = get_pid(x_profile_id)
|
||||
return get_profile(pid, session)
|
||||
|
||||
|
||||
@router.put("/profile")
|
||||
def update_active_profile(p: ProfileUpdate, x_profile_id: Optional[str] = Header(default=None), session: dict = Depends(require_auth)):
|
||||
"""Update current user's profile."""
|
||||
pid = get_pid(x_profile_id)
|
||||
return update_profile(pid, p, session)
|
||||
@@ -0,0 +1,60 @@
|
||||
"""
|
||||
AI Prompts Management Endpoints for Mitai Jinkendo
|
||||
|
||||
Handles prompt template configuration (admin-editable).
|
||||
"""
|
||||
from fastapi import APIRouter, Depends
|
||||
|
||||
from db import get_db, get_cursor, r2d
|
||||
from auth import require_auth, require_admin
|
||||
|
||||
router = APIRouter(prefix="/api/prompts", tags=["prompts"])
|
||||
|
||||
|
||||
@router.get("")
|
||||
def list_prompts(session: dict=Depends(require_auth)):
|
||||
"""
|
||||
List AI prompts.
|
||||
- Admins: see ALL prompts (including pipeline and inactive)
|
||||
- Users: see only active single-analysis prompts
|
||||
"""
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
is_admin = session.get('role') == 'admin'
|
||||
|
||||
if is_admin:
|
||||
# Admin sees everything
|
||||
cur.execute("SELECT * FROM ai_prompts ORDER BY sort_order, slug")
|
||||
else:
|
||||
# Users see only active, non-pipeline prompts
|
||||
cur.execute("SELECT * FROM ai_prompts WHERE active=true AND slug NOT LIKE 'pipeline_%' ORDER BY sort_order")
|
||||
|
||||
return [r2d(r) for r in cur.fetchall()]
|
||||
|
||||
|
||||
@router.put("/{prompt_id}")
|
||||
def update_prompt(prompt_id: str, data: dict, session: dict=Depends(require_admin)):
|
||||
"""Update AI prompt template (admin only)."""
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
updates = []
|
||||
values = []
|
||||
if 'name' in data:
|
||||
updates.append('name=%s')
|
||||
values.append(data['name'])
|
||||
if 'description' in data:
|
||||
updates.append('description=%s')
|
||||
values.append(data['description'])
|
||||
if 'template' in data:
|
||||
updates.append('template=%s')
|
||||
values.append(data['template'])
|
||||
if 'active' in data:
|
||||
updates.append('active=%s')
|
||||
# Convert to boolean (accepts true/false, 1/0)
|
||||
values.append(bool(data['active']))
|
||||
|
||||
if updates:
|
||||
cur.execute(f"UPDATE ai_prompts SET {', '.join(updates)}, updated=CURRENT_TIMESTAMP WHERE id=%s",
|
||||
values + [prompt_id])
|
||||
|
||||
return {"ok": True}
|
||||
@@ -0,0 +1,39 @@
|
||||
"""
|
||||
Statistics Endpoints for Mitai Jinkendo
|
||||
|
||||
Dashboard statistics showing entry counts across all categories.
|
||||
"""
|
||||
from typing import Optional
|
||||
|
||||
from fastapi import APIRouter, Header, Depends
|
||||
|
||||
from db import get_db, get_cursor
|
||||
from auth import require_auth
|
||||
from routers.profiles import get_pid
|
||||
|
||||
router = APIRouter(prefix="/api", tags=["stats"])
|
||||
|
||||
|
||||
@router.get("/stats")
|
||||
def get_stats(x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Get entry counts for all tracking categories."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT COUNT(*) as count FROM weight_log WHERE profile_id=%s",(pid,))
|
||||
weight_count = cur.fetchone()['count']
|
||||
cur.execute("SELECT COUNT(*) as count FROM circumference_log WHERE profile_id=%s",(pid,))
|
||||
circ_count = cur.fetchone()['count']
|
||||
cur.execute("SELECT COUNT(*) as count FROM caliper_log WHERE profile_id=%s",(pid,))
|
||||
caliper_count = cur.fetchone()['count']
|
||||
cur.execute("SELECT COUNT(*) as count FROM nutrition_log WHERE profile_id=%s",(pid,))
|
||||
nutrition_count = cur.fetchone()['count']
|
||||
cur.execute("SELECT COUNT(*) as count FROM activity_log WHERE profile_id=%s",(pid,))
|
||||
activity_count = cur.fetchone()['count']
|
||||
return {
|
||||
"weight_count": weight_count,
|
||||
"circ_count": circ_count,
|
||||
"caliper_count": caliper_count,
|
||||
"nutrition_count": nutrition_count,
|
||||
"activity_count": activity_count
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
"""
|
||||
Weight Tracking Endpoints for Mitai Jinkendo
|
||||
|
||||
Handles weight log CRUD operations and statistics.
|
||||
"""
|
||||
import uuid
|
||||
from typing import Optional
|
||||
|
||||
from fastapi import APIRouter, Header, Depends
|
||||
|
||||
from db import get_db, get_cursor, r2d
|
||||
from auth import require_auth
|
||||
from models import WeightEntry
|
||||
from routers.profiles import get_pid
|
||||
|
||||
router = APIRouter(prefix="/api/weight", tags=["weight"])
|
||||
|
||||
|
||||
@router.get("")
|
||||
def list_weight(limit: int=365, x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Get weight entries for current profile."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute(
|
||||
"SELECT * FROM weight_log WHERE profile_id=%s ORDER BY date DESC LIMIT %s", (pid,limit))
|
||||
return [r2d(r) for r in cur.fetchall()]
|
||||
|
||||
|
||||
@router.post("")
|
||||
def upsert_weight(e: WeightEntry, x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Create or update weight entry (upsert by date)."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT id FROM weight_log WHERE profile_id=%s AND date=%s", (pid,e.date))
|
||||
ex = cur.fetchone()
|
||||
if ex:
|
||||
cur.execute("UPDATE weight_log SET weight=%s,note=%s WHERE id=%s", (e.weight,e.note,ex['id']))
|
||||
wid = ex['id']
|
||||
else:
|
||||
wid = str(uuid.uuid4())
|
||||
cur.execute("INSERT INTO weight_log (id,profile_id,date,weight,note,created) VALUES (%s,%s,%s,%s,%s,CURRENT_TIMESTAMP)",
|
||||
(wid,pid,e.date,e.weight,e.note))
|
||||
return {"id":wid,"date":e.date,"weight":e.weight}
|
||||
|
||||
|
||||
@router.put("/{wid}")
|
||||
def update_weight(wid: str, e: WeightEntry, x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Update existing weight entry."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("UPDATE weight_log SET date=%s,weight=%s,note=%s WHERE id=%s AND profile_id=%s",
|
||||
(e.date,e.weight,e.note,wid,pid))
|
||||
return {"id":wid}
|
||||
|
||||
|
||||
@router.delete("/{wid}")
|
||||
def delete_weight(wid: str, x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Delete weight entry."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("DELETE FROM weight_log WHERE id=%s AND profile_id=%s", (wid,pid))
|
||||
return {"ok":True}
|
||||
|
||||
|
||||
@router.get("/stats")
|
||||
def weight_stats(x_profile_id: Optional[str]=Header(default=None), session: dict=Depends(require_auth)):
|
||||
"""Get weight statistics (last 90 days)."""
|
||||
pid = get_pid(x_profile_id)
|
||||
with get_db() as conn:
|
||||
cur = get_cursor(conn)
|
||||
cur.execute("SELECT date,weight FROM weight_log WHERE profile_id=%s ORDER BY date DESC LIMIT 90", (pid,))
|
||||
rows = cur.fetchall()
|
||||
if not rows: return {"count":0,"latest":None,"prev":None,"min":None,"max":None,"avg_7d":None}
|
||||
w=[float(r['weight']) for r in rows]
|
||||
return {"count":len(rows),"latest":{"date":rows[0]['date'],"weight":float(rows[0]['weight'])},
|
||||
"prev":{"date":rows[1]['date'],"weight":float(rows[1]['weight'])} if len(rows)>1 else None,
|
||||
"min":min(w),"max":max(w),"avg_7d":round(sum(w[:7])/min(7,len(w)),2)}
|
||||
@@ -0,0 +1,263 @@
|
||||
-- ================================================================
|
||||
-- MITAI JINKENDO v9b – PostgreSQL Schema
|
||||
-- ================================================================
|
||||
-- Migration from SQLite to PostgreSQL
|
||||
-- Includes v9b Tier System features
|
||||
-- ================================================================
|
||||
|
||||
-- Enable UUID Extension
|
||||
CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
|
||||
|
||||
-- ================================================================
|
||||
-- CORE TABLES
|
||||
-- ================================================================
|
||||
|
||||
-- ── Profiles Table ──────────────────────────────────────────────
|
||||
-- User/Profile management with auth and permissions
|
||||
CREATE TABLE IF NOT EXISTS profiles (
|
||||
id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
|
||||
name VARCHAR(255) NOT NULL DEFAULT 'Nutzer',
|
||||
avatar_color VARCHAR(7) DEFAULT '#1D9E75',
|
||||
photo_id UUID,
|
||||
sex VARCHAR(1) DEFAULT 'm' CHECK (sex IN ('m', 'w', 'd')),
|
||||
dob DATE,
|
||||
height NUMERIC(5,2) DEFAULT 178,
|
||||
goal_weight NUMERIC(5,2),
|
||||
goal_bf_pct NUMERIC(4,2),
|
||||
|
||||
-- Auth & Permissions
|
||||
role VARCHAR(20) DEFAULT 'user' CHECK (role IN ('user', 'admin')),
|
||||
pin_hash TEXT,
|
||||
auth_type VARCHAR(20) DEFAULT 'pin' CHECK (auth_type IN ('pin', 'email')),
|
||||
session_days INTEGER DEFAULT 30,
|
||||
ai_enabled BOOLEAN DEFAULT TRUE,
|
||||
ai_limit_day INTEGER,
|
||||
export_enabled BOOLEAN DEFAULT TRUE,
|
||||
email VARCHAR(255) UNIQUE,
|
||||
|
||||
-- v9b: Tier System
|
||||
tier VARCHAR(20) DEFAULT 'free' CHECK (tier IN ('free', 'basic', 'premium', 'selfhosted')),
|
||||
tier_expires_at TIMESTAMP WITH TIME ZONE,
|
||||
trial_ends_at TIMESTAMP WITH TIME ZONE,
|
||||
invited_by UUID REFERENCES profiles(id),
|
||||
|
||||
-- Timestamps
|
||||
created TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
|
||||
updated TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_profiles_email ON profiles(email) WHERE email IS NOT NULL;
|
||||
CREATE INDEX IF NOT EXISTS idx_profiles_tier ON profiles(tier);
|
||||
|
||||
-- ── Sessions Table ──────────────────────────────────────────────
|
||||
-- Auth token management
|
||||
CREATE TABLE IF NOT EXISTS sessions (
|
||||
token VARCHAR(64) PRIMARY KEY,
|
||||
profile_id UUID NOT NULL REFERENCES profiles(id) ON DELETE CASCADE,
|
||||
expires_at TIMESTAMP WITH TIME ZONE NOT NULL,
|
||||
created TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_sessions_profile_id ON sessions(profile_id);
|
||||
CREATE INDEX IF NOT EXISTS idx_sessions_expires_at ON sessions(expires_at);
|
||||
|
||||
-- ── AI Usage Tracking ───────────────────────────────────────────
|
||||
-- Daily AI call limits per profile
|
||||
CREATE TABLE IF NOT EXISTS ai_usage (
|
||||
id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
|
||||
profile_id UUID NOT NULL REFERENCES profiles(id) ON DELETE CASCADE,
|
||||
date DATE NOT NULL,
|
||||
call_count INTEGER DEFAULT 0,
|
||||
UNIQUE(profile_id, date)
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_ai_usage_profile_date ON ai_usage(profile_id, date);
|
||||
|
||||
-- ================================================================
|
||||
-- TRACKING TABLES
|
||||
-- ================================================================
|
||||
|
||||
-- ── Weight Log ──────────────────────────────────────────────────
|
||||
CREATE TABLE IF NOT EXISTS weight_log (
|
||||
id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
|
||||
profile_id UUID NOT NULL REFERENCES profiles(id) ON DELETE CASCADE,
|
||||
date DATE NOT NULL,
|
||||
weight NUMERIC(5,2) NOT NULL,
|
||||
note TEXT,
|
||||
source VARCHAR(20) DEFAULT 'manual',
|
||||
created TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_weight_log_profile_date ON weight_log(profile_id, date DESC);
|
||||
CREATE UNIQUE INDEX IF NOT EXISTS idx_weight_log_profile_date_unique ON weight_log(profile_id, date);
|
||||
|
||||
-- ── Circumference Log ───────────────────────────────────────────
|
||||
CREATE TABLE IF NOT EXISTS circumference_log (
|
||||
id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
|
||||
profile_id UUID NOT NULL REFERENCES profiles(id) ON DELETE CASCADE,
|
||||
date DATE NOT NULL,
|
||||
c_neck NUMERIC(5,2),
|
||||
c_chest NUMERIC(5,2),
|
||||
c_waist NUMERIC(5,2),
|
||||
c_belly NUMERIC(5,2),
|
||||
c_hip NUMERIC(5,2),
|
||||
c_thigh NUMERIC(5,2),
|
||||
c_calf NUMERIC(5,2),
|
||||
c_arm NUMERIC(5,2),
|
||||
notes TEXT,
|
||||
photo_id UUID,
|
||||
created TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_circumference_profile_date ON circumference_log(profile_id, date DESC);
|
||||
|
||||
-- ── Caliper Log ─────────────────────────────────────────────────
|
||||
CREATE TABLE IF NOT EXISTS caliper_log (
|
||||
id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
|
||||
profile_id UUID NOT NULL REFERENCES profiles(id) ON DELETE CASCADE,
|
||||
date DATE NOT NULL,
|
||||
sf_method VARCHAR(20) DEFAULT 'jackson3',
|
||||
sf_chest NUMERIC(5,2),
|
||||
sf_axilla NUMERIC(5,2),
|
||||
sf_triceps NUMERIC(5,2),
|
||||
sf_subscap NUMERIC(5,2),
|
||||
sf_suprailiac NUMERIC(5,2),
|
||||
sf_abdomen NUMERIC(5,2),
|
||||
sf_thigh NUMERIC(5,2),
|
||||
sf_calf_med NUMERIC(5,2),
|
||||
sf_lowerback NUMERIC(5,2),
|
||||
sf_biceps NUMERIC(5,2),
|
||||
body_fat_pct NUMERIC(4,2),
|
||||
lean_mass NUMERIC(5,2),
|
||||
fat_mass NUMERIC(5,2),
|
||||
notes TEXT,
|
||||
created TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_caliper_profile_date ON caliper_log(profile_id, date DESC);
|
||||
|
||||
-- ── Nutrition Log ───────────────────────────────────────────────
|
||||
CREATE TABLE IF NOT EXISTS nutrition_log (
|
||||
id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
|
||||
profile_id UUID NOT NULL REFERENCES profiles(id) ON DELETE CASCADE,
|
||||
date DATE NOT NULL,
|
||||
kcal NUMERIC(7,2),
|
||||
protein_g NUMERIC(6,2),
|
||||
fat_g NUMERIC(6,2),
|
||||
carbs_g NUMERIC(6,2),
|
||||
source VARCHAR(20) DEFAULT 'csv',
|
||||
created TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_nutrition_profile_date ON nutrition_log(profile_id, date DESC);
|
||||
|
||||
-- ── Activity Log ────────────────────────────────────────────────
|
||||
CREATE TABLE IF NOT EXISTS activity_log (
|
||||
id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
|
||||
profile_id UUID NOT NULL REFERENCES profiles(id) ON DELETE CASCADE,
|
||||
date DATE NOT NULL,
|
||||
start_time TIME,
|
||||
end_time TIME,
|
||||
activity_type VARCHAR(50) NOT NULL,
|
||||
duration_min NUMERIC(6,2),
|
||||
kcal_active NUMERIC(7,2),
|
||||
kcal_resting NUMERIC(7,2),
|
||||
hr_avg NUMERIC(5,2),
|
||||
hr_max NUMERIC(5,2),
|
||||
distance_km NUMERIC(7,2),
|
||||
rpe INTEGER CHECK (rpe >= 1 AND rpe <= 10),
|
||||
source VARCHAR(20) DEFAULT 'manual',
|
||||
notes TEXT,
|
||||
created TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_activity_profile_date ON activity_log(profile_id, date DESC);
|
||||
|
||||
-- ── Photos ──────────────────────────────────────────────────────
|
||||
CREATE TABLE IF NOT EXISTS photos (
|
||||
id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
|
||||
profile_id UUID NOT NULL REFERENCES profiles(id) ON DELETE CASCADE,
|
||||
meas_id UUID, -- Legacy: reference to measurement (circumference/caliper)
|
||||
date DATE,
|
||||
path TEXT NOT NULL,
|
||||
created TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_photos_profile_date ON photos(profile_id, date DESC);
|
||||
|
||||
-- ================================================================
|
||||
-- AI TABLES
|
||||
-- ================================================================
|
||||
|
||||
-- ── AI Insights ─────────────────────────────────────────────────
|
||||
CREATE TABLE IF NOT EXISTS ai_insights (
|
||||
id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
|
||||
profile_id UUID NOT NULL REFERENCES profiles(id) ON DELETE CASCADE,
|
||||
scope VARCHAR(50) NOT NULL,
|
||||
content TEXT NOT NULL,
|
||||
created TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_ai_insights_profile_scope ON ai_insights(profile_id, scope, created DESC);
|
||||
|
||||
-- ── AI Prompts ──────────────────────────────────────────────────
|
||||
CREATE TABLE IF NOT EXISTS ai_prompts (
|
||||
id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
|
||||
name VARCHAR(255) NOT NULL,
|
||||
slug VARCHAR(100) NOT NULL UNIQUE,
|
||||
description TEXT,
|
||||
template TEXT NOT NULL,
|
||||
active BOOLEAN DEFAULT TRUE,
|
||||
sort_order INTEGER DEFAULT 0,
|
||||
created TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
|
||||
updated TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_ai_prompts_slug ON ai_prompts(slug);
|
||||
CREATE INDEX IF NOT EXISTS idx_ai_prompts_active_sort ON ai_prompts(active, sort_order);
|
||||
|
||||
-- ================================================================
|
||||
-- TRIGGERS
|
||||
-- ================================================================
|
||||
|
||||
-- Auto-update timestamp trigger for profiles
|
||||
CREATE OR REPLACE FUNCTION update_updated_timestamp()
|
||||
RETURNS TRIGGER AS $$
|
||||
BEGIN
|
||||
NEW.updated = CURRENT_TIMESTAMP;
|
||||
RETURN NEW;
|
||||
END;
|
||||
$$ LANGUAGE plpgsql;
|
||||
|
||||
DROP TRIGGER IF EXISTS trigger_profiles_updated ON profiles;
|
||||
CREATE TRIGGER trigger_profiles_updated
|
||||
BEFORE UPDATE ON profiles
|
||||
FOR EACH ROW
|
||||
EXECUTE FUNCTION update_updated_timestamp();
|
||||
|
||||
DROP TRIGGER IF EXISTS trigger_ai_prompts_updated ON ai_prompts;
|
||||
CREATE TRIGGER trigger_ai_prompts_updated
|
||||
BEFORE UPDATE ON ai_prompts
|
||||
FOR EACH ROW
|
||||
EXECUTE FUNCTION update_updated_timestamp();
|
||||
|
||||
-- ================================================================
|
||||
-- COMMENTS (Documentation)
|
||||
-- ================================================================
|
||||
|
||||
COMMENT ON TABLE profiles IS 'User profiles with auth, permissions, and tier system';
|
||||
COMMENT ON TABLE sessions IS 'Active auth tokens';
|
||||
COMMENT ON TABLE ai_usage IS 'Daily AI call tracking per profile';
|
||||
COMMENT ON TABLE weight_log IS 'Weight measurements';
|
||||
COMMENT ON TABLE circumference_log IS 'Body circumference measurements (8 points)';
|
||||
COMMENT ON TABLE caliper_log IS 'Skinfold measurements with body fat calculations';
|
||||
COMMENT ON TABLE nutrition_log IS 'Daily nutrition intake (calories + macros)';
|
||||
COMMENT ON TABLE activity_log IS 'Training sessions and activities';
|
||||
COMMENT ON TABLE photos IS 'Progress photos';
|
||||
COMMENT ON TABLE ai_insights IS 'AI-generated analysis results';
|
||||
COMMENT ON TABLE ai_prompts IS 'Configurable AI prompt templates';
|
||||
|
||||
COMMENT ON COLUMN profiles.tier IS 'Subscription tier: free, basic, premium, selfhosted';
|
||||
COMMENT ON COLUMN profiles.trial_ends_at IS 'Trial expiration timestamp (14 days from registration)';
|
||||
COMMENT ON COLUMN profiles.tier_expires_at IS 'Paid tier expiration timestamp';
|
||||
COMMENT ON COLUMN profiles.invited_by IS 'Profile ID of inviter (for beta invitations)';
|
||||
@@ -0,0 +1,19 @@
|
||||
#!/bin/bash
|
||||
set -e
|
||||
|
||||
# Run database initialization with Python (no psql needed!)
|
||||
python /app/db_init.py
|
||||
|
||||
if [ $? -ne 0 ]; then
|
||||
echo "✗ Database initialization failed"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# ── Start Application ──────────────────────────────────────────
|
||||
echo ""
|
||||
echo "═══════════════════════════════════════════════════════════"
|
||||
echo "Starting FastAPI application..."
|
||||
echo "═══════════════════════════════════════════════════════════"
|
||||
echo ""
|
||||
|
||||
exec uvicorn main:app --host 0.0.0.0 --port 8000
|
||||
@@ -0,0 +1,72 @@
|
||||
services:
|
||||
postgres-dev:
|
||||
image: postgres:16-alpine
|
||||
container_name: dev-mitai-postgres
|
||||
restart: unless-stopped
|
||||
environment:
|
||||
POSTGRES_DB: mitai_dev
|
||||
POSTGRES_USER: mitai_dev
|
||||
POSTGRES_PASSWORD: dev_password_change_me
|
||||
volumes:
|
||||
- mitai_dev_postgres_data:/var/lib/postgresql/data
|
||||
ports:
|
||||
- "127.0.0.1:5433:5432"
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U mitai_dev"]
|
||||
interval: 10s
|
||||
timeout: 5s
|
||||
retries: 5
|
||||
|
||||
backend:
|
||||
build: ./backend
|
||||
container_name: dev-mitai-api
|
||||
restart: unless-stopped
|
||||
ports:
|
||||
- "8099:8000"
|
||||
depends_on:
|
||||
postgres-dev:
|
||||
condition: service_healthy
|
||||
volumes:
|
||||
- bodytrack_bodytrack-data:/app/data
|
||||
- bodytrack_bodytrack-photos:/app/photos
|
||||
environment:
|
||||
# Database
|
||||
- DB_HOST=postgres-dev
|
||||
- DB_PORT=5432
|
||||
- DB_NAME=mitai_dev
|
||||
- DB_USER=mitai_dev
|
||||
- DB_PASSWORD=dev_password_change_me
|
||||
|
||||
# AI
|
||||
- OPENROUTER_API_KEY=${OPENROUTER_API_KEY}
|
||||
- OPENROUTER_MODEL=${OPENROUTER_MODEL:-anthropic/claude-sonnet-4}
|
||||
- ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
|
||||
|
||||
# Email
|
||||
- SMTP_HOST=${SMTP_HOST}
|
||||
- SMTP_PORT=${SMTP_PORT:-587}
|
||||
- SMTP_USER=${SMTP_USER}
|
||||
- SMTP_PASS=${SMTP_PASS}
|
||||
- SMTP_FROM=${SMTP_FROM}
|
||||
|
||||
# App
|
||||
- APP_URL=${APP_URL_DEV:-https://dev.mitai.jinkendo.de}
|
||||
- PHOTOS_DIR=/app/photos
|
||||
- ALLOWED_ORIGINS=${ALLOWED_ORIGINS_DEV:-*}
|
||||
- ENVIRONMENT=development
|
||||
|
||||
frontend:
|
||||
build: ./frontend
|
||||
container_name: dev-mitai-ui
|
||||
restart: unless-stopped
|
||||
ports:
|
||||
- "3099:80"
|
||||
depends_on:
|
||||
- backend
|
||||
|
||||
volumes:
|
||||
mitai_dev_postgres_data:
|
||||
bodytrack_bodytrack-data:
|
||||
external: true
|
||||
bodytrack_bodytrack-photos:
|
||||
external: true
|
||||
@@ -1,22 +1,53 @@
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16-alpine
|
||||
container_name: mitai-db-prod
|
||||
restart: unless-stopped
|
||||
environment:
|
||||
POSTGRES_DB: mitai_prod
|
||||
POSTGRES_USER: mitai_prod
|
||||
POSTGRES_PASSWORD: ${DB_PASSWORD:-change_me_in_production}
|
||||
volumes:
|
||||
- mitai_postgres_data:/var/lib/postgresql/data
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U mitai_prod"]
|
||||
interval: 10s
|
||||
timeout: 5s
|
||||
retries: 5
|
||||
|
||||
backend:
|
||||
build: ./backend
|
||||
container_name: mitai-api
|
||||
restart: unless-stopped
|
||||
ports:
|
||||
- "8002:8000"
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
volumes:
|
||||
- bodytrack_bodytrack-data:/app/data
|
||||
- bodytrack_bodytrack-photos:/app/photos
|
||||
environment:
|
||||
# Database
|
||||
- DB_HOST=postgres
|
||||
- DB_PORT=5432
|
||||
- DB_NAME=mitai_prod
|
||||
- DB_USER=mitai_prod
|
||||
- DB_PASSWORD=${DB_PASSWORD:-change_me_in_production}
|
||||
|
||||
# AI
|
||||
- OPENROUTER_API_KEY=${OPENROUTER_API_KEY}
|
||||
- OPENROUTER_MODEL=${OPENROUTER_MODEL:-anthropic/claude-sonnet-4}
|
||||
- ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
|
||||
|
||||
# Email
|
||||
- SMTP_HOST=${SMTP_HOST}
|
||||
- SMTP_PORT=${SMTP_PORT:-587}
|
||||
- SMTP_USER=${SMTP_USER}
|
||||
- SMTP_PASS=${SMTP_PASS}
|
||||
- SMTP_FROM=${SMTP_FROM}
|
||||
|
||||
# App
|
||||
- APP_URL=${APP_URL}
|
||||
- DATA_DIR=/app/data
|
||||
- PHOTOS_DIR=/app/photos
|
||||
@@ -33,6 +64,7 @@ services:
|
||||
- backend
|
||||
|
||||
volumes:
|
||||
mitai_postgres_data:
|
||||
bodytrack_bodytrack-data:
|
||||
external: true
|
||||
bodytrack_bodytrack-photos:
|
||||
|
||||
@@ -150,8 +150,11 @@ export default function Analysis() {
|
||||
}
|
||||
|
||||
const savePrompt = async (promptId, data) => {
|
||||
const token = localStorage.getItem('bodytrack_token')||''
|
||||
await fetch(`/api/prompts/${promptId}`, {
|
||||
method:'PUT', headers:{'Content-Type':'application/json'}, body:JSON.stringify(data)
|
||||
method:'PUT',
|
||||
headers:{'Content-Type':'application/json', 'X-Auth-Token': token},
|
||||
body:JSON.stringify(data)
|
||||
})
|
||||
setEditing(null); await loadAll()
|
||||
}
|
||||
@@ -176,6 +179,10 @@ export default function Analysis() {
|
||||
|
||||
const activePrompts = prompts.filter(p=>p.active && !p.slug.startsWith('pipeline_'))
|
||||
|
||||
// Pipeline is available if the "pipeline" prompt is active
|
||||
const pipelinePrompt = prompts.find(p=>p.slug==='pipeline')
|
||||
const pipelineAvailable = pipelinePrompt?.active ?? true // Default to true if not found (backwards compatibility)
|
||||
|
||||
return (
|
||||
<div>
|
||||
<h1 className="page-title">KI-Analyse</h1>
|
||||
@@ -218,36 +225,38 @@ export default function Analysis() {
|
||||
</div>
|
||||
)}
|
||||
|
||||
{/* Pipeline button */}
|
||||
<div className="card" style={{marginBottom:16,borderColor:'var(--accent)',borderWidth:2}}>
|
||||
<div style={{display:'flex',alignItems:'flex-start',gap:12}}>
|
||||
<div style={{flex:1}}>
|
||||
<div style={{fontWeight:700,fontSize:15,color:'var(--accent)'}}>🔬 Mehrstufige Gesamtanalyse</div>
|
||||
<div style={{fontSize:12,color:'var(--text2)',marginTop:3,lineHeight:1.5}}>
|
||||
3 spezialisierte KI-Calls parallel (Körper + Ernährung + Aktivität),
|
||||
dann Synthese + Zielabgleich. Detaillierteste Auswertung.
|
||||
</div>
|
||||
{allInsights.find(i=>i.scope==='pipeline') && (
|
||||
<div style={{fontSize:11,color:'var(--text3)',marginTop:3}}>
|
||||
Letzte Analyse: {dayjs(allInsights.find(i=>i.scope==='pipeline').created).format('DD.MM.YYYY, HH:mm')}
|
||||
{/* Pipeline button - only if all sub-prompts are active */}
|
||||
{pipelineAvailable && (
|
||||
<div className="card" style={{marginBottom:16,borderColor:'var(--accent)',borderWidth:2}}>
|
||||
<div style={{display:'flex',alignItems:'flex-start',gap:12}}>
|
||||
<div style={{flex:1}}>
|
||||
<div style={{fontWeight:700,fontSize:15,color:'var(--accent)'}}>🔬 Mehrstufige Gesamtanalyse</div>
|
||||
<div style={{fontSize:12,color:'var(--text2)',marginTop:3,lineHeight:1.5}}>
|
||||
3 spezialisierte KI-Calls parallel (Körper + Ernährung + Aktivität),
|
||||
dann Synthese + Zielabgleich. Detaillierteste Auswertung.
|
||||
</div>
|
||||
)}
|
||||
{allInsights.find(i=>i.scope==='pipeline') && (
|
||||
<div style={{fontSize:11,color:'var(--text3)',marginTop:3}}>
|
||||
Letzte Analyse: {dayjs(allInsights.find(i=>i.scope==='pipeline').created).format('DD.MM.YYYY, HH:mm')}
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
<button className="btn btn-primary" style={{flexShrink:0,minWidth:100}}
|
||||
onClick={runPipeline} disabled={!!loading||pipelineLoading}>
|
||||
{pipelineLoading
|
||||
? <><div className="spinner" style={{width:13,height:13}}/> Läuft…</>
|
||||
: <><Brain size={13}/> Starten</>}
|
||||
</button>
|
||||
{!canUseAI && <div style={{fontSize:11,color:'#D85A30',marginTop:4}}>🔒 KI nicht freigeschaltet</div>}
|
||||
</div>
|
||||
<button className="btn btn-primary" style={{flexShrink:0,minWidth:100}}
|
||||
onClick={runPipeline} disabled={!!loading||pipelineLoading}>
|
||||
{pipelineLoading
|
||||
? <><div className="spinner" style={{width:13,height:13}}/> Läuft…</>
|
||||
: <><Brain size={13}/> Starten</>}
|
||||
</button>
|
||||
{!canUseAI && <div style={{fontSize:11,color:'#D85A30',marginTop:4}}>🔒 KI nicht freigeschaltet</div>}
|
||||
{pipelineLoading && (
|
||||
<div style={{marginTop:10,padding:'8px 12px',background:'var(--accent-light)',
|
||||
borderRadius:8,fontSize:12,color:'var(--accent-dark)'}}>
|
||||
⚡ Stufe 1: 3 parallele Analyse-Calls… dann Synthese… dann Zielabgleich
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
{pipelineLoading && (
|
||||
<div style={{marginTop:10,padding:'8px 12px',background:'var(--accent-light)',
|
||||
borderRadius:8,fontSize:12,color:'var(--accent-dark)'}}>
|
||||
⚡ Stufe 1: 3 parallele Analyse-Calls… dann Synthese… dann Zielabgleich
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
)}
|
||||
|
||||
{!canUseAI && (
|
||||
<div style={{padding:'14px 16px',background:'#FCEBEB',borderRadius:10,
|
||||
@@ -345,21 +354,26 @@ export default function Analysis() {
|
||||
Einzelanalysen
|
||||
</div>
|
||||
{singlePrompts.map(p=>(
|
||||
<div key={p.id} className="card section-gap">
|
||||
<div key={p.id} className="card section-gap" style={{opacity:p.active?1:0.6}}>
|
||||
<div style={{display:'flex',alignItems:'center',gap:10}}>
|
||||
<div style={{flex:1}}>
|
||||
<div style={{fontWeight:600,fontSize:14,display:'flex',alignItems:'center',gap:8}}>
|
||||
{SLUG_LABELS[p.slug]||p.name}
|
||||
{!p.active && <span style={{fontSize:10,color:'var(--text3)',
|
||||
background:'var(--surface2)',padding:'1px 6px',borderRadius:4}}>Inaktiv</span>}
|
||||
{!p.active && <span style={{fontSize:10,color:'#D85A30',
|
||||
background:'#FCEBEB',padding:'2px 8px',borderRadius:4,fontWeight:600}}>⏸ Deaktiviert</span>}
|
||||
</div>
|
||||
{p.description && <div style={{fontSize:12,color:'var(--text3)',marginTop:1}}>{p.description}</div>}
|
||||
</div>
|
||||
<button className="btn btn-secondary" style={{padding:'5px 8px',fontSize:12}}
|
||||
onClick={()=>fetch(`/api/prompts/${p.id}`,{method:'PUT',
|
||||
headers:{'Content-Type':'application/json'},
|
||||
body:JSON.stringify({active:p.active?0:1})}).then(loadAll)}>
|
||||
{p.active?'Deaktiv.':'Aktiv.'}
|
||||
onClick={()=>{
|
||||
const token = localStorage.getItem('bodytrack_token')||''
|
||||
fetch(`/api/prompts/${p.id}`,{
|
||||
method:'PUT',
|
||||
headers:{'Content-Type':'application/json','X-Auth-Token':token},
|
||||
body:JSON.stringify({active:!p.active})
|
||||
}).then(loadAll)
|
||||
}}>
|
||||
{p.active?'Deaktivieren':'Aktivieren'}
|
||||
</button>
|
||||
<button className="btn btn-secondary" style={{padding:'5px 8px'}}
|
||||
onClick={()=>setEditing(p)}><Pencil size={13}/></button>
|
||||
@@ -372,26 +386,60 @@ export default function Analysis() {
|
||||
))}
|
||||
|
||||
{/* Pipeline prompts */}
|
||||
<div style={{fontSize:12,fontWeight:700,color:'var(--text3)',
|
||||
textTransform:'uppercase',letterSpacing:'0.05em',margin:'20px 0 8px'}}>
|
||||
Mehrstufige Pipeline
|
||||
</div>
|
||||
<div style={{padding:'10px 12px',background:'var(--warn-bg)',borderRadius:8,
|
||||
fontSize:12,color:'var(--warn-text)',marginBottom:12,lineHeight:1.6}}>
|
||||
⚠️ <strong>Hinweis:</strong> Pipeline-Stage-1-Prompts müssen valides JSON zurückgeben.
|
||||
Halte das JSON-Format im Prompt erhalten. Stage 2 + 3 können frei angepasst werden.
|
||||
<div style={{display:'flex',alignItems:'center',justifyContent:'space-between',margin:'20px 0 8px'}}>
|
||||
<div style={{fontSize:12,fontWeight:700,color:'var(--text3)',
|
||||
textTransform:'uppercase',letterSpacing:'0.05em'}}>
|
||||
Mehrstufige Pipeline
|
||||
</div>
|
||||
{(() => {
|
||||
const pipelinePrompt = prompts.find(p=>p.slug==='pipeline')
|
||||
return pipelinePrompt && (
|
||||
<button className="btn btn-secondary" style={{padding:'5px 12px',fontSize:12}}
|
||||
onClick={()=>{
|
||||
const token = localStorage.getItem('bodytrack_token')||''
|
||||
fetch(`/api/prompts/${pipelinePrompt.id}`,{
|
||||
method:'PUT',
|
||||
headers:{'Content-Type':'application/json','X-Auth-Token':token},
|
||||
body:JSON.stringify({active:!pipelinePrompt.active})
|
||||
}).then(loadAll)
|
||||
}}>
|
||||
{pipelinePrompt.active ? 'Gesamte Pipeline deaktivieren' : 'Gesamte Pipeline aktivieren'}
|
||||
</button>
|
||||
)
|
||||
})()}
|
||||
</div>
|
||||
{(() => {
|
||||
const pipelinePrompt = prompts.find(p=>p.slug==='pipeline')
|
||||
const isPipelineActive = pipelinePrompt?.active ?? true
|
||||
return (
|
||||
<div style={{padding:'10px 12px',
|
||||
background: isPipelineActive ? 'var(--warn-bg)' : '#FCEBEB',
|
||||
borderRadius:8,fontSize:12,
|
||||
color: isPipelineActive ? 'var(--warn-text)' : '#D85A30',
|
||||
marginBottom:12,lineHeight:1.6}}>
|
||||
{isPipelineActive ? (
|
||||
<>⚠️ <strong>Hinweis:</strong> Pipeline-Stage-1-Prompts müssen valides JSON zurückgeben.
|
||||
Halte das JSON-Format im Prompt erhalten. Stage 2 + 3 können frei angepasst werden.</>
|
||||
) : (
|
||||
<>⏸ <strong>Pipeline deaktiviert:</strong> Die mehrstufige Gesamtanalyse ist aktuell nicht verfügbar.
|
||||
Aktiviere sie mit dem Schalter oben, um sie auf der Analyse-Seite zu nutzen.</>
|
||||
)}
|
||||
</div>
|
||||
)
|
||||
})()}
|
||||
{pipelinePrompts.map(p=>{
|
||||
const isJson = jsonSlugs.includes(p.slug)
|
||||
return (
|
||||
<div key={p.id} className="card section-gap"
|
||||
style={{borderLeft:`3px solid ${isJson?'var(--warn)':'var(--accent)'}`}}>
|
||||
style={{borderLeft:`3px solid ${isJson?'var(--warn)':'var(--accent)'}`,opacity:p.active?1:0.6}}>
|
||||
<div style={{display:'flex',alignItems:'center',gap:10}}>
|
||||
<div style={{flex:1}}>
|
||||
<div style={{fontWeight:600,fontSize:14,display:'flex',alignItems:'center',gap:8}}>
|
||||
{p.name}
|
||||
{isJson && <span style={{fontSize:10,background:'var(--warn-bg)',
|
||||
color:'var(--warn-text)',padding:'1px 6px',borderRadius:4}}>JSON-Output</span>}
|
||||
{!p.active && <span style={{fontSize:10,color:'#D85A30',
|
||||
background:'#FCEBEB',padding:'2px 8px',borderRadius:4,fontWeight:600}}>⏸ Deaktiviert</span>}
|
||||
</div>
|
||||
{p.description && <div style={{fontSize:12,color:'var(--text3)',marginTop:1}}>{p.description}</div>}
|
||||
</div>
|
||||
|
||||
@@ -147,7 +147,7 @@ function PeriodSelector({ value, onChange }) {
|
||||
}
|
||||
|
||||
// ── Body Section (Weight + Composition combined) ──────────────────────────────
|
||||
function BodySection({ weights, calipers, circs, profile, insights, onRequest, loadingSlug }) {
|
||||
function BodySection({ weights, calipers, circs, profile, insights, onRequest, loadingSlug, filterActiveSlugs }) {
|
||||
const [period, setPeriod] = useState(90)
|
||||
const sex = profile?.sex||'m'
|
||||
const height = profile?.height||178
|
||||
@@ -394,14 +394,14 @@ function BodySection({ weights, calipers, circs, profile, insights, onRequest, l
|
||||
</div>
|
||||
)}
|
||||
|
||||
<InsightBox insights={insights} slugs={['pipeline','koerper','gesundheit','ziele']}
|
||||
<InsightBox insights={insights} slugs={filterActiveSlugs(['pipeline','koerper','gesundheit','ziele'])}
|
||||
onRequest={onRequest} loading={loadingSlug}/>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
// ── Nutrition Section ─────────────────────────────────────────────────────────
|
||||
function NutritionSection({ nutrition, weights, profile, insights, onRequest, loadingSlug }) {
|
||||
function NutritionSection({ nutrition, weights, profile, insights, onRequest, loadingSlug, filterActiveSlugs }) {
|
||||
const [period, setPeriod] = useState(30)
|
||||
if (!nutrition?.length) return (
|
||||
<EmptySection text="Noch keine Ernährungsdaten." to="/nutrition" toLabel="FDDB importieren"/>
|
||||
@@ -579,13 +579,13 @@ function NutritionSection({ nutrition, weights, profile, insights, onRequest, lo
|
||||
<div style={{fontSize:12,fontWeight:600,color:'var(--text3)',marginBottom:8}}>BEWERTUNG</div>
|
||||
{macroRules.map((item,i)=><RuleCard key={i} item={item}/>)}
|
||||
</div>
|
||||
<InsightBox insights={insights} slugs={['ernaehrung']} onRequest={onRequest} loading={loadingSlug}/>
|
||||
<InsightBox insights={insights} slugs={filterActiveSlugs(['ernaehrung'])} onRequest={onRequest} loading={loadingSlug}/>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
// ── Activity Section ──────────────────────────────────────────────────────────
|
||||
function ActivitySection({ activities, insights, onRequest, loadingSlug }) {
|
||||
function ActivitySection({ activities, insights, onRequest, loadingSlug, filterActiveSlugs }) {
|
||||
const [period, setPeriod] = useState(30)
|
||||
if (!activities?.length) return (
|
||||
<EmptySection text="Noch keine Aktivitätsdaten." to="/activity" toLabel="Aktivität erfassen"/>
|
||||
@@ -657,13 +657,13 @@ function ActivitySection({ activities, insights, onRequest, loadingSlug }) {
|
||||
<div style={{fontSize:12,fontWeight:600,color:'var(--text3)',marginBottom:8}}>BEWERTUNG</div>
|
||||
{actRules.map((item,i)=><RuleCard key={i} item={item}/>)}
|
||||
</div>
|
||||
<InsightBox insights={insights} slugs={['aktivitaet']} onRequest={onRequest} loading={loadingSlug}/>
|
||||
<InsightBox insights={insights} slugs={filterActiveSlugs(['aktivitaet'])} onRequest={onRequest} loading={loadingSlug}/>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
// ── Correlation Section ───────────────────────────────────────────────────────
|
||||
function CorrelationSection({ corrData, insights, profile, onRequest, loadingSlug }) {
|
||||
function CorrelationSection({ corrData, insights, profile, onRequest, loadingSlug, filterActiveSlugs }) {
|
||||
const filtered = (corrData||[]).filter(d=>d.kcal&&d.weight)
|
||||
if (filtered.length < 5) return (
|
||||
<EmptySection text="Für Korrelationen werden Gewichts- und Ernährungsdaten benötigt (mind. 5 gemeinsame Tage)."/>
|
||||
@@ -852,7 +852,7 @@ function CorrelationSection({ corrData, insights, profile, onRequest, loadingSlu
|
||||
</div>
|
||||
)}
|
||||
|
||||
<InsightBox insights={insights} slugs={['gesamt','ziele']} onRequest={onRequest} loading={loadingSlug}/>
|
||||
<InsightBox insights={insights} slugs={filterActiveSlugs(['gesamt','ziele'])} onRequest={onRequest} loading={loadingSlug}/>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
@@ -903,6 +903,7 @@ export default function History() {
|
||||
const [activities, setActivities] = useState([])
|
||||
const [corrData, setCorrData] = useState([])
|
||||
const [insights, setInsights] = useState([])
|
||||
const [prompts, setPrompts] = useState([])
|
||||
const [profile, setProfile] = useState(null)
|
||||
const [loading, setLoading] = useState(true)
|
||||
const [loadingSlug,setLoadingSlug]= useState(null)
|
||||
@@ -911,10 +912,12 @@ export default function History() {
|
||||
api.listWeight(365), api.listCaliper(), api.listCirc(),
|
||||
api.listNutrition(90), api.listActivity(200),
|
||||
api.nutritionCorrelations(), api.latestInsights(), api.getProfile(),
|
||||
]).then(([w,ca,ci,n,a,corr,ins,p])=>{
|
||||
api.listPrompts(),
|
||||
]).then(([w,ca,ci,n,a,corr,ins,p,pr])=>{
|
||||
setWeights(w); setCalipers(ca); setCircs(ci)
|
||||
setNutrition(n); setActivities(a); setCorrData(corr)
|
||||
setInsights(Array.isArray(ins)?ins:[]); setProfile(p)
|
||||
setPrompts(Array.isArray(pr)?pr:[])
|
||||
setLoading(false)
|
||||
})
|
||||
|
||||
@@ -923,17 +926,23 @@ export default function History() {
|
||||
const requestInsight = async (slug) => {
|
||||
setLoadingSlug(slug)
|
||||
try {
|
||||
const pid=localStorage.getItem('bodytrack_active_profile')||''
|
||||
const r=await api.runInsight(slug)
|
||||
if(!r.ok) throw new Error(await r.text())
|
||||
const ins=await api.latestInsights()
|
||||
const result = await api.runInsight(slug)
|
||||
// result is already JSON, not a Response object
|
||||
const ins = await api.latestInsights()
|
||||
setInsights(Array.isArray(ins)?ins:[])
|
||||
} catch(e){ alert('KI-Fehler: '+e.message) }
|
||||
} catch(e){
|
||||
alert('KI-Fehler: '+e.message)
|
||||
}
|
||||
finally{ setLoadingSlug(null) }
|
||||
}
|
||||
|
||||
if(loading) return <div className="empty-state"><div className="spinner"/></div>
|
||||
const sp={insights,onRequest:requestInsight,loadingSlug}
|
||||
|
||||
// Filter active prompts
|
||||
const activeSlugs = prompts.filter(p=>p.active).map(p=>p.slug)
|
||||
const filterActiveSlugs = (slugs) => slugs.filter(s=>activeSlugs.includes(s))
|
||||
|
||||
const sp={insights,onRequest:requestInsight,loadingSlug,filterActiveSlugs}
|
||||
|
||||
return (
|
||||
<div>
|
||||
|
||||
@@ -32,7 +32,7 @@ export default function LoginScreen() {
|
||||
}
|
||||
setLoading(true); setError(null)
|
||||
try {
|
||||
await login({ email: email.trim().toLowerCase(), pin: password })
|
||||
await login({ email: email.trim().toLowerCase(), password: password })
|
||||
} catch(e) {
|
||||
setError(e.message || 'Ungültige E-Mail oder Passwort')
|
||||
} finally { setLoading(false) }
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
import { useState } from 'react'
|
||||
import { Save, Download, Trash2, Plus, Check, Pencil, X, LogOut, Shield, Key } from 'lucide-react'
|
||||
import { Save, Download, Upload, Trash2, Plus, Check, Pencil, X, LogOut, Shield, Key } from 'lucide-react'
|
||||
import { useProfile } from '../context/ProfileContext'
|
||||
import { useAuth } from '../context/AuthContext'
|
||||
import { Avatar } from './ProfileSelect'
|
||||
@@ -123,6 +123,73 @@ export default function SettingsPage() {
|
||||
// editingId: string ID of profile being edited, or 'new' for new profile, or null
|
||||
const [editingId, setEditingId] = useState(null)
|
||||
const [saved, setSaved] = useState(false)
|
||||
const [importing, setImporting] = useState(false)
|
||||
const [importMsg, setImportMsg] = useState(null)
|
||||
|
||||
const handleImport = async (e) => {
|
||||
const file = e.target.files?.[0]
|
||||
if (!file) return
|
||||
|
||||
if (!confirm(`Backup "${file.name}" importieren? Vorhandene Einträge werden nicht überschrieben.`)) {
|
||||
e.target.value = '' // Reset file input
|
||||
return
|
||||
}
|
||||
|
||||
setImporting(true)
|
||||
setImportMsg(null)
|
||||
|
||||
try {
|
||||
const formData = new FormData()
|
||||
formData.append('file', file)
|
||||
|
||||
const token = localStorage.getItem('bodytrack_token')||''
|
||||
const pid = localStorage.getItem('bodytrack_active_profile')||''
|
||||
|
||||
const res = await fetch('/api/import/zip', {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
'X-Auth-Token': token,
|
||||
'X-Profile-Id': pid
|
||||
},
|
||||
body: formData
|
||||
})
|
||||
|
||||
const data = await res.json()
|
||||
|
||||
if (!res.ok) {
|
||||
throw new Error(data.detail || 'Import fehlgeschlagen')
|
||||
}
|
||||
|
||||
// Show success message with stats
|
||||
const stats = data.stats
|
||||
const lines = []
|
||||
if (stats.weight > 0) lines.push(`${stats.weight} Gewicht`)
|
||||
if (stats.circumferences > 0) lines.push(`${stats.circumferences} Umfänge`)
|
||||
if (stats.caliper > 0) lines.push(`${stats.caliper} Caliper`)
|
||||
if (stats.nutrition > 0) lines.push(`${stats.nutrition} Ernährung`)
|
||||
if (stats.activity > 0) lines.push(`${stats.activity} Aktivität`)
|
||||
if (stats.photos > 0) lines.push(`${stats.photos} Fotos`)
|
||||
if (stats.insights > 0) lines.push(`${stats.insights} KI-Analysen`)
|
||||
|
||||
setImportMsg({
|
||||
type: 'success',
|
||||
text: `✓ Import erfolgreich: ${lines.join(', ')}`
|
||||
})
|
||||
|
||||
// Refresh data (in case new entries were added)
|
||||
await refreshProfiles()
|
||||
|
||||
} catch (err) {
|
||||
setImportMsg({
|
||||
type: 'error',
|
||||
text: `✗ ${err.message}`
|
||||
})
|
||||
} finally {
|
||||
setImporting(false)
|
||||
e.target.value = '' // Reset file input
|
||||
setTimeout(() => setImportMsg(null), 5000)
|
||||
}
|
||||
}
|
||||
|
||||
const handleSave = async (form, profileId) => {
|
||||
const data = {}
|
||||
@@ -291,12 +358,12 @@ export default function SettingsPage() {
|
||||
)}
|
||||
{canExport && <>
|
||||
<button className="btn btn-primary btn-full"
|
||||
onClick={()=>window.open('/api/export/zip')}>
|
||||
onClick={()=>api.exportZip()}>
|
||||
<Download size={14}/> ZIP exportieren
|
||||
<span style={{fontSize:11,opacity:0.8,marginLeft:6}}>— je eine CSV pro Kategorie</span>
|
||||
</button>
|
||||
<button className="btn btn-secondary btn-full"
|
||||
onClick={()=>window.open('/api/export/json')}>
|
||||
onClick={()=>api.exportJson()}>
|
||||
<Download size={14}/> JSON exportieren
|
||||
<span style={{fontSize:11,opacity:0.8,marginLeft:6}}>— maschinenlesbar, alles in einer Datei</span>
|
||||
</button>
|
||||
@@ -307,6 +374,55 @@ export default function SettingsPage() {
|
||||
</p>
|
||||
</div>
|
||||
|
||||
{/* Import */}
|
||||
<div className="card section-gap">
|
||||
<div className="card-title">Backup importieren</div>
|
||||
<p style={{fontSize:13,color:'var(--text2)',marginBottom:12,lineHeight:1.6}}>
|
||||
Importiere einen ZIP-Export zurück in <strong>{activeProfile?.name}</strong>.
|
||||
Vorhandene Einträge werden nicht überschrieben.
|
||||
</p>
|
||||
<div style={{display:'flex',flexDirection:'column',gap:8}}>
|
||||
{!canExport && (
|
||||
<div style={{padding:'10px 12px',background:'#FCEBEB',borderRadius:8,
|
||||
fontSize:13,color:'#D85A30',marginBottom:8}}>
|
||||
🔒 Import ist für dein Profil nicht freigeschaltet. Bitte den Admin kontaktieren.
|
||||
</div>
|
||||
)}
|
||||
{canExport && (
|
||||
<>
|
||||
<label className="btn btn-primary btn-full"
|
||||
style={{cursor:importing?'wait':'pointer',opacity:importing?0.6:1}}>
|
||||
<input type="file" accept=".zip" onChange={handleImport}
|
||||
disabled={importing}
|
||||
style={{display:'none'}}/>
|
||||
{importing ? (
|
||||
<>Importiere...</>
|
||||
) : (
|
||||
<>
|
||||
<Upload size={14}/> ZIP-Backup importieren
|
||||
</>
|
||||
)}
|
||||
</label>
|
||||
{importMsg && (
|
||||
<div style={{
|
||||
padding:'10px 12px',
|
||||
background: importMsg.type === 'success' ? '#E1F5EE' : '#FCEBEB',
|
||||
borderRadius:8,
|
||||
fontSize:12,
|
||||
color: importMsg.type === 'success' ? 'var(--accent)' : '#D85A30',
|
||||
lineHeight:1.4
|
||||
}}>
|
||||
{importMsg.text}
|
||||
</div>
|
||||
)}
|
||||
</>
|
||||
)}
|
||||
</div>
|
||||
<p style={{fontSize:11,color:'var(--text3)',marginTop:8}}>
|
||||
Der Import erkennt automatisch das Format und importiert nur neue Einträge.
|
||||
</p>
|
||||
</div>
|
||||
|
||||
{saved && (
|
||||
<div style={{position:'fixed',bottom:80,left:'50%',transform:'translateX(-50%)',
|
||||
background:'var(--accent)',color:'white',padding:'8px 20px',borderRadius:20,
|
||||
|
||||
@@ -68,7 +68,10 @@ export const api = {
|
||||
return fetch(`${BASE}/photos`,{method:'POST',body:fd,headers:hdrs()}).then(r=>r.json())
|
||||
},
|
||||
listPhotos: () => req('/photos'),
|
||||
photoUrl: (pid) => `${BASE}/photos/${pid}`,
|
||||
photoUrl: (pid) => {
|
||||
const token = getToken()
|
||||
return `${BASE}/photos/${pid}${token ? `?token=${token}` : ''}`
|
||||
},
|
||||
|
||||
// Nutrition
|
||||
importCsv: async(file)=>{
|
||||
@@ -88,9 +91,45 @@ export const api = {
|
||||
insightPipeline: () => req('/insights/pipeline',{method:'POST'}),
|
||||
listInsights: () => req('/insights'),
|
||||
latestInsights: () => req('/insights/latest'),
|
||||
exportZip: () => window.open(`${BASE}/export/zip`),
|
||||
exportJson: () => window.open(`${BASE}/export/json`),
|
||||
exportCsv: () => window.open(`${BASE}/export/csv`),
|
||||
exportZip: async () => {
|
||||
const res = await fetch(`${BASE}/export/zip`, {headers: hdrs()})
|
||||
if (!res.ok) throw new Error('Export failed')
|
||||
const blob = await res.blob()
|
||||
const url = window.URL.createObjectURL(blob)
|
||||
const a = document.createElement('a')
|
||||
a.href = url
|
||||
a.download = `mitai-export-${new Date().toISOString().split('T')[0]}.zip`
|
||||
document.body.appendChild(a)
|
||||
a.click()
|
||||
document.body.removeChild(a)
|
||||
window.URL.revokeObjectURL(url)
|
||||
},
|
||||
exportJson: async () => {
|
||||
const res = await fetch(`${BASE}/export/json`, {headers: hdrs()})
|
||||
if (!res.ok) throw new Error('Export failed')
|
||||
const blob = await res.blob()
|
||||
const url = window.URL.createObjectURL(blob)
|
||||
const a = document.createElement('a')
|
||||
a.href = url
|
||||
a.download = `mitai-export-${new Date().toISOString().split('T')[0]}.json`
|
||||
document.body.appendChild(a)
|
||||
a.click()
|
||||
document.body.removeChild(a)
|
||||
window.URL.revokeObjectURL(url)
|
||||
},
|
||||
exportCsv: async () => {
|
||||
const res = await fetch(`${BASE}/export/csv`, {headers: hdrs()})
|
||||
if (!res.ok) throw new Error('Export failed')
|
||||
const blob = await res.blob()
|
||||
const url = window.URL.createObjectURL(blob)
|
||||
const a = document.createElement('a')
|
||||
a.href = url
|
||||
a.download = `mitai-export-${new Date().toISOString().split('T')[0]}.csv`
|
||||
document.body.appendChild(a)
|
||||
a.click()
|
||||
document.body.removeChild(a)
|
||||
window.URL.revokeObjectURL(url)
|
||||
},
|
||||
|
||||
// Admin
|
||||
adminListProfiles: () => req('/admin/profiles'),
|
||||
|
||||
Reference in new issue
Block a user