369 lines
10 KiB
JavaScript
369 lines
10 KiB
JavaScript
const express = require("express");
|
|
const pool = require("../db"); // PostgreSQL-Datenbankverbindung
|
|
const {
|
|
requireAuth,
|
|
requireRole,
|
|
requireAdmin,
|
|
} = require("../middleware/auth"); // Auth-Middleware
|
|
|
|
const router = express.Router();
|
|
|
|
router.get("/:id?", requireAuth, requireRole(3), async (req, res) => {
|
|
const { id } = req.params; // Mitglieds-ID (optional)
|
|
const abteilung = req.abteilung; // Abteilung aus Middleware
|
|
|
|
console.log(abteilung);
|
|
try {
|
|
let query;
|
|
let values = [];
|
|
|
|
if (id) {
|
|
if (abteilung) {
|
|
console.log("**Einzelnes Mitglied mit aktueller Riege abrufen**");
|
|
query = `
|
|
SELECT
|
|
m.*,
|
|
r.id AS riegen_id,
|
|
r.fid_abteilung,
|
|
riegenzuordnung.von,
|
|
riegenzuordnung.bis
|
|
FROM mitglieder m
|
|
LEFT JOIN riegenzuordnung
|
|
ON m.id = riegenzuordnung.fid_mitglied
|
|
AND riegenzuordnung.bis IS NULL
|
|
LEFT JOIN riegen r
|
|
ON riegenzuordnung.fid_riege = r.id
|
|
WHERE m.id = $1 AND (r.fid_abteilung = $2 OR r.fid_abteilung IS NULL)
|
|
`;
|
|
values = [id, abteilung];
|
|
} else {
|
|
console.log(" **Einzelnes Mitglied ohne Riege abrufen**");
|
|
query = `SELECT * FROM members WHERE id = $1`;
|
|
values = [id];
|
|
}
|
|
} else if (abteilung) {
|
|
console.log("**Alle Mitglieder einer Abteilung abrufen**");
|
|
query = `
|
|
SELECT
|
|
m.*,
|
|
r.id AS riegen_id,
|
|
r.fid_abteilung,
|
|
riegenzuordnung.von,
|
|
riegenzuordnung.bis
|
|
FROM mitglieder m
|
|
LEFT JOIN riegenzuordnung
|
|
ON m.id = riegenzuordnung.fid_mitglied
|
|
AND riegenzuordnung.bis IS NULL
|
|
LEFT JOIN riegen r
|
|
ON riegenzuordnung.fid_riege = r.id
|
|
WHERE r.fid_abteilung = $1
|
|
`;
|
|
values = [abteilung];
|
|
} else {
|
|
console.log("**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, requireRole(3), 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, requireRole(2), 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, requireRole(3), 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, requireRole(3), 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, requireRole(2), 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, requireRole(2), 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;
|