opencrm/backend/src/controllers/backup.controller.ts

import { Request, Response } from 'express';
import * as backupService from '../services/backup.service.js';

/**
 * Validiert Backup-Namen: nur Zeichen die auch der Backup-Generator erstellen darf
 * (ISO-Zeitstempel mit Buchstaben, Zahlen, Bindestrich, optional -N Suffix).
 * Blockt Path-Traversal-Versuche wie "../../etc/passwd".
 */
function isValidBackupName(name: string): boolean {
  return /^[A-Za-z0-9_-]+$/.test(name) && !name.includes('..');
}
import { logChange } from '../services/audit.service.js';

/**
 * Liste aller Backups abrufen
 * GET /api/settings/backups
 */
export async function listBackups(req: Request, res: Response) {
  try {
    const backups = await backupService.listBackups();
    res.json({ data: backups });
  } catch (error: any) {
    res.status(500).json({ error: 'Fehler beim Laden der Backups', details: error.message });
  }
}

/**
 * Neues Backup erstellen
 * POST /api/settings/backup
 */
export async function createBackup(req: Request, res: Response) {
  try {
    const result = await backupService.createBackup();

    if (result.success) {
      await logChange({
        req, action: 'CREATE', resourceType: 'Backup',
        label: `Backup ${result.backupName} erstellt`,
      });
      res.json({ data: { backupName: result.backupName }, message: 'Backup erfolgreich erstellt' });
    } else {
      res.status(500).json({ error: 'Backup fehlgeschlagen', details: result.error });
    }
  } catch (error: any) {
    res.status(500).json({ error: 'Fehler beim Erstellen des Backups', details: error.message });
  }
}

/**
 * Backup wiederherstellen
 * POST /api/settings/backup/:name/restore
 */
export async function restoreBackup(req: Request, res: Response) {
  try {
    const { name } = req.params;

    if (!name || !isValidBackupName(name)) {
      return res.status(400).json({ error: 'Ungültiger Backup-Name' });
    }

    const result = await backupService.restoreBackup(name);

    if (result.success) {
      await logChange({
        req, action: 'UPDATE', resourceType: 'Backup',
        label: `Backup ${name} wiederhergestellt`,
      });
      res.json({
        data: {
          restoredRecords: result.restoredRecords,
          restoredFiles: result.restoredFiles,
        },
        message: `${result.restoredRecords} Datensätze und ${result.restoredFiles || 0} Dateien wiederhergestellt`,
      });
    } else {
      res.status(500).json({ error: 'Wiederherstellung fehlgeschlagen', details: result.error });
    }
  } catch (error: any) {
    res.status(500).json({ error: 'Fehler bei der Wiederherstellung', details: error.message });
  }
}

/**
 * Backup löschen
 * DELETE /api/settings/backup/:name
 */
export async function deleteBackup(req: Request, res: Response) {
  try {
    const { name } = req.params;

    if (!name || !isValidBackupName(name)) {
      return res.status(400).json({ error: 'Ungültiger Backup-Name' });
    }

    const result = await backupService.deleteBackup(name);

    if (result.success) {
      await logChange({
        req, action: 'DELETE', resourceType: 'Backup',
        label: `Backup ${name} gelöscht`,
      });
      res.json({ message: 'Backup gelöscht' });
    } else {
      res.status(500).json({ error: 'Löschen fehlgeschlagen', details: result.error });
    }
  } catch (error: any) {
    res.status(500).json({ error: 'Fehler beim Löschen des Backups', details: error.message });
  }
}

/**
 * Backup als ZIP herunterladen
 * GET /api/settings/backup/:name/download
 */
export async function downloadBackup(req: Request, res: Response) {
  try {
    const { name } = req.params;

    if (!name || !isValidBackupName(name)) {
      return res.status(400).json({ error: 'Ungültiger Backup-Name' });
    }

    const result = await backupService.createBackupZip(name);

    if ('error' in result) {
      return res.status(404).json({ error: result.error });
    }

    // Response-Header setzen
    res.setHeader('Content-Type', 'application/zip');
    res.setHeader('Content-Disposition', `attachment; filename="${result.filename}"`);

    // Archiver zum Response pipen
    result.stream.pipe(res);

    // Archiver finalisieren (startet das Schreiben)
    result.stream.finalize();
  } catch (error: any) {
    res.status(500).json({ error: 'Fehler beim Download', details: error.message });
  }
}

/**
 * Backup-ZIP hochladen
 * POST /api/settings/backup/upload
 */
export async function uploadBackup(req: Request, res: Response) {
  try {
    if (!req.file) {
      return res.status(400).json({ error: 'Keine Datei hochgeladen' });
    }

    // Prüfen ob es eine ZIP-Datei ist
    if (!req.file.originalname.endsWith('.zip')) {
      return res.status(400).json({ error: 'Nur ZIP-Dateien sind erlaubt' });
    }

    const result = await backupService.uploadBackupZip(req.file.buffer);

    if (result.success) {
      res.json({
        data: { backupName: result.backupName },
        message: 'Backup erfolgreich hochgeladen',
      });
    } else {
      res.status(400).json({ error: 'Upload fehlgeschlagen', details: result.error });
    }
  } catch (error: any) {
    res.status(500).json({ error: 'Fehler beim Upload', details: error.message });
  }
}

/**
 * Werkseinstellungen - Alle Daten löschen
 * POST /api/settings/factory-reset
 */
export async function factoryReset(req: Request, res: Response) {
  try {
    const result = await backupService.factoryReset();

    if (result.success) {
      await logChange({
        req, action: 'DELETE', resourceType: 'System',
        label: `Werkseinstellungen wiederhergestellt`,
      });
      res.json({
        message: 'Werkseinstellungen wiederhergestellt. Bitte melden Sie sich mit admin@admin.com / admin an.',
      });
    } else {
      res.status(500).json({ error: 'Werkseinstellungen fehlgeschlagen', details: result.error });
    }
  } catch (error: any) {
    res.status(500).json({ error: 'Fehler bei Werkseinstellungen', details: error.message });
  }
}