Refactoring

routes/admin-ldap.js

@@ -0,0 +1,167 @@
+// LDAP Admin Routes
+
+const { db } = require('../database');
+const LDAPService = require('../ldap-service');
+const { requireAdmin } = require('../middleware/auth');
+
+// Routes registrieren
+function registerAdminLDAPRoutes(app) {
+  // LDAP-Konfiguration abrufen
+  app.get('/admin/ldap/config', requireAdmin, (req, res) => {
+    db.get('SELECT * FROM ldap_config WHERE id = 1', (err, config) => {
+      if (err) {
+        return res.status(500).json({ error: 'Fehler beim Abrufen der Konfiguration' });
+      }
+      
+      // Passwort nicht zurückgeben
+      if (config) {
+        delete config.bind_password;
+      }
+      
+      res.json({ config: config || null });
+    });
+  });
+
+  // LDAP-Konfiguration speichern
+  app.post('/admin/ldap/config', requireAdmin, (req, res) => {
+    const {
+      enabled,
+      url,
+      bind_dn,
+      bind_password,
+      base_dn,
+      user_search_filter,
+      username_attribute,
+      firstname_attribute,
+      lastname_attribute,
+      sync_interval
+    } = req.body;
+
+    // Validierung - nur wenn aktiviert
+    if (enabled && (!url || !base_dn)) {
+      return res.status(400).json({ error: 'URL und Base DN sind erforderlich wenn LDAP aktiviert ist' });
+    }
+
+    // Prüfe ob Konfiguration bereits existiert
+    db.get('SELECT id FROM ldap_config WHERE id = 1', (err, existing) => {
+      if (err) {
+        return res.status(500).json({ error: 'Fehler beim Prüfen der Konfiguration' });
+      }
+
+      const configData = {
+        enabled: enabled ? 1 : 0,
+        url: url.trim(),
+        bind_dn: bind_dn ? bind_dn.trim() : null,
+        bind_password: bind_password ? bind_password.trim() : null,
+        base_dn: base_dn.trim(),
+        user_search_filter: user_search_filter ? user_search_filter.trim() : '(objectClass=person)',
+        username_attribute: username_attribute ? username_attribute.trim() : 'cn',
+        firstname_attribute: firstname_attribute ? firstname_attribute.trim() : 'givenName',
+        lastname_attribute: lastname_attribute ? lastname_attribute.trim() : 'sn',
+        sync_interval: parseInt(sync_interval) || 0,
+        updated_at: new Date().toISOString()
+      };
+
+      if (existing) {
+        // Update - Passwort nur aktualisieren wenn angegeben
+        if (configData.bind_password) {
+          db.run(
+            `UPDATE ldap_config SET 
+              enabled = ?, url = ?, bind_dn = ?, bind_password = ?, base_dn = ?,
+              user_search_filter = ?, username_attribute = ?, firstname_attribute = ?,
+              lastname_attribute = ?, sync_interval = ?, updated_at = ?
+             WHERE id = 1`,
+            [
+              configData.enabled, configData.url, configData.bind_dn, configData.bind_password,
+              configData.base_dn, configData.user_search_filter, configData.username_attribute,
+              configData.firstname_attribute, configData.lastname_attribute, configData.sync_interval,
+              configData.updated_at
+            ],
+            (err) => {
+              if (err) {
+                return res.status(500).json({ error: 'Fehler beim Speichern der Konfiguration' });
+              }
+              res.json({ success: true });
+            }
+          );
+        } else {
+          // Passwort nicht ändern
+          db.run(
+            `UPDATE ldap_config SET 
+              enabled = ?, url = ?, bind_dn = ?, base_dn = ?,
+              user_search_filter = ?, username_attribute = ?, firstname_attribute = ?,
+              lastname_attribute = ?, sync_interval = ?, updated_at = ?
+             WHERE id = 1`,
+            [
+              configData.enabled, configData.url, configData.bind_dn,
+              configData.base_dn, configData.user_search_filter, configData.username_attribute,
+              configData.firstname_attribute, configData.lastname_attribute, configData.sync_interval,
+              configData.updated_at
+            ],
+            (err) => {
+              if (err) {
+                return res.status(500).json({ error: 'Fehler beim Speichern der Konfiguration' });
+              }
+              res.json({ success: true });
+            }
+          );
+        }
+      } else {
+        // Insert
+        db.run(
+          `INSERT INTO ldap_config (
+            enabled, url, bind_dn, bind_password, base_dn, user_search_filter,
+            username_attribute, firstname_attribute, lastname_attribute, sync_interval, updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+          [
+            configData.enabled, configData.url, configData.bind_dn, configData.bind_password,
+            configData.base_dn, configData.user_search_filter, configData.username_attribute,
+            configData.firstname_attribute, configData.lastname_attribute, configData.sync_interval,
+            configData.updated_at
+          ],
+          (err) => {
+            if (err) {
+              return res.status(500).json({ error: 'Fehler beim Erstellen der Konfiguration' });
+            }
+            res.json({ success: true });
+          }
+        );
+      }
+    });
+  });
+
+  // Manuelle LDAP-Synchronisation starten
+  app.post('/admin/ldap/sync', requireAdmin, (req, res) => {
+    LDAPService.performSync('manual', (err, result) => {
+      if (err) {
+        return res.status(500).json({ 
+          error: err.message || 'Fehler bei der Synchronisation',
+          synced: result ? result.synced : 0,
+          errors: result ? result.errors : []
+        });
+      }
+      res.json({ 
+        success: true, 
+        synced: result.synced,
+        errors: result.errors || []
+      });
+    });
+  });
+
+  // Sync-Log abrufen
+  app.get('/admin/ldap/sync/log', requireAdmin, (req, res) => {
+    const limit = parseInt(req.query.limit) || 10;
+    db.all(
+      'SELECT * FROM ldap_sync_log ORDER BY sync_started_at DESC LIMIT ?',
+      [limit],
+      (err, logs) => {
+        if (err) {
+          return res.status(500).json({ error: 'Fehler beim Abrufen des Logs' });
+        }
+        res.json({ logs: logs || [] });
+      }
+    );
+  });
+}
+
+module.exports = registerAdminLDAPRoutes;

routes/admin.js

@@ -0,0 +1,154 @@
+// Admin Routes
+
+const bcrypt = require('bcryptjs');
+const { db } = require('../database');
+const { requireAdmin } = require('../middleware/auth');
+
+// Routes registrieren
+function registerAdminRoutes(app) {
+  // Admin-Bereich
+  app.get('/admin', requireAdmin, (req, res) => {
+    db.all('SELECT id, username, firstname, lastname, role, personalnummer, wochenstunden, urlaubstage, created_at FROM users ORDER BY created_at DESC', 
+      (err, users) => {
+        // LDAP-Konfiguration und Sync-Log abrufen
+        db.get('SELECT * FROM ldap_config WHERE id = 1', (err, ldapConfig) => {
+          db.all('SELECT * FROM ldap_sync_log ORDER BY sync_started_at DESC LIMIT 10', (err, syncLogs) => {
+            // Parse Rollen für jeden User
+            const usersWithRoles = (users || []).map(u => {
+              let roles = [];
+              try {
+                roles = JSON.parse(u.role);
+                if (!Array.isArray(roles)) {
+                  roles = [u.role];
+                }
+              } catch (e) {
+                roles = [u.role || 'mitarbeiter'];
+              }
+              return { ...u, roles };
+            });
+            
+            res.render('admin', { 
+              users: usersWithRoles,
+              ldapConfig: ldapConfig || null,
+              syncLogs: syncLogs || [],
+              user: {
+                firstname: req.session.firstname,
+                lastname: req.session.lastname,
+                roles: req.session.roles || [],
+                currentRole: req.session.currentRole || 'admin'
+              }
+            });
+          });
+        });
+      });
+  });
+
+  // Benutzer erstellen
+  app.post('/admin/users', requireAdmin, (req, res) => {
+    const { username, password, firstname, lastname, roles, personalnummer, wochenstunden, urlaubstage } = req.body;
+    const hashedPassword = bcrypt.hashSync(password, 10);
+    
+    // Normalisiere die optionalen Felder
+    const normalizedPersonalnummer = personalnummer && personalnummer.trim() !== '' ? personalnummer.trim() : null;
+    const normalizedWochenstunden = wochenstunden && wochenstunden !== '' ? parseFloat(wochenstunden) : null;
+    const normalizedUrlaubstage = urlaubstage && urlaubstage !== '' ? parseFloat(urlaubstage) : null;
+    
+    // Rollen verarbeiten: Erwarte Array, konvertiere zu JSON-String
+    let rolesArray = [];
+    if (Array.isArray(roles)) {
+      rolesArray = roles.filter(r => r && ['mitarbeiter', 'verwaltung', 'admin'].includes(r));
+    } else if (roles) {
+      // Fallback: Einzelne Rolle als Array
+      rolesArray = [roles];
+    }
+    
+    // Mindestens eine Rolle erforderlich
+    if (rolesArray.length === 0) {
+      rolesArray = ['mitarbeiter']; // Standard-Rolle
+    }
+    
+    const rolesJson = JSON.stringify(rolesArray);
+    
+    db.run('INSERT INTO users (username, password, firstname, lastname, role, personalnummer, wochenstunden, urlaubstage) VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
+      [username, hashedPassword, firstname, lastname, rolesJson, normalizedPersonalnummer, normalizedWochenstunden, normalizedUrlaubstage],
+      (err) => {
+        if (err) {
+          return res.status(400).json({ error: 'Benutzername existiert bereits' });
+        }
+        res.json({ success: true });
+      });
+  });
+
+  // Benutzer löschen
+  app.delete('/admin/users/:id', requireAdmin, (req, res) => {
+    const userId = req.params.id;
+    
+    // Admin darf sich nicht selbst löschen
+    if (userId == req.session.userId) {
+      return res.status(400).json({ error: 'Sie können sich nicht selbst löschen' });
+    }
+    
+    db.run('DELETE FROM users WHERE id = ?', [userId], (err) => {
+      if (err) {
+        return res.status(500).json({ error: 'Fehler beim Löschen' });
+      }
+      res.json({ success: true });
+    });
+  });
+
+  // Benutzer aktualisieren (Personalnummer, Wochenstunden, Urlaubstage, Rollen)
+  app.put('/admin/users/:id', requireAdmin, (req, res) => {
+    const userId = req.params.id;
+    const { personalnummer, wochenstunden, urlaubstage, roles } = req.body;
+    
+    // Rollen verarbeiten falls vorhanden
+    let rolesJson = null;
+    if (roles !== undefined) {
+      let rolesArray = [];
+      if (Array.isArray(roles)) {
+        rolesArray = roles.filter(r => r && ['mitarbeiter', 'verwaltung', 'admin'].includes(r));
+      }
+      // Mindestens eine Rolle erforderlich
+      if (rolesArray.length === 0) {
+        return res.status(400).json({ error: 'Mindestens eine Rolle ist erforderlich' });
+      }
+      rolesJson = JSON.stringify(rolesArray);
+    }
+    
+    // SQL-Query dynamisch zusammenstellen
+    if (rolesJson !== null) {
+      // Aktualisiere auch Rollen
+      db.run('UPDATE users SET personalnummer = ?, wochenstunden = ?, urlaubstage = ?, role = ? WHERE id = ?',
+        [
+          personalnummer || null,
+          wochenstunden ? parseFloat(wochenstunden) : null,
+          urlaubstage ? parseFloat(urlaubstage) : null,
+          rolesJson,
+          userId
+        ],
+        (err) => {
+          if (err) {
+            return res.status(500).json({ error: 'Fehler beim Aktualisieren' });
+          }
+          res.json({ success: true });
+        });
+    } else {
+      // Nur andere Felder aktualisieren
+      db.run('UPDATE users SET personalnummer = ?, wochenstunden = ?, urlaubstage = ? WHERE id = ?',
+        [
+          personalnummer || null,
+          wochenstunden ? parseFloat(wochenstunden) : null,
+          urlaubstage ? parseFloat(urlaubstage) : null,
+          userId
+        ],
+        (err) => {
+          if (err) {
+            return res.status(500).json({ error: 'Fehler beim Aktualisieren' });
+          }
+          res.json({ success: true });
+        });
+    }
+  });
+}
+
+module.exports = registerAdminRoutes;

routes/auth.js

@@ -0,0 +1,121 @@
+// Authentifizierungs-Routes
+
+const bcrypt = require('bcryptjs');
+const { db } = require('../database');
+const LDAPService = require('../ldap-service');
+const { getDefaultRole } = require('../helpers/utils');
+
+// Helper-Funktion für erfolgreiche Anmeldung
+function handleSuccessfulLogin(req, res, user) {
+  // Rollen als JSON-Array parsen
+  let roles = [];
+  try {
+    roles = JSON.parse(user.role);
+    if (!Array.isArray(roles)) {
+      // Fallback: Falls kein Array, erstelle Array mit vorhandener Rolle
+      roles = [user.role];
+    }
+  } catch (e) {
+    // Fallback: Falls kein JSON, erstelle Array mit vorhandener Rolle
+    roles = [user.role || 'mitarbeiter'];
+  }
+  
+  // Standard-Rolle bestimmen: Immer "mitarbeiter" wenn vorhanden, sonst höchste Priorität
+  let defaultRole;
+  if (roles.includes('mitarbeiter')) {
+    defaultRole = 'mitarbeiter';
+  } else {
+    defaultRole = getDefaultRole(roles);
+  }
+  
+  req.session.userId = user.id;
+  req.session.username = user.username;
+  req.session.roles = roles;
+  req.session.currentRole = defaultRole;
+  req.session.firstname = user.firstname;
+  req.session.lastname = user.lastname;
+  
+  // Redirect: Immer zu Dashboard wenn Mitarbeiter-Rolle vorhanden, sonst basierend auf Standard-Rolle
+  if (roles.includes('mitarbeiter')) {
+    res.redirect('/dashboard');
+  } else if (defaultRole === 'admin') {
+    res.redirect('/admin');
+  } else if (defaultRole === 'verwaltung') {
+    res.redirect('/verwaltung');
+  } else {
+    res.redirect('/dashboard');
+  }
+}
+
+// Routes registrieren
+function registerAuthRoutes(app) {
+  // Login-Seite
+  app.get('/login', (req, res) => {
+    res.render('login', { error: null });
+  });
+
+  // Login-Verarbeitung
+  app.post('/login', (req, res) => {
+    const { username, password } = req.body;
+    
+    // Prüfe ob LDAP aktiviert ist
+    LDAPService.getConfig((err, ldapConfig) => {
+      if (err) {
+        console.error('Fehler beim Abrufen der LDAP-Konfiguration:', err);
+      }
+      
+      const isLDAPEnabled = ldapConfig && ldapConfig.enabled === 1;
+      
+      // Wenn LDAP aktiviert ist, authentifiziere gegen LDAP
+      if (isLDAPEnabled) {
+        LDAPService.authenticate(username, password, (authErr, authSuccess) => {
+          if (authErr || !authSuccess) {
+            // LDAP-Authentifizierung fehlgeschlagen - prüfe lokale Datenbank als Fallback
+            db.get('SELECT * FROM users WHERE username = ?', [username], (err, user) => {
+              if (err || !user) {
+                return res.render('login', { error: 'Ungültiger Benutzername oder Passwort' });
+              }
+              
+              // Versuche lokale Authentifizierung
+              if (bcrypt.compareSync(password, user.password)) {
+                handleSuccessfulLogin(req, res, user);
+              } else {
+                res.render('login', { error: 'Ungültiger Benutzername oder Passwort' });
+              }
+            });
+          } else {
+            // LDAP-Authentifizierung erfolgreich - hole Benutzer aus Datenbank
+            db.get('SELECT * FROM users WHERE username = ?', [username], (err, user) => {
+              if (err || !user) {
+                return res.render('login', { error: 'Benutzer nicht in der Datenbank gefunden. Bitte führen Sie eine LDAP-Synchronisation durch.' });
+              }
+              
+              handleSuccessfulLogin(req, res, user);
+            });
+          }
+        });
+      } else {
+        // LDAP nicht aktiviert - verwende lokale Authentifizierung
+        db.get('SELECT * FROM users WHERE username = ?', [username], (err, user) => {
+          if (err || !user) {
+            return res.render('login', { error: 'Ungültiger Benutzername oder Passwort' });
+          }
+          
+          if (bcrypt.compareSync(password, user.password)) {
+            handleSuccessfulLogin(req, res, user);
+          } else {
+            res.render('login', { error: 'Ungültiger Benutzername oder Passwort' });
+          }
+        });
+      }
+    });
+  });
+
+  // Logout
+  app.get('/logout', (req, res) => {
+    req.session.destroy();
+    res.redirect('/login');
+  });
+}
+
+module.exports = registerAuthRoutes;

routes/dashboard.js

@@ -0,0 +1,35 @@
+// Dashboard-Route
+
+const { hasRole } = require('../helpers/utils');
+const { requireAuth } = require('../middleware/auth');
+
+// Routes registrieren
+function registerDashboardRoutes(app) {
+  // Dashboard für Mitarbeiter
+  app.get('/dashboard', requireAuth, (req, res) => {
+    // Prüfe ob User Mitarbeiter-Rolle hat
+    if (!hasRole(req, 'mitarbeiter')) {
+      // Wenn User keine Mitarbeiter-Rolle hat, aber andere Rollen, redirecte entsprechend
+      if (hasRole(req, 'admin')) {
+        return res.redirect('/admin');
+      }
+      if (hasRole(req, 'verwaltung')) {
+        return res.redirect('/verwaltung');
+      }
+      return res.status(403).send('Zugriff verweigert');
+    }
+    
+    res.render('dashboard', { 
+      user: {
+        id: req.session.userId,
+        firstname: req.session.firstname,
+        lastname: req.session.lastname,
+        username: req.session.username,
+        roles: req.session.roles || [],
+        currentRole: req.session.currentRole || 'mitarbeiter'
+      }
+    });
+  });
+}
+
+module.exports = registerDashboardRoutes;

routes/timesheet.js

@@ -0,0 +1,378 @@
+// Timesheet API Routes
+
+const { db } = require('../database');
+const { requireAuth, requireVerwaltung } = require('../middleware/auth');
+const { generatePDF } = require('../services/pdf-service');
+
+// Routes registrieren
+function registerTimesheetRoutes(app) {
+  // API: Stundenerfassung speichern
+  app.post('/api/timesheet/save', requireAuth, (req, res) => {
+    const { 
+      date, start_time, end_time, break_minutes, notes,
+      activity1_desc, activity1_hours, activity1_project_number,
+      activity2_desc, activity2_hours, activity2_project_number,
+      activity3_desc, activity3_hours, activity3_project_number,
+      activity4_desc, activity4_hours, activity4_project_number,
+      activity5_desc, activity5_hours, activity5_project_number,
+      overtime_taken_hours, vacation_type, sick_status
+    } = req.body;
+    const userId = req.session.userId;
+    
+    // Normalisiere end_time: Leere Strings werden zu null
+    const normalizedEndTime = (end_time && typeof end_time === 'string' && end_time.trim() !== '') ? end_time.trim() : (end_time || null);
+    const normalizedStartTime = (start_time && typeof start_time === 'string' && start_time.trim() !== '') ? start_time.trim() : (start_time || null);
+    
+    // Normalisiere sick_status: Boolean oder 1/0 zu Boolean
+    const isSick = sick_status === true || sick_status === 1 || sick_status === 'true' || sick_status === '1';
+    
+    // User-Daten laden (für Überstunden-Berechnung)
+    db.get('SELECT wochenstunden FROM users WHERE id = ?', [userId], (err, user) => {
+      if (err) {
+        console.error('Fehler beim Laden der User-Daten:', err);
+        return res.status(500).json({ error: 'Fehler beim Laden der User-Daten' });
+      }
+      
+      const wochenstunden = user?.wochenstunden || 0;
+      const overtimeValue = overtime_taken_hours ? parseFloat(overtime_taken_hours) : 0;
+      const fullDayHours = wochenstunden > 0 ? wochenstunden / 5 : 0;
+      
+      // Überstunden-Logik: Prüfe ob ganzer Tag oder weniger
+      let isFullDayOvertime = false;
+      if (overtimeValue > 0 && fullDayHours > 0 && Math.abs(overtimeValue - fullDayHours) < 0.01) {
+        isFullDayOvertime = true;
+      }
+      
+      // Gesamtstunden berechnen (aus Start- und Endzeit, nicht aus Tätigkeiten)
+      // Wenn ganzer Tag Urlaub oder Krank, dann zählt dieser als 8 Stunden normale Arbeitszeit
+      let total_hours = 0;
+      let finalActivity1Desc = activity1_desc;
+      let finalActivity1Hours = parseFloat(activity1_hours) || 0;
+      let finalActivity2Desc = activity2_desc;
+      let finalActivity3Desc = activity3_desc;
+      let finalActivity4Desc = activity4_desc;
+      let finalActivity5Desc = activity5_desc;
+      let finalStartTime = normalizedStartTime;
+      let finalEndTime = normalizedEndTime;
+      
+      // Überstunden-Logik: Bei vollem Tag Überstunden
+      if (isFullDayOvertime) {
+        total_hours = 0;
+        finalStartTime = null;
+        finalEndTime = null;
+        finalActivity1Desc = 'Überstunden';
+        finalActivity1Hours = 0;
+      } else if (vacation_type === 'full') {
+        total_hours = 8; // Ganzer Tag Urlaub = 8 Stunden normale Arbeitszeit
+      } else if (isSick) {
+        total_hours = 8; // Krank = 8 Stunden normale Arbeitszeit
+        finalActivity1Desc = 'Krank';
+        finalActivity1Hours = 8;
+      } else if (normalizedStartTime && normalizedEndTime) {
+        const start = new Date(`2000-01-01T${normalizedStartTime}`);
+        const end = new Date(`2000-01-01T${normalizedEndTime}`);
+        const diffMs = end - start;
+        total_hours = (diffMs / (1000 * 60 * 60)) - (break_minutes / 60);
+        // Bei halbem Tag Urlaub: total_hours bleibt die tatsächlich gearbeiteten Stunden
+        // Die 4 Stunden Urlaub werden nur in der Überstunden-Berechnung hinzugezählt
+      }
+      
+      // Überstunden-Logik: Bei weniger als vollem Tag - füge "Überstunden" als Tätigkeit hinzu
+      if (overtimeValue > 0 && !isFullDayOvertime && fullDayHours > 0) {
+        // Prüfe ob "Überstunden" bereits in activities vorhanden
+        const activities = [
+          { desc: finalActivity1Desc, hours: finalActivity1Hours },
+          { desc: finalActivity2Desc, hours: activity2_hours },
+          { desc: finalActivity3Desc, hours: activity3_hours },
+          { desc: finalActivity4Desc, hours: activity4_hours },
+          { desc: finalActivity5Desc, hours: activity5_hours }
+        ];
+        
+        let foundOvertime = false;
+        for (let i = 0; i < activities.length; i++) {
+          if (activities[i].desc && activities[i].desc.trim().toLowerCase() === 'überstunden') {
+            foundOvertime = true;
+            break;
+          }
+        }
+        
+        // Wenn nicht gefunden, füge zur ersten freien Activity-Spalte hinzu
+        if (!foundOvertime) {
+          for (let i = 0; i < activities.length; i++) {
+            if (!activities[i].desc || activities[i].desc.trim() === '') {
+              // Setze diese Activity auf "Überstunden"
+              if (i === 0) {
+                finalActivity1Desc = 'Überstunden';
+                // Stunden bleiben unverändert (werden vom User eingegeben)
+              } else if (i === 1) {
+                finalActivity2Desc = 'Überstunden';
+              } else if (i === 2) {
+                finalActivity3Desc = 'Überstunden';
+              } else if (i === 3) {
+                finalActivity4Desc = 'Überstunden';
+              } else if (i === 4) {
+                finalActivity5Desc = 'Überstunden';
+              }
+              break;
+            }
+          }
+        }
+      }
+      
+      // Prüfen ob Eintrag existiert - verwende den neuesten Eintrag falls mehrere existieren
+      db.get('SELECT id FROM timesheet_entries WHERE user_id = ? AND date = ? ORDER BY updated_at DESC, id DESC LIMIT 1', 
+        [userId, date], (err, row) => {
+        if (row) {
+          // Update
+          db.run(`UPDATE timesheet_entries 
+                  SET start_time = ?, end_time = ?, break_minutes = ?, total_hours = ?, notes = ?,
+                      activity1_desc = ?, activity1_hours = ?, activity1_project_number = ?,
+                      activity2_desc = ?, activity2_hours = ?, activity2_project_number = ?,
+                      activity3_desc = ?, activity3_hours = ?, activity3_project_number = ?,
+                      activity4_desc = ?, activity4_hours = ?, activity4_project_number = ?,
+                      activity5_desc = ?, activity5_hours = ?, activity5_project_number = ?,
+                      overtime_taken_hours = ?, vacation_type = ?, sick_status = ?,
+                      updated_at = CURRENT_TIMESTAMP
+                  WHERE id = ?`,
+            [
+              finalStartTime, finalEndTime, break_minutes, total_hours, notes,
+              finalActivity1Desc || null, finalActivity1Hours, activity1_project_number || null,
+              finalActivity2Desc || null, parseFloat(activity2_hours) || 0, activity2_project_number || null,
+              finalActivity3Desc || null, parseFloat(activity3_hours) || 0, activity3_project_number || null,
+              finalActivity4Desc || null, parseFloat(activity4_hours) || 0, activity4_project_number || null,
+              finalActivity5Desc || null, parseFloat(activity5_hours) || 0, activity5_project_number || null,
+              overtime_taken_hours ? parseFloat(overtime_taken_hours) : null,
+              vacation_type || null,
+              isSick ? 1 : 0,
+              row.id
+            ],
+            (err) => {
+              if (err) {
+                console.error('Fehler beim Update:', err);
+                return res.status(500).json({ error: 'Fehler beim Speichern: ' + err.message });
+              }
+              res.json({ success: true, total_hours });
+            });
+        } else {
+          // Insert
+          db.run(`INSERT INTO timesheet_entries 
+                  (user_id, date, start_time, end_time, break_minutes, total_hours, notes,
+                   activity1_desc, activity1_hours, activity1_project_number,
+                   activity2_desc, activity2_hours, activity2_project_number,
+                   activity3_desc, activity3_hours, activity3_project_number,
+                   activity4_desc, activity4_hours, activity4_project_number,
+                   activity5_desc, activity5_hours, activity5_project_number,
+                   overtime_taken_hours, vacation_type, sick_status)
+                  VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+            [
+              userId, date, finalStartTime, finalEndTime, break_minutes, total_hours, notes,
+              finalActivity1Desc || null, finalActivity1Hours, activity1_project_number || null,
+              finalActivity2Desc || null, parseFloat(activity2_hours) || 0, activity2_project_number || null,
+              finalActivity3Desc || null, parseFloat(activity3_hours) || 0, activity3_project_number || null,
+              finalActivity4Desc || null, parseFloat(activity4_hours) || 0, activity4_project_number || null,
+              finalActivity5Desc || null, parseFloat(activity5_hours) || 0, activity5_project_number || null,
+              overtime_taken_hours ? parseFloat(overtime_taken_hours) : null,
+              vacation_type || null,
+              isSick ? 1 : 0
+            ],
+            (err) => {
+              if (err) {
+                console.error('Fehler beim Insert:', err);
+                return res.status(500).json({ error: 'Fehler beim Speichern: ' + err.message });
+              }
+              res.json({ success: true, total_hours });
+            });
+        }
+      });
+    });
+  });
+
+  // API: Stundenerfassung für Woche laden
+  app.get('/api/timesheet/week/:weekStart', requireAuth, (req, res) => {
+    const userId = req.session.userId;
+    const weekStart = req.params.weekStart;
+    
+    // Berechne Wochenende
+    const startDate = new Date(weekStart);
+    const endDate = new Date(startDate);
+    endDate.setDate(endDate.getDate() + 6);
+    const weekEnd = endDate.toISOString().split('T')[0];
+    
+    // Prüfe ob die Woche bereits eingereicht wurde (aber ermögliche Bearbeitung)
+    db.get(`SELECT id, version FROM weekly_timesheets 
+            WHERE user_id = ? AND week_start = ? AND week_end = ?
+            ORDER BY version DESC LIMIT 1`,
+      [userId, weekStart, weekEnd],
+      (err, weeklySheet) => {
+        const hasSubmittedVersion = !!weeklySheet;
+        const latestVersion = weeklySheet ? weeklySheet.version : 0;
+        
+        // Lade alle Einträge für die Woche
+        db.all(`SELECT * FROM timesheet_entries 
+                WHERE user_id = ? AND date >= ? AND date <= ?
+                ORDER BY date`,
+          [userId, weekStart, weekEnd],
+          (err, entries) => {
+            // Füge Status-Info hinzu (Bearbeitung ist immer möglich)
+            const entriesWithStatus = (entries || []).map(entry => ({
+              ...entry,
+              week_submitted: false, // Immer false, damit Bearbeitung möglich ist
+              latest_version: latestVersion,
+              has_existing_version: latestVersion > 0
+            }));
+            res.json(entriesWithStatus);
+          });
+      });
+  });
+
+  // API: Woche abschicken
+  app.post('/api/timesheet/submit', requireAuth, (req, res) => {
+    const { week_start, week_end, version_reason } = req.body;
+    const userId = req.session.userId;
+    
+    // Validierung: Prüfen ob alle 7 Tage der Woche ausgefüllt sind
+    db.all(`SELECT id, date, start_time, end_time, vacation_type, sick_status, updated_at FROM timesheet_entries 
+            WHERE user_id = ? AND date >= ? AND date <= ?
+            ORDER BY date, updated_at DESC, id DESC`,
+      [userId, week_start, week_end],
+      (err, entries) => {
+        if (err) {
+          return res.status(500).json({ error: 'Fehler beim Prüfen der Daten' });
+        }
+        
+        // Erstelle Set mit vorhandenen Daten
+        // WICHTIG: Wenn mehrere Einträge für denselben Tag existieren, nimm den neuesten
+        const entriesByDate = {};
+        entries.forEach(entry => {
+          const existing = entriesByDate[entry.date];
+          // Wenn noch kein Eintrag existiert oder dieser neuer ist, verwende ihn
+          if (!existing) {
+            entriesByDate[entry.date] = entry;
+          } else {
+            // Vergleiche updated_at (falls vorhanden) oder id (höhere ID = neuer)
+            const existingTime = existing.updated_at ? new Date(existing.updated_at).getTime() : 0;
+            const currentTime = entry.updated_at ? new Date(entry.updated_at).getTime() : 0;
+            if (currentTime > existingTime || (currentTime === existingTime && entry.id > existing.id)) {
+              entriesByDate[entry.date] = entry;
+            }
+          }
+        });
+        
+        // Prüfe nur Werktage (Montag-Freitag, erste 5 Tage)
+        // Samstag und Sonntag sind optional
+        // Bei ganztägigem Urlaub (vacation_type = 'full') ist der Tag als ausgefüllt zu betrachten
+        // week_start ist bereits im Format YYYY-MM-DD
+        const startDateParts = week_start.split('-');
+        const startYear = parseInt(startDateParts[0]);
+        const startMonth = parseInt(startDateParts[1]) - 1; // Monat ist 0-basiert
+        const startDay = parseInt(startDateParts[2]);
+        
+        let missingDays = [];
+        
+        for (let i = 0; i < 5; i++) {
+          // Datum direkt berechnen ohne Zeitzonenprobleme
+          const date = new Date(startYear, startMonth, startDay + i);
+          const year = date.getFullYear();
+          const month = String(date.getMonth() + 1).padStart(2, '0');
+          const day = String(date.getDate()).padStart(2, '0');
+          const dateStr = `${year}-${month}-${day}`;
+          const entry = entriesByDate[dateStr];
+          
+          // Wenn ganztägiger Urlaub oder Krank, dann ist der Tag als ausgefüllt zu betrachten
+          const isSick = entry && (entry.sick_status === 1 || entry.sick_status === true);
+          if (entry && (entry.vacation_type === 'full' || isSick)) {
+            continue; // Tag ist ausgefüllt
+          }
+          
+          // Bei halbem Tag Urlaub oder keinem Urlaub müssen Start- und Endzeit vorhanden sein
+          // start_time und end_time könnten null, undefined oder leer strings sein
+          const hasStartTime = entry && entry.start_time && entry.start_time.toString().trim() !== '';
+          const hasEndTime = entry && entry.end_time && entry.end_time.toString().trim() !== '';
+          
+          if (!entry || !hasStartTime || !hasEndTime) {
+            missingDays.push(dateStr);
+          }
+        }
+        
+        if (missingDays.length > 0) {
+          return res.status(400).json({ 
+            error: `Nicht alle Werktage (Montag bis Freitag) sind ausgefüllt. Fehlende Tage: ${missingDays.join(', ')}. Bitte füllen Sie alle Werktage mit Start- und Endzeit aus. Wochenende ist optional.` 
+          });
+        }
+        
+        // Alle Tage ausgefüllt - Woche abschicken (immer neue Version erstellen)
+        // Prüfe welche Version die letzte ist
+        db.get(`SELECT MAX(version) as max_version FROM weekly_timesheets 
+                WHERE user_id = ? AND week_start = ? AND week_end = ?`,
+          [userId, week_start, week_end],
+          (err, result) => {
+            if (err) return res.status(500).json({ error: 'Fehler beim Prüfen der Version' });
+            
+            const maxVersion = result && result.max_version ? result.max_version : 0;
+            const newVersion = maxVersion + 1;
+            
+            // Wenn bereits eine Version existiert, ist version_reason erforderlich
+            if (maxVersion > 0 && (!version_reason || version_reason.trim() === '')) {
+              return res.status(400).json({ 
+                error: 'Bitte geben Sie einen Grund für die neue Version an.' 
+              });
+            }
+            
+            // Neue Version erstellen (nicht überschreiben)
+            db.run(`INSERT INTO weekly_timesheets (user_id, week_start, week_end, version, status, version_reason)
+                    VALUES (?, ?, ?, ?, 'eingereicht', ?)`,
+              [userId, week_start, week_end, newVersion, version_reason ? version_reason.trim() : null],
+              (err) => {
+                if (err) return res.status(500).json({ error: 'Fehler beim Abschicken' });
+                
+                // Status der Einträge aktualisieren (optional - für Nachverfolgung)
+                db.run(`UPDATE timesheet_entries 
+                        SET status = 'eingereicht'
+                        WHERE user_id = ? AND date >= ? AND date <= ?`,
+                  [userId, week_start, week_end],
+                  (err) => {
+                    if (err) return res.status(500).json({ error: 'Fehler beim Aktualisieren des Status' });
+                    res.json({ success: true, version: newVersion });
+                  });
+              });
+          });
+      });
+  });
+
+  // API: PDF Download-Info abrufen
+  app.get('/api/timesheet/download-info/:id', requireVerwaltung, (req, res) => {
+    const timesheetId = req.params.id;
+    
+    db.get(`SELECT wt.pdf_downloaded_at, 
+                   dl.firstname as downloaded_by_firstname,
+                   dl.lastname as downloaded_by_lastname
+            FROM weekly_timesheets wt
+            LEFT JOIN users dl ON wt.pdf_downloaded_by = dl.id
+            WHERE wt.id = ?`, [timesheetId], (err, result) => {
+      
+      if (err) {
+        console.error('Fehler beim Abrufen der Download-Info:', err);
+        return res.status(500).json({ error: 'Fehler beim Abrufen der Informationen' });
+      }
+      
+      if (!result) {
+        return res.status(404).json({ error: 'Stundenzettel nicht gefunden' });
+      }
+      
+      res.json({
+        downloaded: !!result.pdf_downloaded_at,
+        downloaded_at: result.pdf_downloaded_at,
+        downloaded_by_firstname: result.downloaded_by_firstname,
+        downloaded_by_lastname: result.downloaded_by_lastname
+      });
+    });
+  });
+
+  // API: PDF generieren
+  app.get('/api/timesheet/pdf/:id', requireVerwaltung, (req, res) => {
+    const timesheetId = req.params.id;
+    generatePDF(timesheetId, req, res);
+  });
+}
+
+module.exports = registerTimesheetRoutes;

routes/user.js

@@ -0,0 +1,310 @@
+// User API Routes
+
+const { db } = require('../database');
+const { hasRole, getCurrentDate } = require('../helpers/utils');
+const { requireAuth } = require('../middleware/auth');
+
+// Routes registrieren
+function registerUserRoutes(app) {
+  // API: Letzte bearbeitete Woche abrufen
+  app.get('/api/user/last-week', requireAuth, (req, res) => {
+    const userId = req.session.userId;
+    
+    db.get('SELECT last_week_start FROM users WHERE id = ?', [userId], (err, user) => {
+      if (err) {
+        return res.status(500).json({ error: 'Fehler beim Abrufen der letzten Woche' });
+      }
+      
+      res.json({ last_week_start: user?.last_week_start || null });
+    });
+  });
+
+  // API: Letzte bearbeitete Woche speichern
+  app.post('/api/user/last-week', requireAuth, (req, res) => {
+    const userId = req.session.userId;
+    const { week_start } = req.body;
+    
+    if (!week_start) {
+      return res.status(400).json({ error: 'week_start ist erforderlich' });
+    }
+    
+    db.run('UPDATE users SET last_week_start = ? WHERE id = ?', 
+      [week_start, userId], 
+      (err) => {
+        if (err) {
+          return res.status(500).json({ error: 'Fehler beim Speichern der letzten Woche' });
+        }
+        res.json({ success: true });
+      });
+  });
+
+  // API: User-Daten abrufen (Wochenstunden)
+  app.get('/api/user/data', requireAuth, (req, res) => {
+    const userId = req.session.userId;
+    
+    db.get('SELECT wochenstunden FROM users WHERE id = ?', [userId], (err, user) => {
+      if (err) {
+        return res.status(500).json({ error: 'Fehler beim Abrufen der User-Daten' });
+      }
+      
+      res.json({ wochenstunden: user?.wochenstunden || 0 });
+    });
+  });
+
+  // API: Ping-IP abrufen
+  app.get('/api/user/ping-ip', requireAuth, (req, res) => {
+    const userId = req.session.userId;
+    
+    db.get('SELECT ping_ip FROM users WHERE id = ?', [userId], (err, user) => {
+      if (err) {
+        return res.status(500).json({ error: 'Fehler beim Abrufen der IP-Adresse' });
+      }
+      
+      res.json({ ping_ip: user?.ping_ip || null });
+    });
+  });
+
+  // API: Ping-IP speichern
+  app.post('/api/user/ping-ip', requireAuth, (req, res) => {
+    const userId = req.session.userId;
+    const { ping_ip } = req.body;
+    
+    // Validierung: IPv4 Format (einfache Prüfung)
+    const ipv4Regex = /^(\d{1,3}\.){3}\d{1,3}$/;
+    if (ping_ip && ping_ip.trim() !== '' && !ipv4Regex.test(ping_ip.trim())) {
+      return res.status(400).json({ error: 'Ungültige IP-Adresse. Bitte geben Sie eine gültige IPv4-Adresse ein.' });
+    }
+    
+    // Normalisiere: Leere Strings werden zu null
+    const normalizedPingIp = (ping_ip && ping_ip.trim() !== '') ? ping_ip.trim() : null;
+    
+    db.run('UPDATE users SET ping_ip = ? WHERE id = ?', [normalizedPingIp, userId], (err) => {
+      if (err) {
+        return res.status(500).json({ error: 'Fehler beim Speichern der IP-Adresse' });
+      }
+      
+      // Wenn IP entfernt wurde, lösche auch den Ping-Status für heute
+      if (!normalizedPingIp) {
+        const currentDate = getCurrentDate();
+        db.run('DELETE FROM ping_status WHERE user_id = ? AND date = ?', [userId, currentDate], (err) => {
+          // Fehler ignorieren
+        });
+      }
+      
+      res.json({ success: true, ping_ip: normalizedPingIp });
+    });
+  });
+
+  // API: Rollenwechsel
+  app.post('/api/user/switch-role', requireAuth, (req, res) => {
+    const { role } = req.body;
+    
+    if (!role) {
+      return res.status(400).json({ error: 'Rolle ist erforderlich' });
+    }
+    
+    // Prüfe ob User diese Rolle hat
+    if (!hasRole(req, role)) {
+      return res.status(403).json({ error: 'Sie haben keine Berechtigung für diese Rolle' });
+    }
+    
+    // Validiere dass die Rolle eine gültige Rolle ist
+    const validRoles = ['mitarbeiter', 'verwaltung', 'admin'];
+    if (!validRoles.includes(role)) {
+      return res.status(400).json({ error: 'Ungültige Rolle' });
+    }
+    
+    // Setze aktuelle Rolle
+    req.session.currentRole = role;
+    
+    res.json({ success: true, currentRole: role });
+  });
+
+  // API: Gesamtstatistiken für Mitarbeiter (Überstunden und Urlaubstage)
+  app.get('/api/user/stats', requireAuth, (req, res) => {
+    const userId = req.session.userId;
+    
+    // User-Daten abrufen
+    db.get('SELECT wochenstunden, urlaubstage FROM users WHERE id = ?', [userId], (err, user) => {
+      if (err || !user) {
+        return res.status(500).json({ error: 'Fehler beim Abrufen der User-Daten' });
+      }
+      
+      const wochenstunden = user.wochenstunden || 0;
+      const urlaubstage = user.urlaubstage || 0;
+      
+      // Alle eingereichten Wochen abrufen
+      db.all(`SELECT DISTINCT week_start, week_end 
+              FROM weekly_timesheets 
+              WHERE user_id = ? AND status = 'eingereicht'
+              ORDER BY week_start`,
+        [userId],
+        (err, weeks) => {
+          if (err) {
+            return res.status(500).json({ error: 'Fehler beim Abrufen der Wochen' });
+          }
+          
+          // Wenn keine Wochen vorhanden
+          if (!weeks || weeks.length === 0) {
+            return res.json({
+              currentOvertime: 0,
+              remainingVacation: urlaubstage,
+              totalOvertimeHours: 0,
+              totalOvertimeTaken: 0,
+              totalVacationDays: 0,
+              urlaubstage: urlaubstage
+            });
+          }
+          
+          let totalOvertimeHours = 0;
+          let totalOvertimeTaken = 0;
+          let totalVacationDays = 0;
+          let processedWeeks = 0;
+          let hasError = false;
+          
+          // Für jede Woche die Statistiken berechnen
+          weeks.forEach((week) => {
+            // Einträge für diese Woche abrufen (nur neueste pro Tag)
+            db.all(`SELECT id, date, total_hours, overtime_taken_hours, vacation_type, sick_status, start_time, end_time, updated_at
+                    FROM timesheet_entries 
+                    WHERE user_id = ? AND date >= ? AND date <= ?
+                    ORDER BY date, updated_at DESC, id DESC`,
+              [userId, week.week_start, week.week_end],
+              (err, allEntries) => {
+                if (hasError) return; // Wenn bereits ein Fehler aufgetreten ist, ignoriere weitere Ergebnisse
+                
+                if (err) {
+                  hasError = true;
+                  return res.status(500).json({ error: 'Fehler beim Abrufen der Einträge' });
+                }
+                
+                // Filtere auf neuesten Eintrag pro Tag
+                const entriesByDate = {};
+                (allEntries || []).forEach(entry => {
+                  const existing = entriesByDate[entry.date];
+                  if (!existing) {
+                    entriesByDate[entry.date] = entry;
+                  } else {
+                    // Vergleiche updated_at (falls vorhanden) oder id (höhere ID = neuer)
+                    const existingTime = existing.updated_at ? new Date(existing.updated_at).getTime() : 0;
+                    const currentTime = entry.updated_at ? new Date(entry.updated_at).getTime() : 0;
+                    if (currentTime > existingTime || (currentTime === existingTime && entry.id > existing.id)) {
+                      entriesByDate[entry.date] = entry;
+                    }
+                  }
+                });
+                
+                // Konvertiere zurück zu Array
+                const entries = Object.values(entriesByDate);
+                
+                // Prüfe ob Woche vollständig ausgefüllt ist (alle 5 Werktage)
+                
+                // Prüfe alle 5 Werktage (Montag-Freitag)
+                const startDate = new Date(week.week_start);
+                const endDate = new Date(week.week_end);
+                let workdays = 0;
+                let filledWorkdays = 0;
+                
+                for (let d = new Date(startDate); d <= endDate; d.setDate(d.getDate() + 1)) {
+                  const day = d.getDay();
+                  if (day >= 1 && day <= 5) { // Montag bis Freitag
+                    workdays++;
+                    const dateStr = d.toISOString().split('T')[0];
+                    const entry = entriesByDate[dateStr];
+                    
+                    // Tag gilt als ausgefüllt wenn:
+                    // - Ganzer Tag Urlaub (vacation_type = 'full')
+                    // - Krank (sick_status = 1)
+                    // - ODER Start- und End-Zeit vorhanden sind
+                    if (entry) {
+                      const isFullDayVacation = entry.vacation_type === 'full';
+                      const isSick = entry.sick_status === 1 || entry.sick_status === true;
+                      const hasStartAndEnd = entry.start_time && entry.end_time && 
+                                            entry.start_time.toString().trim() !== '' && 
+                                            entry.end_time.toString().trim() !== '';
+                      
+                      if (isFullDayVacation || isSick || hasStartAndEnd) {
+                        filledWorkdays++;
+                      }
+                    }
+                  }
+                }
+                
+                // Nur berechnen wenn alle Werktage ausgefüllt sind
+                if (filledWorkdays < workdays) {
+                  // Woche nicht vollständig - überspringe diese Woche
+                  processedWeeks++;
+                  if (processedWeeks === weeks.length && !hasError) {
+                    const currentOvertime = totalOvertimeHours - totalOvertimeTaken;
+                    const remainingVacation = urlaubstage - totalVacationDays;
+                    
+                    res.json({
+                      currentOvertime: currentOvertime,
+                      remainingVacation: remainingVacation,
+                      totalOvertimeHours: totalOvertimeHours,
+                      totalOvertimeTaken: totalOvertimeTaken,
+                      totalVacationDays: totalVacationDays,
+                      urlaubstage: urlaubstage
+                    });
+                  }
+                  return; // Überspringe diese Woche
+                }
+                
+                // Berechnungen für diese Woche (nur wenn vollständig ausgefüllt)
+                let weekTotalHours = 0;
+                let weekOvertimeTaken = 0;
+                let weekVacationDays = 0;
+                let weekVacationHours = 0;
+                
+                entries.forEach(entry => {
+                  if (entry.total_hours) {
+                    weekTotalHours += entry.total_hours;
+                  }
+                  if (entry.overtime_taken_hours) {
+                    weekOvertimeTaken += entry.overtime_taken_hours;
+                  }
+                  if (entry.vacation_type === 'full') {
+                    weekVacationDays += 1;
+                    weekVacationHours += 8;
+                  } else if (entry.vacation_type === 'half') {
+                    weekVacationDays += 0.5;
+                    weekVacationHours += 4;
+                  }
+                });
+                
+                // Sollstunden berechnen
+                const sollStunden = (wochenstunden / 5) * workdays;
+                
+                // Überstunden für diese Woche: Urlaub zählt als normale Arbeitszeit
+                const weekTotalHoursWithVacation = weekTotalHours + weekVacationHours;
+                const weekOvertimeHours = weekTotalHoursWithVacation - sollStunden;
+                
+                // Kumulativ addieren
+                totalOvertimeHours += weekOvertimeHours;
+                totalOvertimeTaken += weekOvertimeTaken;
+                totalVacationDays += weekVacationDays;
+                
+                processedWeeks++;
+                
+                // Wenn alle Wochen verarbeitet wurden, Antwort senden
+                if (processedWeeks === weeks.length && !hasError) {
+                  const currentOvertime = totalOvertimeHours - totalOvertimeTaken;
+                  const remainingVacation = urlaubstage - totalVacationDays;
+                  
+                  res.json({
+                    currentOvertime: currentOvertime,
+                    remainingVacation: remainingVacation,
+                    totalOvertimeHours: totalOvertimeHours,
+                    totalOvertimeTaken: totalOvertimeTaken,
+                    totalVacationDays: totalVacationDays,
+                    urlaubstage: urlaubstage
+                  });
+                }
+              });
+          });
+        });
+    });
+  });
+}
+
+module.exports = registerUserRoutes;

routes/verwaltung.js

@@ -0,0 +1,195 @@
+// Verwaltung Routes
+
+const { db } = require('../database');
+const { requireVerwaltung } = require('../middleware/auth');
+
+// Routes registrieren
+function registerVerwaltungRoutes(app) {
+  // Verwaltungs-Bereich
+  app.get('/verwaltung', requireVerwaltung, (req, res) => {
+    db.all(`
+      SELECT wt.*, u.firstname, u.lastname, u.username, u.personalnummer, u.wochenstunden, u.urlaubstage,
+             dl.firstname as downloaded_by_firstname,
+             dl.lastname as downloaded_by_lastname,
+             (SELECT COUNT(*) FROM weekly_timesheets wt2 
+              WHERE wt2.user_id = wt.user_id 
+              AND wt2.week_start = wt.week_start 
+              AND wt2.week_end = wt.week_end) as total_versions
+      FROM weekly_timesheets wt
+      JOIN users u ON wt.user_id = u.id
+      LEFT JOIN users dl ON wt.pdf_downloaded_by = dl.id
+      WHERE wt.status = 'eingereicht'
+      ORDER BY wt.week_start DESC, wt.user_id, wt.version DESC
+    `, (err, timesheets) => {
+      // Gruppiere nach Mitarbeiter, dann nach Kalenderwoche
+      // Struktur: { [user_id]: { user: {...}, weeks: { [week_key]: {...} } } }
+      const groupedByEmployee = {};
+      
+      (timesheets || []).forEach(ts => {
+        const userId = ts.user_id;
+        const weekKey = `${ts.week_start}_${ts.week_end}`;
+        
+        // Level 1: Mitarbeiter
+        if (!groupedByEmployee[userId]) {
+          groupedByEmployee[userId] = {
+            user: {
+              id: ts.user_id,
+              firstname: ts.firstname,
+              lastname: ts.lastname,
+              username: ts.username,
+              personalnummer: ts.personalnummer,
+              wochenstunden: ts.wochenstunden,
+              urlaubstage: ts.urlaubstage
+            },
+            weeks: {}
+          };
+        }
+        
+        // Level 2: Kalenderwoche
+        if (!groupedByEmployee[userId].weeks[weekKey]) {
+          groupedByEmployee[userId].weeks[weekKey] = {
+            week_start: ts.week_start,
+            week_end: ts.week_end,
+            total_versions: ts.total_versions,
+            versions: []
+          };
+        }
+        
+        // Level 3: Versionen
+        groupedByEmployee[userId].weeks[weekKey].versions.push(ts);
+      });
+      
+      // Sortierung: Mitarbeiter nach Name, Wochen nach Datum (neueste zuerst)
+      const sortedEmployees = Object.values(groupedByEmployee).map(employee => {
+        // Wochen innerhalb jedes Mitarbeiters sortieren
+        const sortedWeeks = Object.values(employee.weeks).sort((a, b) => {
+          return new Date(b.week_start) - new Date(a.week_start);
+        });
+        
+        return {
+          ...employee,
+          weeks: sortedWeeks
+        };
+      }).sort((a, b) => {
+        // Mitarbeiter nach Nachname, dann Vorname sortieren
+        const nameA = `${a.user.lastname} ${a.user.firstname}`.toLowerCase();
+        const nameB = `${b.user.lastname} ${b.user.firstname}`.toLowerCase();
+        return nameA.localeCompare(nameB);
+      });
+      
+      res.render('verwaltung', { 
+        groupedByEmployee: sortedEmployees,
+        user: {
+          firstname: req.session.firstname,
+          lastname: req.session.lastname,
+          roles: req.session.roles || [],
+          currentRole: req.session.currentRole || 'verwaltung'
+        }
+      });
+    });
+  });
+
+  // API: Überstunden- und Urlaubsstatistiken für einen User abrufen
+  app.get('/api/verwaltung/user/:id/stats', requireVerwaltung, (req, res) => {
+    const userId = req.params.id;
+    const { week_start, week_end } = req.query;
+    
+    // User-Daten abrufen
+    db.get('SELECT wochenstunden, urlaubstage FROM users WHERE id = ?', [userId], (err, user) => {
+      if (err || !user) {
+        return res.status(500).json({ error: 'Fehler beim Abrufen der User-Daten' });
+      }
+      
+      const wochenstunden = user.wochenstunden || 0;
+      const urlaubstage = user.urlaubstage || 0;
+      
+      // Einträge für die Woche abrufen
+      db.all(`SELECT date, total_hours, overtime_taken_hours, vacation_type 
+              FROM timesheet_entries 
+              WHERE user_id = ? AND date >= ? AND date <= ?
+              ORDER BY date`,
+        [userId, week_start, week_end],
+        (err, entries) => {
+          if (err) {
+            return res.status(500).json({ error: 'Fehler beim Abrufen der Einträge' });
+          }
+          
+          // Berechnungen
+          let totalHours = 0;
+          let overtimeTaken = 0;
+          let vacationDays = 0;
+          let vacationHours = 0;
+          
+          entries.forEach(entry => {
+            if (entry.total_hours) {
+              totalHours += entry.total_hours;
+            }
+            if (entry.overtime_taken_hours) {
+              overtimeTaken += entry.overtime_taken_hours;
+            }
+            if (entry.vacation_type === 'full') {
+              vacationDays += 1;
+              vacationHours += 8; // Ganzer Tag = 8 Stunden
+            } else if (entry.vacation_type === 'half') {
+              vacationDays += 0.5;
+              vacationHours += 4; // Halber Tag = 4 Stunden
+            }
+          });
+          
+          // Anzahl Werktage berechnen (Montag-Freitag)
+          const startDate = new Date(week_start);
+          const endDate = new Date(week_end);
+          let workdays = 0;
+          for (let d = new Date(startDate); d <= endDate; d.setDate(d.getDate() + 1)) {
+            const day = d.getDay();
+            if (day >= 1 && day <= 5) { // Montag bis Freitag
+              workdays++;
+            }
+          }
+          
+          // Sollstunden berechnen
+          const sollStunden = (wochenstunden / 5) * workdays;
+          
+          // Überstunden berechnen: Urlaub zählt als normale Arbeitszeit
+          // Überstunden = (Tatsächliche Stunden + Urlaubsstunden) - Sollstunden
+          const totalHoursWithVacation = totalHours + vacationHours;
+          const overtimeHours = totalHoursWithVacation - sollStunden;
+          const remainingOvertime = overtimeHours - overtimeTaken;
+          
+          // Verbleibende Urlaubstage
+          const remainingVacation = urlaubstage - vacationDays;
+          
+          res.json({
+            wochenstunden,
+            urlaubstage,
+            totalHours,
+            sollStunden,
+            overtimeHours,
+            overtimeTaken,
+            remainingOvertime,
+            vacationDays,
+            remainingVacation,
+            workdays
+          });
+        });
+    });
+  });
+
+  // API: Admin-Kommentar speichern
+  app.put('/api/verwaltung/timesheet/:id/comment', requireVerwaltung, (req, res) => {
+    const timesheetId = req.params.id;
+    const { comment } = req.body;
+    
+    db.run('UPDATE weekly_timesheets SET admin_comment = ? WHERE id = ?',
+      [comment ? comment.trim() : null, timesheetId],
+      (err) => {
+        if (err) {
+          console.error('Fehler beim Speichern des Kommentars:', err);
+          return res.status(500).json({ error: 'Fehler beim Speichern des Kommentars' });
+        }
+        res.json({ success: true });
+      });
+  });
+}
+
+module.exports = registerVerwaltungRoutes;