reptil1990/SDSStundenerfassung
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Init

Browse Source
This commit is contained in:
Carsten Graf
2026-01-30 10:44:07 +01:00
commit a1ddaf5a35
37 changed files with 16573 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

167
routes/admin-ldap.js Normal file
View File

@@ -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;

154
routes/admin.js Normal file
View File

@@ -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;

132
routes/auth.js Normal file
View File

@@ -0,0 +1,132 @@
// 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, rememberMe = false) {
// 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;
// Session-Gültigkeit setzen: 30 Tage wenn "Angemeldet bleiben" aktiviert, sonst 24 Stunden
if (rememberMe) {
req.session.cookie.maxAge = 30 * 24 * 60 * 60 * 1000; // 30 Tage
} else {
req.session.cookie.maxAge = 24 * 60 * 60 * 1000; // 24 Stunden
}
// 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, remember_me } = req.body;
const rememberMe = remember_me === 'on' || remember_me === true;
// 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
// Case-insensitive Suche: COLLATE NOCASE macht den Vergleich case-insensitive
db.get('SELECT * FROM users WHERE username = ? COLLATE NOCASE', [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, rememberMe);
} else {
res.render('login', { error: 'Ungültiger Benutzername oder Passwort' });
}
});
} else {
// LDAP-Authentifizierung erfolgreich - hole Benutzer aus Datenbank
// Case-insensitive Suche: COLLATE NOCASE macht den Vergleich case-insensitive
db.get('SELECT * FROM users WHERE username = ? COLLATE NOCASE', [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, rememberMe);
});
}
});
} else {
// LDAP nicht aktiviert - verwende lokale Authentifizierung
// Case-insensitive Suche: COLLATE NOCASE macht den Vergleich case-insensitive
db.get('SELECT * FROM users WHERE username = ? COLLATE NOCASE', [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, rememberMe);
} 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;

35
routes/dashboard.js Normal file
View File

@@ -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;

379
routes/timesheet.js Normal file
View File

@@ -0,0 +1,379 @@
// Timesheet API Routes
const { db } = require('../database');
const { requireAuth, requireVerwaltung } = require('../middleware/auth');
const { generatePDF } = require('../services/pdf-service');
const { getHolidaysForDateRange } = require('../services/feiertage-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;
// Keine Tätigkeit setzen - Überstunden werden über overtime_taken_hours in der PDF angezeigt
} 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 werden nicht mehr als Tätigkeit hinzugefügt
// Sie werden über overtime_taken_hours in der PDF angezeigt
// 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: Feiertage für einen Zeitraum (Dashboard-Anzeige)
app.get('/api/timesheet/holidays', requireAuth, (req, res) => {
const { week_start, week_end } = req.query;
if (!week_start || !week_end) {
return res.status(400).json({ error: 'week_start und week_end erforderlich' });
}
getHolidaysForDateRange(week_start, week_end)
.then((set) => res.json({ dates: [...set] }))
.catch(() => res.json({ dates: [] }));
});
// 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, overtime_taken_hours, 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
// Bei 8 Überstunden (ganzer Tag) ist der Tag auch 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]);
// User-Daten laden für Überstunden-Berechnung
db.get('SELECT wochenstunden FROM users WHERE id = ?', [userId], (err, user) => {
if (err) {
return res.status(500).json({ error: 'Fehler beim Laden der User-Daten' });
}
const wochenstunden = user?.wochenstunden || 0;
const fullDayHours = wochenstunden > 0 ? wochenstunden / 5 : 8;
// Feiertage laden: Feiertag zählt als ausgefüllt (kein Start/Ende nötig)
getHolidaysForDateRange(week_start, week_end)
.catch(() => new Set())
.then((holidaySet) => {
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];
// Feiertag zählt als ausgefüllt
if (holidaySet.has(dateStr)) {
continue; // Tag ist ausgefüllt
}
// 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
}
// Prüfe ob 8 Überstunden (ganzer Tag) eingetragen sind
const overtimeValue = entry && entry.overtime_taken_hours ? parseFloat(entry.overtime_taken_hours) : 0;
const isFullDayOvertime = overtimeValue > 0 && Math.abs(overtimeValue - fullDayHours) < 0.01;
if (isFullDayOvertime) {
continue; // Tag ist ausgefüllt (8 Überstunden = ganzer Tag)
}
// 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;

468
routes/user.js Normal file
View File

@@ -0,0 +1,468 @@
// User API Routes
const { db } = require('../database');
const { hasRole, getCurrentDate } = require('../helpers/utils');
const { requireAuth } = require('../middleware/auth');
const { getHolidaysForDateRange } = require('../services/feiertage-service');
// 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: Client-IP abrufen
app.get('/api/user/client-ip', requireAuth, (req, res) => {
// Versuche verschiedene Methoden, um die Client-IP zu erhalten
const clientIp = req.ip ||
req.connection.remoteAddress ||
req.socket.remoteAddress ||
(req.headers['x-forwarded-for'] ? req.headers['x-forwarded-for'].split(',')[0].trim() : null) ||
req.headers['x-real-ip'] ||
'unknown';
// Entferne IPv6-Präfix falls vorhanden (::ffff:192.168.1.1 -> 192.168.1.1)
const cleanIp = clientIp.replace(/^::ffff:/, '');
res.json({ client_ip: cleanIp });
});
// 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: Verplante Urlaubstage (alle Wochen, auch nicht-eingereichte)
app.get('/api/user/planned-vacation', requireAuth, (req, res) => {
const userId = req.session.userId;
const { getCalendarWeek } = require('../helpers/utils');
db.all(`SELECT date, vacation_type FROM timesheet_entries
WHERE user_id = ? AND vacation_type IS NOT NULL AND vacation_type != ''`,
[userId],
(err, entries) => {
if (err) {
return res.status(500).json({ error: 'Fehler beim Abrufen der verplanten Tage' });
}
let plannedDays = 0;
const weeksMap = {}; // { KW: { year: YYYY, week: KW, days: X } }
entries.forEach(entry => {
const dayValue = entry.vacation_type === 'full' ? 1 : 0.5;
plannedDays += dayValue;
// Berechne Kalenderwoche
const date = new Date(entry.date);
const year = date.getFullYear();
const week = getCalendarWeek(entry.date);
const weekKey = `${year}-KW${week}`;
if (!weeksMap[weekKey]) {
weeksMap[weekKey] = { year, week, days: 0 };
}
weeksMap[weekKey].days += dayValue;
});
// Konvertiere zu sortiertem Array
const weeks = Object.values(weeksMap).sort((a, b) => {
if (a.year !== b.year) return a.year - b.year;
return a.week - b.week;
});
res.json({
plannedVacationDays: plannedDays,
weeks: weeks
});
}
);
});
// 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, overtime_offset_hours 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;
const overtimeOffsetHours = user.overtime_offset_hours ? parseFloat(user.overtime_offset_hours) : 0;
// Verplante Urlaubstage berechnen (alle Wochen, auch nicht-eingereichte)
const { getCalendarWeek } = require('../helpers/utils');
db.all(`SELECT date, vacation_type FROM timesheet_entries
WHERE user_id = ? AND vacation_type IS NOT NULL AND vacation_type != ''`,
[userId],
(err, allVacationEntries) => {
if (err) {
return res.status(500).json({ error: 'Fehler beim Abrufen der verplanten Tage' });
}
let plannedVacationDays = 0;
const weeksMap = {}; // { KW: { year: YYYY, week: KW, days: X } }
(allVacationEntries || []).forEach(entry => {
const dayValue = entry.vacation_type === 'full' ? 1 : 0.5;
plannedVacationDays += dayValue;
// Berechne Kalenderwoche
const date = new Date(entry.date);
const year = date.getFullYear();
const week = getCalendarWeek(entry.date);
const weekKey = `${year}-KW${week}`;
if (!weeksMap[weekKey]) {
weeksMap[weekKey] = { year, week, days: 0 };
}
weeksMap[weekKey].days += dayValue;
});
// Konvertiere zu sortiertem Array
const plannedWeeks = Object.values(weeksMap).sort((a, b) => {
if (a.year !== b.year) return a.year - b.year;
return a.week - b.week;
});
// 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: overtimeOffsetHours,
remainingVacation: urlaubstage,
totalOvertimeHours: 0,
totalOvertimeTaken: 0,
totalVacationDays: 0,
plannedVacationDays: plannedVacationDays,
plannedWeeks: plannedWeeks,
urlaubstage: urlaubstage,
overtimeOffsetHours: overtimeOffsetHours
});
}
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)
// Feiertage für die Woche laden (Feiertag zählt als ausgefüllt)
getHolidaysForDateRange(week.week_start, week.week_end)
.catch(() => new Set())
.then((holidaySet) => {
// 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];
if (holidaySet.has(dateStr)) {
filledWorkdays++;
continue;
}
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) + overtimeOffsetHours;
const remainingVacation = urlaubstage - totalVacationDays;
res.json({
currentOvertime: currentOvertime,
remainingVacation: remainingVacation,
totalOvertimeHours: totalOvertimeHours,
totalOvertimeTaken: totalOvertimeTaken,
totalVacationDays: totalVacationDays,
plannedVacationDays: plannedVacationDays,
plannedWeeks: plannedWeeks,
urlaubstage: urlaubstage,
overtimeOffsetHours: overtimeOffsetHours
});
}
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;
const fullDayHours = wochenstunden > 0 ? wochenstunden / 5 : 8;
let fullDayOvertimeDays = 0; // Anzahl Tage mit 8 Überstunden
entries.forEach(entry => {
// Prüfe ob 8 Überstunden (ganzer Tag) eingetragen sind
const overtimeValue = entry.overtime_taken_hours ? parseFloat(entry.overtime_taken_hours) : 0;
const isFullDayOvertime = overtimeValue > 0 && Math.abs(overtimeValue - fullDayHours) < 0.01;
if (entry.overtime_taken_hours) {
weekOvertimeTaken += entry.overtime_taken_hours;
}
// Wenn 8 Überstunden eingetragen sind, zählt der Tag als 0 Stunden
// Diese Tage werden separat gezählt, um die Sollstunden anzupassen
if (isFullDayOvertime) {
fullDayOvertimeDays++;
}
// Urlaub hat Priorität - wenn Urlaub, zähle nur Urlaubsstunden, nicht zusätzlich Arbeitsstunden
if (entry.vacation_type === 'full') {
weekVacationDays += 1;
weekVacationHours += 8; // Ganzer Tag = 8 Stunden
// Bei vollem Tag Urlaub werden keine Arbeitsstunden gezählt
} else if (entry.vacation_type === 'half') {
weekVacationDays += 0.5;
weekVacationHours += 4; // Halber Tag = 4 Stunden
// Bei halbem Tag Urlaub können noch Arbeitsstunden vorhanden sein
if (entry.total_hours && !isFullDayOvertime) {
weekTotalHours += entry.total_hours;
}
} else {
// Kein Urlaub - zähle nur Arbeitsstunden (wenn nicht 8 Überstunden)
if (entry.total_hours && !isFullDayOvertime) {
weekTotalHours += entry.total_hours;
}
}
});
// Feiertagsstunden: 8h pro Werktag der ein Feiertag ist
let holidayHours = 0;
for (let d = new Date(startDate); d <= endDate; d.setDate(d.getDate() + 1)) {
const day = d.getDay();
if (day >= 1 && day <= 5) {
const dateStr = d.toISOString().split('T')[0];
if (holidaySet.has(dateStr)) holidayHours += 8;
}
}
// Sollstunden berechnen
const sollStunden = (wochenstunden / 5) * workdays;
// Überstunden für diese Woche: (totalHours + vacationHours + holidayHours) - adjustedSollStunden
const weekTotalHoursWithVacation = weekTotalHours + weekVacationHours + holidayHours;
const adjustedSollStunden = sollStunden - (fullDayOvertimeDays * fullDayHours);
// weekOvertimeHours = Überstunden diese Woche (wie im Frontend berechnet)
const weekOvertimeHours = weekTotalHoursWithVacation - adjustedSollStunden;
// Kumulativ addieren
// WICHTIG: weekOvertimeHours enthält bereits die Überstunden dieser Woche (kann negativ sein bei 8 Überstunden)
// weekOvertimeTaken enthält die verbrauchten Überstunden (8 Stunden pro Tag mit 8 Überstunden)
// Die aktuellen Überstunden = Summe aller Wochen-Überstunden - verbrauchte Überstunden
totalOvertimeHours += weekOvertimeHours;
totalOvertimeTaken += weekOvertimeTaken;
totalVacationDays += weekVacationDays;
processedWeeks++;
// Wenn alle Wochen verarbeitet wurden, Antwort senden
if (processedWeeks === weeks.length && !hasError) {
// Aktuelle Überstunden = Summe aller Wochen-Überstunden - verbrauchte Überstunden + Offset
// weekOvertimeHours enthält bereits die korrekte Berechnung pro Woche (wie im Frontend)
// weekOvertimeTaken enthält die verbrauchten Überstunden (8 Stunden pro Tag mit 8 Überstunden)
const currentOvertime = (totalOvertimeHours - totalOvertimeTaken) + overtimeOffsetHours;
const remainingVacation = urlaubstage - totalVacationDays;
res.json({
currentOvertime: currentOvertime,
remainingVacation: remainingVacation,
totalOvertimeHours: totalOvertimeHours,
totalOvertimeTaken: totalOvertimeTaken,
totalVacationDays: totalVacationDays,
plannedVacationDays: plannedVacationDays,
plannedWeeks: plannedWeeks,
urlaubstage: urlaubstage,
overtimeOffsetHours: overtimeOffsetHours
});
}
});
});
});
});
});
});
});
}
module.exports = registerUserRoutes;

391
routes/verwaltung.js Normal file
View File

@@ -0,0 +1,391 @@
// Verwaltung Routes
const archiver = require('archiver');
const { db } = require('../database');
const { requireVerwaltung } = require('../middleware/auth');
const { getWeekDatesFromCalendarWeek } = require('../helpers/utils');
const { generatePDFToBuffer } = require('../services/pdf-service');
const { getHolidaysForDateRange } = require('../services/feiertage-service');
// 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, u.overtime_offset_hours,
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,
overtime_offset_hours: ts.overtime_offset_hours
},
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-Offset für einen User setzen (positiv/negativ)
app.put('/api/verwaltung/user/:id/overtime-offset', requireVerwaltung, (req, res) => {
const userId = req.params.id;
const raw = req.body ? req.body.overtime_offset_hours : undefined;
// Leere Eingabe => 0
const normalized = (raw === '' || raw === null || raw === undefined) ? 0 : parseFloat(raw);
if (!Number.isFinite(normalized)) {
return res.status(400).json({ error: 'Ungültiger Überstunden-Offset' });
}
db.run('UPDATE users SET overtime_offset_hours = ? WHERE id = ?', [normalized, userId], (err) => {
if (err) {
console.error('Fehler beim Speichern des Überstunden-Offsets:', err);
return res.status(500).json({ error: 'Fehler beim Speichern des Überstunden-Offsets' });
}
res.json({ success: true, overtime_offset_hours: normalized });
});
});
// API: Krankheitstage für einen User im aktuellen Jahr abrufen
app.get('/api/verwaltung/user/:id/sick-days', requireVerwaltung, (req, res) => {
const userId = req.params.id;
const currentYear = new Date().getFullYear();
const yearStart = `${currentYear}-01-01`;
const yearEnd = `${currentYear}-12-31`;
db.all(`SELECT DISTINCT date
FROM timesheet_entries
WHERE user_id = ? AND date >= ? AND date <= ? AND sick_status = 1
ORDER BY date`,
[userId, yearStart, yearEnd],
(err, entries) => {
if (err) {
return res.status(500).json({ error: 'Fehler beim Abrufen der Krankheitstage' });
}
const sickDays = entries ? entries.length : 0;
res.json({ sickDays: sickDays, year: currentYear });
}
);
});
// 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, overtime_offset_hours 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;
const overtimeOffsetHours = user.overtime_offset_hours ? parseFloat(user.overtime_offset_hours) : 0;
// Einträge für die Woche abrufen
db.all(`SELECT date, total_hours, overtime_taken_hours, vacation_type, sick_status
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;
let sickDays = 0;
entries.forEach(entry => {
if (entry.overtime_taken_hours) {
overtimeTaken += entry.overtime_taken_hours;
}
// Krankheitstage zählen
if (entry.sick_status === 1 || entry.sick_status === true) {
sickDays += 1;
}
// Urlaub hat Priorität - wenn Urlaub, zähle nur Urlaubsstunden, nicht zusätzlich Arbeitsstunden
if (entry.vacation_type === 'full') {
vacationDays += 1;
vacationHours += 8; // Ganzer Tag = 8 Stunden
// Bei vollem Tag Urlaub werden keine Arbeitsstunden gezählt
} else if (entry.vacation_type === 'half') {
vacationDays += 0.5;
vacationHours += 4; // Halber Tag = 4 Stunden
// Bei halbem Tag Urlaub können noch Arbeitsstunden vorhanden sein
if (entry.total_hours) {
totalHours += entry.total_hours;
}
} else {
// Kein Urlaub - zähle nur Arbeitsstunden
if (entry.total_hours) {
totalHours += entry.total_hours;
}
}
});
// Feiertage für die Woche laden (8h pro Feiertag; Arbeit an Feiertag = Überstunden)
getHolidaysForDateRange(week_start, week_end)
.catch(() => new Set())
.then((holidaySet) => {
// Anzahl Werktage berechnen (Montag-Freitag)
const startDate = new Date(week_start);
const endDate = new Date(week_end);
let workdays = 0;
let holidayHours = 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];
if (holidaySet.has(dateStr)) holidayHours += 8;
}
}
// Sollstunden berechnen
const sollStunden = (wochenstunden / 5) * workdays;
// Überstunden: (Tatsächliche Stunden + Urlaubsstunden + Feiertagsstunden) - Sollstunden
const totalHoursWithVacation = totalHours + vacationHours + holidayHours;
const overtimeHours = totalHoursWithVacation - sollStunden;
const remainingOvertime = overtimeHours - overtimeTaken;
const remainingOvertimeWithOffset = remainingOvertime + overtimeOffsetHours;
// Verbleibende Urlaubstage
const remainingVacation = urlaubstage - vacationDays;
res.json({
wochenstunden,
urlaubstage,
totalHours,
sollStunden,
overtimeHours,
overtimeTaken,
remainingOvertime,
overtimeOffsetHours,
remainingOvertimeWithOffset,
vacationDays,
remainingVacation,
sickDays,
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 });
});
});
// API: Massendownload aller PDFs für eine Kalenderwoche
app.get('/api/verwaltung/bulk-download/:year/:week', requireVerwaltung, async (req, res) => {
const year = parseInt(req.params.year);
const week = parseInt(req.params.week);
const downloadedBy = req.session.userId;
// Validierung
if (!year || year < 2000 || year > 2100) {
return res.status(400).json({ error: 'Ungültiges Jahr' });
}
if (!week || week < 1 || week > 53) {
return res.status(400).json({ error: 'Ungültige Kalenderwoche (1-53)' });
}
try {
// Berechne week_start und week_end aus Jahr und KW
const { week_start, week_end } = getWeekDatesFromCalendarWeek(year, week);
// Hole alle eingereichten Stundenzettel für diese KW
db.all(`SELECT wt.id, wt.user_id, wt.version, u.firstname, u.lastname
FROM weekly_timesheets wt
JOIN users u ON wt.user_id = u.id
WHERE wt.status = 'eingereicht'
AND wt.week_start = ?
AND wt.week_end = ?
ORDER BY wt.user_id, wt.version DESC`,
[week_start, week_end],
async (err, allTimesheets) => {
if (err) {
console.error('Fehler beim Abrufen der Stundenzettel:', err);
return res.status(500).json({ error: 'Fehler beim Abrufen der Stundenzettel' });
}
if (!allTimesheets || allTimesheets.length === 0) {
return res.status(404).json({ error: `Keine eingereichten Stundenzettel für KW ${week}/${year} gefunden` });
}
// Gruppiere nach user_id und wähle neueste Version pro User
const latestByUser = {};
allTimesheets.forEach(ts => {
if (!latestByUser[ts.user_id] || ts.version > latestByUser[ts.user_id].version) {
latestByUser[ts.user_id] = ts;
}
});
const timesheetsToDownload = Object.values(latestByUser);
const timesheetIds = timesheetsToDownload.map(ts => ts.id);
// Erstelle ZIP
res.setHeader('Content-Type', 'application/zip');
res.setHeader('Content-Disposition', `attachment; filename="Stundenzettel_KW${String(week).padStart(2, '0')}_${year}.zip"`);
const archive = archiver('zip', { zlib: { level: 9 } });
archive.on('error', (err) => {
console.error('Fehler beim Erstellen des ZIP:', err);
if (!res.headersSent) {
res.status(500).json({ error: 'Fehler beim Erstellen des ZIP-Archivs' });
}
});
archive.pipe(res);
// Generiere PDFs sequenziell und füge sie zum ZIP hinzu
const errors = [];
for (const ts of timesheetsToDownload) {
try {
// Erstelle Mock-Request-Objekt für generatePDFToBuffer
const mockReq = {
session: { userId: downloadedBy },
query: {}
};
const pdfBuffer = await generatePDFToBuffer(ts.id, mockReq);
// Dateiname: Stundenzettel_KW{week}_{Nachname}{Vorname}_Version{version}.pdf
const employeeName = `${ts.lastname}${ts.firstname}`.replace(/\s+/g, '');
const filename = `Stundenzettel_KW${String(week).padStart(2, '0')}_${employeeName}_Version${ts.version}.pdf`;
archive.append(pdfBuffer, { name: filename });
} catch (pdfError) {
console.error(`Fehler beim Generieren des PDFs für Timesheet ${ts.id}:`, pdfError);
errors.push(`Fehler bei ${ts.firstname} ${ts.lastname}: ${pdfError.message}`);
}
}
// Warte auf ZIP-Finalisierung und markiere dann PDFs als heruntergeladen
archive.on('end', () => {
if (timesheetIds.length > 0 && downloadedBy) {
// Update alle betroffenen timesheets
const placeholders = timesheetIds.map(() => '?').join(',');
db.run(`UPDATE weekly_timesheets
SET pdf_downloaded_at = CURRENT_TIMESTAMP,
pdf_downloaded_by = ?
WHERE id IN (${placeholders})`,
[downloadedBy, ...timesheetIds],
(err) => {
if (err) {
console.error('Fehler beim Markieren der PDFs als heruntergeladen:', err);
} else {
console.log(`Massendownload: ${timesheetIds.length} PDFs als heruntergeladen markiert`);
}
});
}
});
// Finalisiere ZIP (startet den Stream)
archive.finalize();
// Wenn Fehler aufgetreten sind, aber ZIP trotzdem erstellt wurde, logge sie
if (errors.length > 0) {
console.warn('Einige PDFs konnten nicht generiert werden:', errors);
}
});
} catch (error) {
console.error('Fehler beim Massendownload:', error);
if (!res.headersSent) {
res.status(500).json({ error: 'Fehler beim Massendownload: ' + error.message });
}
}
});
}
module.exports = registerVerwaltungRoutes;