feat(backend): multi-tenant refactor + Geraete + Kundenbilder

Middleware:
- requireTenant prueft tenant_id, Status und Demo-Ablauf (autom. Status-Update)
- requireSuperAdmin fuer cross-tenant Endpoints
- JWT enthaelt jetzt tenant_id

Auth:
- Login: SuperAdmin (tenant_id=NULL) ODER tenant-scoped User
- Demo-Ablaufs-Check beim Login

Neue Routes:
- /api/tenants  (SuperAdmin: Demo-Accounts anlegen mit 30-Tage-Default,
                 Mail-Invite via Resend, Sample-Daten-Seed automatisch,
                 verlaengern, deaktivieren)
- /api/geraete  (Seriennummern-Verwaltung mit Kunde-Zuordnung)
- /api/kunden-bilder/:kunde_id (Foto-Upload, max 5/Kunde)

Bestehende Routes:
- alle tenant_id-scoped (SELECT/UPDATE/DELETE)
- kunden: anlieferungshinweis + lieferzeit_bis Felder
- Cross-tenant-Refs (kunde_id/artikel_id) werden gegen Tenant validiert

Lib:
- lib/mail.js (Resend, mit Dev-Fallback)
- lib/seed.js (5 Kunden, 3 Artikel, 6 Lieferungen, 2 Geraete)
- scripts/bootstrap.js (legt SuperAdmin aus env-Vars beim Start an)

server.js: neue Routes + bootstrap-Call

backend/routes/auth.js

@@ -7,171 +7,117 @@ import { authenticateToken } from '../middleware/auth.js';
 
 const router = express.Router();
 
-// Login
+const issueToken = (m) => jwt.sign(
+  { id: m.id, email: m.email, rolle: m.rolle, name: m.name, tenant_id: m.tenant_id },
+  process.env.JWT_SECRET,
+  { expiresIn: '24h' }
+);
+
+// POST /api/auth/login
+// body: { email, password, tenant_slug? }
+// - tenant_slug optional: falls mehrere Tenants mit gleicher Mail (sollte selten sein)
+// - SuperAdmins logen sich ohne tenant_slug ein.
 router.post('/login', [
   body('email').isEmail().normalizeEmail(),
   body('password').notEmpty()
 ], async (req, res) => {
   const errors = validationResult(req);
-  if (!errors.isEmpty()) {
-    return res.status(400).json({ errors: errors.array() });
-  }
+  if (!errors.isEmpty()) return res.status(400).json({ errors: errors.array() });
 
-  const { email, password } = req.body;
+  const { email, password, tenant_slug } = req.body;
 
   try {
-    const [rows] = await pool.query(
-      'SELECT * FROM mitarbeiter WHERE email = ?',
-      [email]
-    );
-
-    if (rows.length === 0) {
-      return res.status(401).json({ error: 'Ungültige Anmeldedaten' });
+    let rows;
+    if (tenant_slug) {
+      [rows] = await pool.query(
+        `SELECT m.* FROM mitarbeiter m
+         JOIN tenants t ON m.tenant_id = t.id
+         WHERE m.email = ? AND t.slug = ? AND m.aktiv = 1`,
+        [email, tenant_slug]
+      );
+    } else {
+      // Versuche zuerst SuperAdmin (tenant_id NULL), dann ersten Tenant-Match
+      [rows] = await pool.query(
+        `SELECT * FROM mitarbeiter
+         WHERE email = ? AND aktiv = 1
+         ORDER BY (tenant_id IS NULL) DESC
+         LIMIT 1`,
+        [email]
+      );
     }
 
-    const mitarbeiter = rows[0];
-    const validPassword = await bcrypt.compare(password, mitarbeiter.password_hash);
+    if (rows.length === 0) return res.status(401).json({ error: 'Ungueltige Anmeldedaten' });
+    const m = rows[0];
 
-    if (!validPassword) {
-      return res.status(401).json({ error: 'Ungültige Anmeldedaten' });
+    const ok = await bcrypt.compare(password, m.password_hash);
+    if (!ok) return res.status(401).json({ error: 'Ungueltige Anmeldedaten' });
+
+    // Demo-Ablauf-Pruefung
+    if (m.tenant_id) {
+      const [tr] = await pool.query(
+        'SELECT status, demo_expires_at, typ, name FROM tenants WHERE id = ?',
+        [m.tenant_id]
+      );
+      if (tr.length === 0 || tr[0].status !== 'aktiv') {
+        return res.status(403).json({ error: 'Tenant nicht aktiv' });
+      }
+      if (tr[0].typ === 'demo' && tr[0].demo_expires_at && new Date(tr[0].demo_expires_at) < new Date()) {
+        await pool.query("UPDATE tenants SET status='abgelaufen' WHERE id = ?", [m.tenant_id]);
+        return res.status(403).json({ error: 'Demo-Zugang abgelaufen' });
+      }
     }
 
-    const token = jwt.sign(
-      { 
-        id: mitarbeiter.id, 
-        email: mitarbeiter.email, 
-        rolle: mitarbeiter.rolle,
-        name: mitarbeiter.name
-      },
-      process.env.JWT_SECRET,
-      { expiresIn: '24h' }
-    );
-
     res.json({
-      token,
+      token: issueToken(m),
       user: {
-        id: mitarbeiter.id,
-        email: mitarbeiter.email,
-        name: mitarbeiter.name,
-        rolle: mitarbeiter.rolle
+        id: m.id, email: m.email, name: m.name, rolle: m.rolle, tenant_id: m.tenant_id
       }
     });
-  } catch (error) {
-    console.error('Login-Fehler:', error);
+  } catch (e) {
+    console.error('Login-Fehler:', e);
     res.status(500).json({ error: 'Serverfehler beim Login' });
   }
 });
 
-// Register (nur für Admin)
-router.post('/register', authenticateToken, [
-  body('email').isEmail().normalizeEmail(),
-  body('password').isLength({ min: 6 }),
-  body('name').notEmpty(),
-  body('rolle').isIn(['user', 'admin'])
-], async (req, res) => {
-  // Nur Admins dürfen neue Benutzer anlegen
-  if (req.user.rolle !== 'admin') {
-    return res.status(403).json({ error: 'Keine Berechtigung' });
-  }
-
-  const errors = validationResult(req);
-  if (!errors.isEmpty()) {
-    return res.status(400).json({ errors: errors.array() });
-  }
-
-  const { email, password, name, rolle } = req.body;
-
-  try {
-    // Prüfe ob Email bereits existiert
-    const [existing] = await pool.query(
-      'SELECT id FROM mitarbeiter WHERE email = ?',
-      [email]
-    );
-
-    if (existing.length > 0) {
-      return res.status(400).json({ error: 'Email bereits registriert' });
-    }
-
-    const passwordHash = await bcrypt.hash(password, 10);
-
-    const [result] = await pool.query(
-      'INSERT INTO mitarbeiter (email, password_hash, name, rolle) VALUES (?, ?, ?, ?)',
-      [email, passwordHash, name, rolle]
-    );
-
-    res.status(201).json({
-      message: 'Mitarbeiter erfolgreich angelegt',
-      id: result.insertId
-    });
-  } catch (error) {
-    console.error('Registrierungs-Fehler:', error);
-    res.status(500).json({ error: 'Serverfehler bei der Registrierung' });
-  }
-});
-
-// Get current user
+// GET /api/auth/me
 router.get('/me', authenticateToken, async (req, res) => {
   try {
     const [rows] = await pool.query(
-      'SELECT id, email, name, rolle, erstellt_am FROM mitarbeiter WHERE id = ?',
+      `SELECT m.id, m.email, m.name, m.rolle, m.tenant_id, m.erstellt_am,
+              t.name AS tenant_name, t.slug AS tenant_slug,
+              t.typ AS tenant_typ, t.demo_expires_at, t.status AS tenant_status
+       FROM mitarbeiter m
+       LEFT JOIN tenants t ON m.tenant_id = t.id
+       WHERE m.id = ?`,
       [req.user.id]
     );
-
-    if (rows.length === 0) {
-      return res.status(404).json({ error: 'Benutzer nicht gefunden' });
-    }
-
+    if (rows.length === 0) return res.status(404).json({ error: 'Benutzer nicht gefunden' });
     res.json(rows[0]);
-  } catch (error) {
-    console.error('Fehler beim Abrufen des Benutzers:', error);
+  } catch (e) {
+    console.error('me-Fehler:', e);
     res.status(500).json({ error: 'Serverfehler' });
   }
 });
 
-// Change password
+// POST /api/auth/change-password
 router.post('/change-password', authenticateToken, [
   body('currentPassword').notEmpty(),
   body('newPassword').isLength({ min: 6 })
 ], async (req, res) => {
   const errors = validationResult(req);
-  if (!errors.isEmpty()) {
-    return res.status(400).json({ errors: errors.array() });
-  }
-
-  const { currentPassword, newPassword } = req.body;
+  if (!errors.isEmpty()) return res.status(400).json({ errors: errors.array() });
 
   try {
-    // Hole aktuellen Benutzer
-    const [rows] = await pool.query(
-      'SELECT * FROM mitarbeiter WHERE id = ?',
-      [req.user.id]
-    );
-
-    if (rows.length === 0) {
-      return res.status(404).json({ error: 'Benutzer nicht gefunden' });
-    }
-
-    const mitarbeiter = rows[0];
-
-    // Prüfe aktuelles Passwort
-    const validPassword = await bcrypt.compare(currentPassword, mitarbeiter.password_hash);
-    if (!validPassword) {
-      return res.status(401).json({ error: 'Aktuelles Passwort ist falsch' });
-    }
-
-    // Hash neues Passwort
-    const newPasswordHash = await bcrypt.hash(newPassword, 10);
-
-    // Update Passwort
-    await pool.query(
-      'UPDATE mitarbeiter SET password_hash = ? WHERE id = ?',
-      [newPasswordHash, req.user.id]
-    );
-
-    res.json({ message: 'Passwort erfolgreich geändert' });
-  } catch (error) {
-    console.error('Fehler beim Ändern des Passworts:', error);
-    res.status(500).json({ error: 'Serverfehler beim Ändern des Passworts' });
+    const [rows] = await pool.query('SELECT password_hash FROM mitarbeiter WHERE id = ?', [req.user.id]);
+    if (rows.length === 0) return res.status(404).json({ error: 'Benutzer nicht gefunden' });
+    const ok = await bcrypt.compare(req.body.currentPassword, rows[0].password_hash);
+    if (!ok) return res.status(401).json({ error: 'Aktuelles Passwort ist falsch' });
+    const hash = await bcrypt.hash(req.body.newPassword, 10);
+    await pool.query('UPDATE mitarbeiter SET password_hash = ? WHERE id = ?', [hash, req.user.id]);
+    res.json({ message: 'Passwort erfolgreich geaendert' });
+  } catch (e) {
+    console.error('change-password-Fehler:', e);
+    res.status(500).json({ error: 'Serverfehler' });
   }
 });