Add sick routes to backend and frontend; update routing and UI components for sickness tracking

backend/src/controllers/SickController.js

@@ -0,0 +1,92 @@
+const SickService = require('../services/SickService');
+
+/**
+ * Controller für Krankheitseinträge
+ * Verarbeitet HTTP-Requests und delegiert an SickService
+ */
+class SickController {
+  /**
+   * Holt alle Krankheitseinträge für den aktuellen User
+   */
+  async getAllSickEntries(req, res) {
+    try {
+      const userId = req.user?.id || 1;
+      const sickEntries = await SickService.getAllSickEntries(userId);
+      res.json(sickEntries);
+    } catch (error) {
+      console.error('Fehler beim Abrufen der Krankheitseinträge:', error);
+      res.status(500).json({ 
+        message: 'Fehler beim Abrufen der Krankheitseinträge',
+        error: error.message 
+      });
+    }
+  }
+
+  /**
+   * Holt alle verfügbaren Krankheitstypen
+   */
+  async getSickTypes(req, res) {
+    try {
+      const types = await SickService.getSickTypes();
+      res.json(types);
+    } catch (error) {
+      console.error('Fehler beim Abrufen der Krankheitstypen:', error);
+      res.status(500).json({ 
+        message: 'Fehler beim Abrufen der Krankheitstypen',
+        error: error.message 
+      });
+    }
+  }
+
+  /**
+   * Erstellt einen neuen Krankheitseintrag
+   */
+  async createSickEntry(req, res) {
+    try {
+      const userId = req.user?.id || 1;
+      const { sickTypeId, startDate, endDate } = req.body;
+      
+      console.log('DEBUG createSickEntry:', { sickTypeId, startDate, endDate, body: req.body });
+      
+      if (!sickTypeId || !startDate) {
+        return res.status(400).json({ 
+          message: 'Krankheitstyp und Startdatum sind erforderlich' 
+        });
+      }
+      
+      const sick = await SickService.createSickEntry(userId, sickTypeId, startDate, endDate);
+      res.status(201).json(sick);
+    } catch (error) {
+      console.error('Fehler beim Erstellen des Krankheitseintrags:', error);
+      res.status(500).json({ 
+        message: 'Fehler beim Erstellen des Krankheitseintrags',
+        error: error.message 
+      });
+    }
+  }
+
+  /**
+   * Löscht einen Krankheitseintrag
+   */
+  async deleteSickEntry(req, res) {
+    try {
+      const userId = req.user?.id || 1;
+      const sickId = parseInt(req.params.id);
+      
+      if (isNaN(sickId)) {
+        return res.status(400).json({ message: 'Ungültige ID' });
+      }
+      
+      await SickService.deleteSickEntry(userId, sickId);
+      res.json({ message: 'Krankheitseintrag gelöscht' });
+    } catch (error) {
+      console.error('Fehler beim Löschen des Krankheitseintrags:', error);
+      res.status(error.message.includes('nicht gefunden') ? 404 : 500).json({ 
+        message: error.message 
+      });
+    }
+  }
+}
+
+module.exports = new SickController();
+

backend/src/index.js

@@ -74,6 +74,10 @@ app.use('/api/timefix', authenticateToken, timefixRouter);
 const vacationRouter = require('./routes/vacation');
 app.use('/api/vacation', authenticateToken, vacationRouter);
 
+// Sick routes (geschützt) - MIT ID-Hashing
+const sickRouter = require('./routes/sick');
+app.use('/api/sick', authenticateToken, sickRouter);
+
 // Error handling middleware
 app.use((err, req, res, next) => {
   console.error(err.stack);

backend/src/routes/sick.js

@@ -0,0 +1,23 @@
+const express = require('express');
+const router = express.Router();
+const SickController = require('../controllers/SickController');
+const unhashRequestIds = require('../middleware/unhashRequest');
+
+/**
+ * Routen für Krankheitseinträge
+ */
+
+// GET /api/sick - Alle Krankheitseinträge abrufen
+router.get('/', SickController.getAllSickEntries.bind(SickController));
+
+// GET /api/sick/types - Alle Krankheitstypen abrufen (MIT ID-Hashing)
+router.get('/types', SickController.getSickTypes.bind(SickController));
+
+// POST /api/sick - Neuen Krankheitseintrag erstellen (mit unhashing)
+router.post('/', unhashRequestIds, SickController.createSickEntry.bind(SickController));
+
+// DELETE /api/sick/:id - Krankheitseintrag löschen
+router.delete('/:id', unhashRequestIds, SickController.deleteSickEntry.bind(SickController));
+
+module.exports = router;
+

backend/src/services/SickService.js

@@ -0,0 +1,169 @@
+const database = require('../config/database');
+const { Op } = require('sequelize');
+
+/**
+ * Service-Klasse für Krankheitseinträge
+ * Enthält die gesamte Business-Logik für Sick
+ */
+class SickService {
+  constructor() {
+    this.defaultUserId = 1;
+  }
+
+  /**
+   * Holt alle Krankheitseinträge für einen User
+   * Zeigt dieses Jahr und die letzten 3 Monate
+   * @param {number} userId - Benutzer-ID
+   * @returns {Promise<Array>} Array von Krankheitseinträgen
+   */
+  async getAllSickEntries(userId) {
+    const { Sick, SickType } = database.getModels();
+    
+    const now = new Date();
+    const currentYear = now.getFullYear();
+    
+    // Berechne das Datum von vor 3 Monaten
+    const threeMonthsAgo = new Date(now);
+    threeMonthsAgo.setMonth(now.getMonth() - 3);
+    
+    // Nimm das frühere Datum (was weiter zurück liegt): Entweder Jahresanfang oder 3 Monate zurück
+    const yearStart = new Date(currentYear, 0, 1); // 1. Januar dieses Jahres
+    const startDate = yearStart < threeMonthsAgo ? yearStart : threeMonthsAgo;
+    
+    const startDateStr = `${startDate.getFullYear()}-${String(startDate.getMonth() + 1).padStart(2, '0')}-${String(startDate.getDate()).padStart(2, '0')}`;
+    
+    const sickEntries = await Sick.findAll({
+      where: {
+        user_id: userId,
+        first_day: {
+          [Op.gte]: startDateStr
+        }
+      },
+      include: [
+        {
+          model: SickType,
+          as: 'sickType',
+          attributes: ['id', 'description']
+        }
+      ],
+      order: [['first_day', 'DESC']],
+      raw: true,
+      nest: true
+    });
+    
+    // Mapping: Englisch -> Deutsch
+    const typeNames = {
+      'self': 'Selbst',
+      'child': 'Kinder',
+      'parents': 'Eltern',
+      'partner': 'Partner'
+    };
+    
+    // Formatiere die Daten
+    return sickEntries.map(sick => ({
+      id: sick.id,
+      startDate: sick.first_day,
+      endDate: sick.last_day,
+      sickTypeId: sick.sick_type_id,
+      sickTypeName: typeNames[sick.sickType?.description] || sick.sickType?.description || 'Unbekannt'
+    }));
+  }
+
+  /**
+   * Holt alle verfügbaren Krankheitstypen
+   * @returns {Promise<Array>} Array von Krankheitstypen
+   */
+  async getSickTypes() {
+    const { SickType } = database.getModels();
+    
+    const types = await SickType.findAll({
+      order: [['id', 'ASC']],
+      raw: true
+    });
+    
+    // Mapping: Englisch -> Deutsch
+    const typeNames = {
+      'self': 'Selbst',
+      'child': 'Kinder',
+      'parents': 'Eltern',
+      'partner': 'Partner'
+    };
+    
+    return types.map(type => ({
+      id: type.id,
+      name: typeNames[type.description] || type.description
+    }));
+  }
+
+  /**
+   * Erstellt einen neuen Krankheitseintrag
+   * @param {number} userId - Benutzer-ID
+   * @param {number} sickTypeId - Krankheitstyp-ID
+   * @param {string} startDate - Startdatum (YYYY-MM-DD)
+   * @param {string} endDate - Enddatum (YYYY-MM-DD)
+   * @returns {Promise<Object>} Erstellter Krankheitseintrag
+   */
+  async createSickEntry(userId, sickTypeId, startDate, endDate) {
+    const { Sick, SickType } = database.getModels();
+    
+    if (!endDate) {
+      endDate = startDate; // Falls kein Enddatum: Single-Day
+    }
+    
+    // Prüfe ob SickType existiert
+    const sickType = await SickType.findByPk(sickTypeId);
+    if (!sickType) {
+      throw new Error('Ungültiger Krankheitstyp');
+    }
+    
+    const sick = await Sick.create({
+      user_id: userId,
+      sick_type_id: sickTypeId,
+      first_day: startDate,
+      last_day: endDate,
+      version: 0
+    });
+    
+    // Mapping: Englisch -> Deutsch
+    const typeNames = {
+      'self': 'Selbst',
+      'child': 'Kinder',
+      'parents': 'Eltern',
+      'partner': 'Partner'
+    };
+    
+    return {
+      id: sick.id,
+      startDate: sick.first_day,
+      endDate: sick.last_day,
+      sickTypeId: sick.sick_type_id,
+      sickTypeName: typeNames[sickType.description] || sickType.description
+    };
+  }
+
+  /**
+   * Löscht einen Krankheitseintrag
+   * @param {number} userId - Benutzer-ID
+   * @param {number} sickId - Sick-ID
+   * @returns {Promise<void>}
+   */
+  async deleteSickEntry(userId, sickId) {
+    const { Sick } = database.getModels();
+    
+    const sick = await Sick.findByPk(sickId);
+    
+    if (!sick) {
+      throw new Error('Krankheitseintrag nicht gefunden');
+    }
+    
+    // Prüfe Berechtigung
+    if (sick.user_id !== userId) {
+      throw new Error('Keine Berechtigung für diesen Eintrag');
+    }
+    
+    await sick.destroy();
+  }
+}
+
+module.exports = new SickService();
+

backend/src/services/TimeEntryService.js

@@ -490,20 +490,33 @@ class TimeEntryService {
     const todayDate = new Date(now.getFullYear(), now.getMonth(), now.getDate());
     const includeTodayInOvertime = !runningEntry; // Nur wenn heute schon abgeschlossen ist
     
+    console.log(`DEBUG Wochen-Überstunden: runningEntry=${!!runningEntry}, includeTodayInOvertime=${includeTodayInOvertime}, weekData.days.length=${weekData.days.length}`);
+    
     weekData.days.forEach(day => {
-      // Parse day.date (YYYY-MM-DD)
-      const dayDate = new Date(day.date);
+      // Parse day.date (YYYY-MM-DD) - mit expliziter Zeit um Midnight
+      const dayDate = new Date(day.date + 'T00:00:00');
+      const dayDateOnly = new Date(dayDate.getFullYear(), dayDate.getMonth(), dayDate.getDate());
+      
+      const isToday = dayDateOnly.getTime() === todayDate.getTime();
+      
+      console.log(`DEBUG Wochen-Überstunden: Prüfe Tag ${day.date}, isToday=${isToday}, dayDateOnly=${dayDateOnly.toISOString()}, todayDate=${todayDate.toISOString()}, netWorkTime=${day.netWorkTime}`);
       
       // Zukünftige Tage überspringen
-      if (dayDate > todayDate) {
+      if (dayDateOnly > todayDate) {
+        console.log(`DEBUG Wochen-Überstunden: Tag ${day.date} übersprungen (Zukunft)`);
         return;
       }
       
       // Heute überspringen, wenn noch gearbeitet wird
-      if (dayDate.getTime() === todayDate.getTime() && !includeTodayInOvertime) {
+      if (isToday && !includeTodayInOvertime) {
+        console.log(`DEBUG Wochen-Überstunden: Tag ${day.date} übersprungen (heute, noch nicht abgeschlossen)`);
         return;
       }
       
+      if (isToday && includeTodayInOvertime) {
+        console.log(`DEBUG Wochen-Überstunden: Tag ${day.date} WIRD GEZÄHLT (heute, abgeschlossen)`);
+      }
+      
       const dayOfWeek = dayDate.getDay(); // 0=So, 1=Mo, ..., 6=Sa
       
       // Nur Mo-Fr berücksichtigen
@@ -1362,12 +1375,20 @@ class TimeEntryService {
         });
         const endFix = endFixEntry ? timefixMap.get(endFixEntry.id)?.find(f => f.fix_type === 'stop work') : null;
         
+        if (startFix || endFix) {
+          console.log(`DEBUG Timefix für Block ${pair.id}: startFix=${!!startFix}, endFix=${!!endFix}`);
+          if (startFix) {
+            console.log(`DEBUG startFix.fix_date_time:`, startFix.fix_date_time, typeof startFix.fix_date_time);
+          }
+        }
+        
         // Verwende korrigierte Zeiten falls vorhanden
         const originalStartTime = workStartUTC;
         const originalEndTime = workEndUTC;
         
         if (startFix) {
           workStartUTC = new Date(startFix.fix_date_time);
+          console.log(`DEBUG workStartUTC nach Korrektur:`, workStartUTC, workStartUTC.getHours());
         }
         if (endFix) {
           workEndUTC = new Date(endFix.fix_date_time);
@@ -1385,8 +1406,9 @@ class TimeEntryService {
           return { hours: timeStr.getHours(), minutes: timeStr.getMinutes() };
         };
         
-        const start = parseTimeString(pair.start_time);
-        const end = parseTimeString(pair.end_time);
+        // Verwende korrigierte Zeiten für die Anzeige
+        const start = parseTimeString(startFix ? workStartUTC : pair.start_time);
+        const end = parseTimeString(endFix ? workEndUTC : pair.end_time);
         const startHours = start.hours;
         const startMinutes = start.minutes;
         const endHours = end.hours;