tkd-api/routes/member.js

const express = require("express");
const pool = require("../db"); // PostgreSQL-Datenbankverbindung
const { requireAuth, requireAdmin } = require("../middleware/auth"); // Auth-Middleware

const router = express.Router();

router.get("/:id?", requireAuth, async (req, res) => {
  const { id } = req.params;
  const abteilung = req.abteilung;

  try {
    let query;
    let values = [];

    if (id) {
      // **Ein einzelnes Mitglied abrufen**
      if (abteilung) {
        // Falls Abteilung gesetzt ist, prüfen ob das Mitglied dazugehört
        query = `
                    SELECT m.* 
                    FROM mitglieder m
                    JOIN abteilungszuordnung dm ON m.id = dm.fid_mitglied
                    WHERE m.id = $1 AND dm.fid_abteilung = $2
                `;
        values = [id, abteilung];
      } else {
        // Mitglied ohne Abteilungseinschränkung abrufen
        query = `SELECT * FROM mitglieder WHERE id = $1`;
        values = [id];
      }
    } else if (abteilung) {
      // **Alle Mitglieder einer Abteilung abrufen**
      query = `
                SELECT m.* 
                FROM mitglieder m
                JOIN abteilungszuordnung dm ON m.id = dm.fid_mitglied
                WHERE dm.fid_abteilung = $1
            `;
      values = [abteilung];
    } else {
      // **Alle Mitglieder abrufen**
      query = `SELECT * FROM mitglieder`;
    }

    const result = await pool.query(query, values);

    if (result.rows.length === 0) {
      return res.status(404).json({ error: "Keine Mitglieder gefunden" });
    }

    return res.json(result.rows);
  } catch (err) {
    console.error(err);
    res.status(500).json({ error: "Interner Serverfehler" });
  }
});

// **2. Mitglied anlegen oder aktualisieren (Nur für Admins)**
router.put("/:id?", requireAuth, requireAdmin, async (req, res) => {
  const { id } = req.params;
  const {
    vorname,
    nachname,
    geburtsdatum,
    adresse,
    mit_seit,
    mit_num,
    helfer,
    probe,
  } = req.body;

  try {
    let result;

    if (id) {
      // **Mitglied aktualisieren**
      if (
        !vorname ||
        !nachname ||
        geburtsdatum === undefined ||
        adresse === undefined ||
        mit_seit === undefined ||
        mit_num === undefined ||
        helfer === undefined ||
        probe === undefined
      ) {
        return res.status(400).json({ error: "Alle Felder sind erforderlich" });
      }

      result = await pool.query(
        `UPDATE mitglieder 
                 SET vorname = $1, nachname = $2, geburtsdatum = $3, adresse = $4, 
                     mit_seit = $5, mit_num = $6, helfer = $7, probe = $8 
                 WHERE id = $9 
                 RETURNING *`,
        [
          vorname,
          nachname,
          geburtsdatum,
          adresse,
          mit_seit,
          mit_num,
          helfer,
          probe,
          id,
        ]
      );

      if (result.rows.length === 0) {
        return res.status(404).json({ error: "Mitglied nicht gefunden" });
      }

      return res.json({
        message: "Mitglied erfolgreich aktualisiert",
        member: result.rows[0],
      });
    } else {
      // **Neues Mitglied anlegen**
      if (
        !vorname ||
        !nachname ||
        geburtsdatum === undefined ||
        adresse === undefined ||
        mit_seit === undefined ||
        mit_num === undefined ||
        helfer === undefined ||
        probe === undefined
      ) {
        return res.status(400).json({ error: "Alle Felder sind erforderlich" });
      }

      result = await pool.query(
        `INSERT INTO mitglieder (vorname, nachname, geburtsdatum, adresse, mit_seit, mit_num, helfer, probe) 
                 VALUES ($1, $2, $3, $4, $5, $6, $7, $8) 
                 RETURNING *`,
        [
          vorname,
          nachname,
          geburtsdatum,
          adresse,
          mit_seit,
          mit_num,
          helfer,
          probe,
        ]
      );

      return res.status(201).json({
        message: "Mitglied erfolgreich angelegt",
        member: result.rows[0],
      });
    }
  } catch (err) {
    console.error(err);
    res.status(500).json({ error: "Interner Serverfehler" });
  }
});

// **3. Mitglied löschen (Nur für Admins)**
router.delete("/:id", requireAuth, requireAdmin, async (req, res) => {
  const { id } = req.params;

  try {
    const memberResult = await pool.query(
      "SELECT id FROM mitglieder WHERE id = $1",
      [id]
    );

    if (memberResult.rows.length === 0) {
      return res.status(404).json({ error: "Mitglied nicht gefunden" });
    }

    await pool.query("DELETE FROM mitglieder WHERE id = $1", [id]);

    res.json({ message: "Mitglied erfolgreich gelöscht" });
  } catch (err) {
    console.error(err);
    res.status(500).json({ error: "Interner Serverfehler" });
  }
});

// **1. notfallnummern abrufen (Falls ID gegeben: Nur die Nummern eines Mitglieds)**
router.get("/phone/:id", requireAuth, async (req, res) => {
  const { id } = req.params;

  try {
    const result = await pool.query(
      "SELECT * FROM notfallnummern WHERE fid_mitglied = $1",
      [id]
    );

    if (result.rows.length === 0) {
      return res
        .status(404)
        .json({ error: "Keine notfallnummern für dieses Mitglied gefunden" });
    }

    return res.json(result.rows);
  } catch (err) {
    console.error(err);
    res.status(500).json({ error: "Interner Serverfehler" });
  }
});

// **2. Telefonnummer anlegen oder aktualisieren (Nur für Admins)**
router.put("/phone/:id?", requireAuth, requireAdmin, async (req, res) => {
  const { id } = req.params;
  const { fid_teilnehmer, name, nummer, verbindung, stand } = req.body;

  try {
    let result;

    if (id) {
      // **Telefonnummer aktualisieren**
      if (!fid_teilnehmer || !nummer) {
        return res
          .status(400)
          .json({ error: "Telefonnumer und Mitglieds ID sind erforderlich" });
      }

      result = await pool.query(
        `UPDATE notfallnummern 
                 SET fid_mitglied = $1, name = $2, nummer = $3, verbindung = $4, stand = COALESCE($5, stand) 
                 WHERE id = $6 
                 RETURNING *`,
        [
          fid_teilnehmer,
          name || null,
          nummer,
          verbindung || null,
          stand || new Date(),
          id,
        ]
      );

      if (result.rows.length === 0) {
        return res.status(404).json({ error: "Telefonnummer nicht gefunden" });
      }

      return res.json({
        message: "Telefonnummer erfolgreich aktualisiert",
        phone: result.rows[0],
      });
    } else {
      // **Neue Telefonnummer anlegen**
      if (!fid_teilnehmer || !nummer) {
        return res
          .status(400)
          .json({ error: 'Alle Felder außer "stand" sind erforderlich' });
      }

      result = await pool.query(
        `INSERT INTO notfallnummern (fid_mitglied, name, nummer, verbindung, stand) 
                 VALUES ($1, $2, $3, $4, COALESCE($5, NOW())) 
                 RETURNING *`,
        [fid_teilnehmer, name, nummer, verbindung, stand]
      );

      return res.status(201).json({
        message: "Telefonnummer erfolgreich angelegt",
        phone: result.rows[0],
      });
    }
  } catch (err) {
    console.error(err);
    res.status(500).json({ error: "Interner Serverfehler" });
  }
});

// **3. Telefonnummer löschen (Nur für Admins)**
router.delete("/phone/:id", requireAuth, requireAdmin, async (req, res) => {
  const { id } = req.params;

  try {
    const phoneResult = await pool.query(
      "SELECT id FROM notfallnummern WHERE id = $1",
      [id]
    );

    if (phoneResult.rows.length === 0) {
      return res.status(404).json({ error: "Telefonnummer nicht gefunden" });
    }

    await pool.query("DELETE FROM notfallnummern WHERE id = $1", [id]);

    res.json({ message: "Telefonnummer erfolgreich gelöscht" });
  } catch (err) {
    console.error(err);
    res.status(500).json({ error: "Interner Serverfehler" });
  }
});

router.post("/riege/:id", requireAuth, requireAdmin, async (req, res) => {
  const { id } = req.params;
  const abteilung = req.abteilung;
  const { neue_riege } = req.body;

  if (!neue_riege) {
    return res.status(400).json({ error: "Neue Riege ist erforderlich" });
  }

  try {
    await pool.query("BEGIN"); // Transaktion starten

    // **1. Prüfen, ob das Mitglied bereits in einer Riege dieser Abteilung ist**
    const aktuelleRiege = await pool.query(
      `SELECT rz.id, rz.fid_mitglied, rz.fid_riege 
             FROM riegenzuordnung rz
             JOIN riegen r ON rz.fid_riege = r.id
             WHERE rz.fid_mitglied = $1 AND r.fid_abteilung = $2 AND rz.bis IS NULL`,
      [id, abteilung]
    );
    if (aktuelleRiege.rows.length > 0) {
      const alteRiegenId = aktuelleRiege.rows[0].fid_riege;

      // **2. Falls Mitglied bereits in einer Riege ist → Diesen Eintrag beenden**
      await pool.query(
        `UPDATE riegenzuordnung 
                 SET bis = NOW() 
                 WHERE fid_mitglied = $1 AND fid_riege = $2 AND bis IS NULL`,
        [id, alteRiegenId]
      );
    }

    // **3. Neuen Riegen-Eintrag für das Mitglied erstellen**
    const result = await pool.query(
      `INSERT INTO riegenzuordnung (fid_mitglied, fid_riege, von) 
             VALUES ($1, $2, NOW()) 
             RETURNING *`,
      [id, neue_riege]
    );

    await pool.query("COMMIT"); // Transaktion abschließen

    res.json({
      message: "Mitglied erfolgreich in neue Riege verschoben",
      riegenzuordnung: result.rows[0],
    });
  } catch (err) {
    await pool.query("ROLLBACK"); // Falls Fehler, Transaktion rückgängig machen
    console.error(err);
    res.status(500).json({ error: "Interner Serverfehler" });
  }
});

module.exports = router;