mysql createPool

pages/api/talas5/area.js

@@ -1,40 +1,19 @@
 // pages/api/talas_v5/area.js
 // Lesen von talas_v5 MySQL-Datenbank -> area Tabelle enthält DAUZ Geräte
-// Wenn gebraucht wird, dann nutzen ansonsten löschen
 
-import mysql from "mysql";
+import getPool from "../../utils/mysqlPool"; // Verwende den Singleton-Pool
 
-const dbConfig = {
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-  port: process.env.DB_PORT,
-};
-//console.log("my dbconfig: ", dbConfig);
-export default function handler(req, res) {
-  const connection = mysql.createConnection(dbConfig);
+export default async function handler(req, res) {
+  try {
+    const pool = getPool(); // Hole den Pool
 
-  connection.connect((err) => {
-    if (err) {
-      console.error("Fehler beim Verbinden:", err.stack);
-      res.status(500).json({ error: "Verbindungsfehler zur Datenbank" });
-      return;
-    }
+    // Führe die Abfrage aus
+    const [results] = await pool.query("SELECT id, name FROM area WHERE id = ?", [req.query.id]);
 
-    //console.log("Verbunden als ID", connection.threadId);
-    //Fehler weil, existiertdie Tabelle auf localhost:3000 nicht
-    connection.query("SELECT ..., ..., ..., ... FROM ... WHERE ... = ...", (error, results) => {
-      if (error) {
-        console.error("Fehler beim Abrufen der API", error);
-        res.status(500).json({ error: "Fehler bei der Abfrage" });
-        return;
-      }
-
-      // Wichtig: Senden Sie die Antwort zurück
-      res.status(200).json(results);
-
-      connection.end();
-    });
-  });
+    // Sende die Antwort zurück
+    res.status(200).json(results);
+  } catch (error) {
+    console.error("Fehler beim Abrufen der API", error);
+    res.status(500).json({ error: "Fehler bei der Abfrage" });
+  }
 }

pages/api/talas5/location_device.js

@@ -1,42 +1,34 @@
-// Importieren des mysql2 Pakets
-import mysql from "mysql2";
-
-// Erstellen eines Pools von Datenbankverbindungen
-const pool = mysql.createPool({
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-  port: process.env.DB_PORT,
-  waitForConnections: true,
-  connectionLimit: 10,
-  queueLimit: 0,
-});
-
-// Ein Hilfsfunktion, um Anfragen zu vereinfachen
-function queryDatabase(query, params) {
-  return new Promise((resolve, reject) => {
-    pool.query(query, params, (error, results) => {
-      if (error) {
-        return reject(error);
-      }
-      resolve(results);
-    });
-  });
-}
+// /pages/api/talas5/location_device.js
+import getPool from "../../../utils/mysqlPool"; // Import Singleton-Pool
 
 // API-Handler
 export default async function handler(req, res) {
-  try {
-    // Dein SQL-Query und die Parameter
-    const sql = "SELECT idLD, iddevice, name FROM location_device WHERE iddevice = ?";
-    const params = [160]; // Beispielparameter
+  const pool = getPool(); // Singleton-Pool verwenden
 
-    // Ausführen der Datenbankabfrage
-    const results = await queryDatabase(sql, params);
+  let connection;
+  try {
+    // SQL-Query and parameters
+    const sql = "SELECT idLD, iddevice, name FROM location_device WHERE iddevice = ?";
+    const params = [160]; // Example parameter
+
+    // Get a connection from the pool
+    connection = await pool.getConnection();
+
+    // Execute the query
+    const [results] = await connection.query(sql, params);
+
+    // Check if results are empty
+    if (!results.length) {
+      return res.status(404).json({ error: "Keine Geräte gefunden" });
+    }
+
+    // Respond with the results
     res.status(200).json(results);
   } catch (error) {
-    console.error("Fehler beim Abrufen der API", error);
-    res.status(500).json({ error: "Fehler bei der Abfrage" });
+    // Log and return error
+    console.error("Fehler beim Abrufen der Geräteinformationen:", error);
+    res.status(500).json({ error: "Fehler beim Abrufen der Geräteinformationen" });
+  } finally {
+    if (connection) connection.release();
   }
 }

pages/api/talas5/webserviceMap/GisStationsStatusDistrict.js

@@ -1,19 +1,10 @@
-// /pages/api/talas5/webserviceMap/gisStationsMeasurementsSQL.js
-import mysql from "mysql2/promise";
-
-// Erstellen eines Verbindungspools anstelle einer einzelnen Verbindung
-const pool = mysql.createPool({
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-  port: process.env.DB_PORT,
-  waitForConnections: true,
-  connectionLimit: 10,
-  queueLimit: 0,
-});
+// /pages/api/talas5/webserviceMap/GisStationsStatusDistrict.js
+import getPool from "../../../../utils/mysqlPool"; // Singleton-Pool importieren
 
 export default async function handler(req, res) {
+  const pool = getPool(); // Singleton-Pool verwenden
+  let connection; // Verbindung deklarieren
+
   const { idMap, idUser } = req.query;
 
   if (!idMap || !idUser) {
@@ -21,22 +12,25 @@ export default async function handler(req, res) {
   }
 
   try {
+    // Verbindung aus dem Pool holen
+    connection = await pool.getConnection();
+
     let onlySystem = -1;
     let districtCounter = 0;
 
     // Get onlySystem
-    const [mapResult] = await pool.query("SELECT idsystem_typ FROM maps WHERE id = ?", [idMap]);
+    const [mapResult] = await connection.query("SELECT idsystem_typ FROM maps WHERE id = ?", [idMap]);
     if (mapResult.length > 0) {
       onlySystem = mapResult[0].idsystem_typ ?? -1;
     }
 
     // Get districtCounter
     if (idUser > 0) {
-      const [userLayerResult] = await pool.query("SELECT count(*) as count FROM user_User_layer1 WHERE iduser = ?", [idUser]);
+      const [userLayerResult] = await connection.query("SELECT count(*) as count FROM user_User_layer1 WHERE iduser = ?", [idUser]);
       districtCounter = userLayerResult[0].count;
     }
 
-    // Building the query
+    // Query erstellen
     let query = `
       SELECT ld.idLD, dc.message, p.level, p.name, p.color, ld.idDevice, de.isService, dc.idIcon
       FROM location as l
@@ -61,7 +55,7 @@ export default async function handler(req, res) {
     }
     query += ` ORDER BY p.level desc`;
 
-    const [results] = await pool.query(query, queryParams);
+    const [results] = await connection.query(query, queryParams);
 
     const mpss = {
       IdMap: idMap.toString(),
@@ -80,5 +74,8 @@ export default async function handler(req, res) {
   } catch (error) {
     console.error("Fehler beim Laden der Daten:", error);
     res.status(500).json({ error: "Interner Serverfehler" });
+  } finally {
+    // Stelle sicher, dass die Verbindung zurück in den Pool gegeben wird
+    if (connection) connection.release();
   }
 }

pages/api/talas5/webserviceMap/gisStationsMeasurementsSQL.js

@@ -1,27 +1,9 @@
 // /pages/api/talas5/webserviceMap/gisStationsMeasurementsSQL.js
-import mysql from "mysql2";
-
-// Erstellen eines Pools von Datenbankverbindungen
-const pool = mysql.createPool({
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-  port: process.env.DB_PORT,
-  waitForConnections: true,
-  connectionLimit: 10,
-  queueLimit: 0,
-});
-
-pool.on("connection", function (connection) {
-  console.log("Database connected successfully.");
-});
-
-pool.on("error", function (err) {
-  console.error("Fehler beim Verbinden:", err);
-});
+import getPool from "../../../../utils/mysqlPool"; // Singleton-Pool importieren
 
 export default function handler(req, res) {
+  const pool = getPool(); // Singleton-Pool verwenden
+
   const idMap = req.query.idMap;
   if (req.method !== "GET") {
     return res.status(405).json({ error: "Nur GET Methode erlaubt" });

pages/api/talas_v5_DB/gisLines/readGisLines.js

@@ -1,19 +1,8 @@
-// /pages/api/talas_v5_DB/gisLines/readGisLines.js
-import mysql from "mysql2/promise";
-
-// Erstellen eines Pools von Datenbankverbindungen
-const pool = mysql.createPool({
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-  port: process.env.DB_PORT,
-  waitForConnections: true,
-  connectionLimit: 10,
-  queueLimit: 0,
-});
+import getPool from "../../../../utils/mysqlPool"; // Singleton-Pool importieren
 
 export default async function handler(req, res) {
+  const pool = getPool(); // Singleton-Pool verwenden
+
   if (req.method !== "GET") {
     return res.status(405).json({ error: "Nur GET Methode erlaubt" });
   }
@@ -21,6 +10,7 @@ export default async function handler(req, res) {
   const query = "SELECT * FROM talas_v5.gis_lines;";
 
   try {
+    // Abrufen der Datenbankergebnisse
     const [results] = await pool.query(query);
     if (results.length > 0) {
       res.status(200).json(results);

pages/api/talas_v5_DB/gisLines/updateLineCoordinates.js

@@ -1,18 +1,8 @@
-import mysql from "mysql2/promise";
-
-// Erstellen eines Pools von Datenbankverbindungen
-const pool = mysql.createPool({
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-  port: process.env.DB_PORT,
-  waitForConnections: true,
-  connectionLimit: 10,
-  queueLimit: 0,
-});
+import getPool from "../../../../utils/mysqlPool"; // Singleton-Pool importieren
 
 export default async function handler(req, res) {
+  const pool = getPool(); // Singleton-Pool verwenden
+
   if (req.method !== "POST") {
     return res.status(405).json({ error: "Nur POST Methode erlaubt" });
   }
@@ -52,7 +42,6 @@ export default async function handler(req, res) {
     console.error("Fehler beim Aktualisieren der gis_lines:", error);
     res.status(500).json({ error: "Fehler beim Aktualisieren der gis_lines" });
   } finally {
-    // Stelle sicher, dass die Verbindung zurückgegeben wird
     if (connection) connection.release();
   }
 }

pages/api/talas_v5_DB/locationDevice/getDeviceId.js

@@ -1,19 +1,9 @@
 // API in /api/talas_v5_DB/locationDevice/getDeviceId.js
-import mysql from "mysql2/promise";
-
-// Erstellen eines Pools von Datenbankverbindungen
-const pool = mysql.createPool({
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-  port: process.env.DB_PORT,
-  waitForConnections: true,
-  connectionLimit: 10,
-  queueLimit: 0,
-});
+import getPool from "../../../../utils/mysqlPool"; // Singleton-Pool importieren
 
 export default async function handler(req, res) {
+  const pool = getPool(); // Singleton-Pool verwenden
+
   if (req.method !== "GET") {
     return res.status(405).json({ error: "Nur GET Methode erlaubt" });
   }
@@ -26,9 +16,14 @@ export default async function handler(req, res) {
 
   const query = "SELECT idLD FROM location_device WHERE name = ?";
 
+  let connection;
+
   try {
-    // Ausführen der Abfrage mit dem Pool
-    const [results] = await pool.query(query, [deviceName]);
+    connection = await pool.getConnection(); // Hole eine Verbindung aus dem Pool
+
+    // Ausführen der Abfrage
+    const [results] = await connection.query(query, [deviceName]);
+
     if (results.length > 0) {
       res.status(200).json({ idLD: results[0].idLD });
     } else {
@@ -37,5 +32,7 @@ export default async function handler(req, res) {
   } catch (error) {
     console.error("Fehler beim Abrufen der Geräte-ID:", error);
     res.status(500).json({ error: "Fehler beim Abrufen der Geräte-ID" });
+  } finally {
+    if (connection) connection.release(); // Gib die Verbindung in den Pool zurück
   }
 }

pages/api/talas_v5_DB/locationDevice/locationDeviceNameById.js

@@ -1,19 +1,9 @@
 // API in /api/talas_v5_DB/locationDevice/locationDeviceNameById.js
-import mysql from "mysql2/promise";
-
-// Erstellen eines Pools von Datenbankverbindungen
-const pool = mysql.createPool({
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-  port: process.env.DB_PORT,
-  waitForConnections: true,
-  connectionLimit: 10,
-  queueLimit: 0,
-});
+import getPool from "../../../../utils/mysqlPool"; // Singleton-Pool importieren
 
 export default async function handler(req, res) {
+  const pool = getPool(); // Singleton-Pool verwenden
+
   if (req.method !== "GET") {
     return res.status(405).json({ error: "Nur GET Methode erlaubt" });
   }
@@ -24,9 +14,13 @@ export default async function handler(req, res) {
     return res.status(400).json({ error: "idLD ist erforderlich" });
   }
 
+  let connection;
+
   try {
+    connection = await pool.getConnection(); // Hole eine Verbindung aus dem Pool
+
     const query = "SELECT name FROM location_device WHERE idLD = ?";
-    const [results] = await pool.query(query, [idLD]);
+    const [results] = await connection.query(query, [idLD]);
 
     if (results.length > 0) {
       res.status(200).json({ name: results[0].name });
@@ -36,5 +30,7 @@ export default async function handler(req, res) {
   } catch (error) {
     console.error("Fehler beim Abrufen des Gerätenamens:", error);
     res.status(500).json({ error: "Fehler beim Abrufen des Gerätenamens" });
+  } finally {
+    if (connection) connection.release(); // Gib die Verbindung in den Pool zurück
   }
 }

pages/api/talas_v5_DB/locationDevice/locationDevices.js

@@ -1,32 +1,28 @@
 // API in /api/talas_v5_DB/locationDevice/locationDevices.js
-import mysql from "mysql2/promise";
-
-// Erstellen eines Pools von Datenbankverbindungen
-const pool = mysql.createPool({
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-  port: process.env.DB_PORT,
-  waitForConnections: true,
-  connectionLimit: 10,
-  queueLimit: 0,
-});
+import getPool from "../../../../utils/mysqlPool"; // Singleton-Pool importieren
 
 export default async function handler(req, res) {
+  const pool = getPool(); // Singleton-Pool verwenden
+
   if (req.method !== "GET") {
     return res.status(405).json({ error: "Nur GET Methode erlaubt" });
   }
 
   const query = "SELECT * FROM location_device WHERE iddevice = 160";
 
+  let connection;
+
   try {
-    // Ausführen der Abfrage mit dem Verbindungspool
-    const [results] = await pool.query(query);
+    connection = await pool.getConnection(); // Hole eine Verbindung aus dem Pool
+
+    // Ausführen der Abfrage
+    const [results] = await connection.query(query);
 
     res.status(200).json(results);
   } catch (error) {
     console.error("Fehler beim Abrufen der Geräteinformationen:", error);
     res.status(500).json({ error: "Fehler beim Abrufen der Geräteinformationen" });
+  } finally {
+    if (connection) connection.release(); // Gib die Verbindung in den Pool zurück
   }
 }

pages/api/talas_v5_DB/poiTyp/readPoiTyp.js

@@ -1,19 +1,9 @@
 // pages/api/talas_v5_DB/poiTyp/readPoiTyp.js
-import mysql from "mysql2/promise";
-
-// Erstellen eines Pools von Datenbankverbindungen
-const pool = mysql.createPool({
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-  port: process.env.DB_PORT,
-  waitForConnections: true,
-  connectionLimit: 10,
-  queueLimit: 0,
-});
+import getPool from "../../../../utils/mysqlPool"; // Singleton-Pool importieren
 
 export default async function handler(req, res) {
+  const pool = getPool(); // Verwende den Singleton-Pool
+
   if (req.method !== "GET") {
     res.setHeader("Allow", ["GET"]);
     return res.status(405).end(`Method ${req.method} Not Allowed`);
@@ -21,9 +11,13 @@ export default async function handler(req, res) {
 
   const query = "SELECT * FROM poityp";
 
+  let connection;
+
   try {
-    // Ausführen der Abfrage mit dem Verbindungspool
-    const [results] = await pool.query(query);
+    connection = await pool.getConnection(); // Hole eine Verbindung aus dem Pool
+
+    // Führe die Abfrage aus
+    const [results] = await connection.query(query);
 
     if (results.length === 0) {
       return res.status(404).json({ message: "Keine Einträge gefunden" });
@@ -33,5 +27,7 @@ export default async function handler(req, res) {
   } catch (error) {
     console.error("Fehler beim Abfragen der Datenbank:", error);
     res.status(500).json({ error: "Ein Fehler ist aufgetreten" });
+  } finally {
+    if (connection) connection.release(); // Gib die Verbindung zurück in den Pool
   }
 }

pages/api/talas_v5_DB/pois/addLocation.js

@@ -1,16 +1,9 @@
 // pages/api/addLocation.js
-import mysql from "mysql";
+import getPool from "../../../../utils/mysqlPool"; // Singleton-Pool importieren
 
-const pool = mysql.createPool({
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-  port: process.env.DB_PORT,
-  connectionLimit: 10, // Maximale Anzahl gleichzeitiger Verbindungen
-});
+export default async function handler(req, res) {
+  const pool = getPool(); // Singleton-Pool verwenden
 
-export default function handler(req, res) {
   if (req.method === "POST") {
     const { name, poiTypeId, latitude, longitude, idLD } = req.body;
     console.log("Received data:", req.body); // Überprüfen der empfangenen Daten
@@ -19,17 +12,24 @@ export default function handler(req, res) {
     const point = `POINT(${longitude} ${latitude})`;
     const values = [name, poiTypeId, point, idLD];
 
-    // Verwende den Pool, um eine Verbindung zu bekommen und die Query auszuführen
-    pool.query(query, values, (error, results) => {
-      if (error) {
-        console.error("Fehler beim Einfügen des Standorts:", error);
-        return res.status(500).json({ error: "Ein Fehler ist aufgetreten" });
-      }
+    let connection;
+
+    try {
+      connection = await pool.getConnection(); // Hole eine Verbindung aus dem Pool
+
+      // Verwende die Verbindung, um die Query auszuführen
+      const [results] = await connection.query(query, values);
+
       res.status(200).json({
         id: results.insertId,
         message: "Standort erfolgreich hinzugefügt",
       });
-    });
+    } catch (error) {
+      console.error("Fehler beim Einfügen des Standorts:", error);
+      res.status(500).json({ error: "Ein Fehler ist aufgetreten" });
+    } finally {
+      if (connection) connection.release(); // Gib die Verbindung in den Pool zurück
+    }
   } else {
     res.setHeader("Allow", ["POST"]);
     res.status(405).end(`Method ${req.method} Not Allowed`);

pages/api/talas_v5_DB/pois/deletePoi.js

@@ -1,19 +1,9 @@
 // pages/api/talas_v5_DB/pois/deletePoi.js
-import mysql from "mysql2/promise";
-
-// Erstellen eines Pools von Datenbankverbindungen
-const pool = mysql.createPool({
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-  port: process.env.DB_PORT,
-  waitForConnections: true,
-  connectionLimit: 10,
-  queueLimit: 0,
-});
+import getPool from "../../../../utils/mysqlPool"; // Singleton-Pool importieren
 
 export default async function handler(req, res) {
+  const pool = getPool(); // Singleton-Pool verwenden
+
   if (req.method !== "DELETE") {
     return res.status(405).json({ error: "Nur DELETE Methode erlaubt" });
   }
@@ -26,9 +16,13 @@ export default async function handler(req, res) {
 
   const query = "DELETE FROM poi WHERE idPoi = ?";
 
+  let connection;
+
   try {
+    connection = await pool.getConnection(); // Hole eine Verbindung aus dem Pool
+
     // Ausführen der Abfrage mit dem Verbindungspool
-    const [results] = await pool.query(query, [id]);
+    const [results] = await connection.query(query, [id]);
 
     if (results.affectedRows > 0) {
       res.status(200).json({ message: "POI erfolgreich gelöscht" });
@@ -36,7 +30,9 @@ export default async function handler(req, res) {
       res.status(404).json({ error: "POI nicht gefunden" });
     }
   } catch (error) {
-    console.error("Fehler beim Löschen des POI 3:", error);
+    console.error("Fehler beim Löschen des POI:", error);
     res.status(500).json({ error: "Fehler beim Löschen des POI" });
+  } finally {
+    if (connection) connection.release(); // Gib die Verbindung in den Pool zurück
   }
 }

pages/api/talas_v5_DB/pois/getPoiById.js

@@ -1,19 +1,9 @@
 // pages/api/talas_v5_DB/pois/getPoiById.js
-import mysql from "mysql2/promise";
-
-// Erstellen eines Pools von Datenbankverbindungen
-const pool = mysql.createPool({
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-  port: process.env.DB_PORT,
-  waitForConnections: true,
-  connectionLimit: 10,
-  queueLimit: 0,
-});
+import getPool from "../../../../utils/mysqlPool"; // Singleton-Pool importieren
 
 export default async function handler(req, res) {
+  const pool = getPool(); // Singleton-Pool verwenden
+
   if (req.method !== "GET") {
     res.setHeader("Allow", ["GET"]);
     return res.status(405).end(`Method ${req.method} Not Allowed`);
@@ -27,9 +17,13 @@ export default async function handler(req, res) {
 
   const query = "SELECT description FROM poi WHERE idPoi = ?";
 
+  let connection;
+
   try {
+    connection = await pool.getConnection(); // Hole eine Verbindung aus dem Pool
+
     // Ausführen der Abfrage mit dem Verbindungspool
-    const [results] = await pool.query(query, [idPoi]);
+    const [results] = await connection.query(query, [idPoi]);
 
     if (results.length === 0) {
       return res.status(404).json({ error: "POI nicht gefunden" });
@@ -39,5 +33,7 @@ export default async function handler(req, res) {
   } catch (error) {
     console.error("Fehler bei der Abfrage:", error);
     res.status(500).json({ error: "Fehler bei der Abfrage" });
+  } finally {
+    if (connection) connection.release(); // Gib die Verbindung in den Pool zurück
   }
 }

pages/api/talas_v5_DB/pois/poi-icons.js

@@ -1,19 +1,9 @@
 // pages/api/talas_v5_DB/pois/poi-icons.js
-import mysql from "mysql2/promise";
-
-// Erstellen eines Pools von Datenbankverbindungen
-const pool = mysql.createPool({
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-  port: process.env.DB_PORT,
-  waitForConnections: true,
-  connectionLimit: 10,
-  queueLimit: 0,
-});
+import getPool from "../../../../utils/mysqlPool"; // Singleton-Pool importieren
 
 export default async function handler(req, res) {
+  const pool = getPool(); // Singleton-Pool verwenden
+
   if (req.method !== "GET") {
     return res.status(405).json({ error: "Nur GET Methode erlaubt" });
   }
@@ -25,12 +15,18 @@ export default async function handler(req, res) {
     JOIN poiicons i ON pt.icon = i.idpoiicons;
   `;
 
+  let connection;
+
   try {
+    connection = await pool.getConnection(); // Hole eine Verbindung aus dem Pool
+
     // Ausführen der Abfrage mit dem Verbindungspool
-    const [results] = await pool.query(query);
+    const [results] = await connection.query(query);
     res.status(200).json(results);
   } catch (error) {
     console.error("Fehler beim Abrufen der Icons:", error);
     res.status(500).json({ error: "Fehler beim Abrufen der Icons" });
+  } finally {
+    if (connection) connection.release(); // Gib die Verbindung in den Pool zurück
   }
 }

pages/api/talas_v5_DB/pois/readLocations.js

@@ -1,32 +1,27 @@
 // pages/api/talas_v5_DB/pois/readLocations.js
-import mysql from "mysql2/promise";
-
-// Erstellen eines Pools von Datenbankverbindungen
-const pool = mysql.createPool({
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-  port: process.env.DB_PORT,
-  waitForConnections: true,
-  connectionLimit: 10,
-  queueLimit: 0,
-});
+import getPool from "../../../../utils/mysqlPool"; // Singleton-Pool importieren
 
 export default async function handler(req, res) {
+  const pool = getPool(); // Singleton-Pool verwenden
+
   const query = `
     SELECT idPoi, description, idPoiTyp, idLD, ST_AsText(position) AS position
     FROM poi
   `;
 
+  let connection;
+
   try {
-    // Ausführen der Abfrage mit dem Verbindungspool
-    const [results] = await pool.query(query);
+    connection = await pool.getConnection(); // Hole eine Verbindung aus dem Pool
+
+    const [results] = await connection.query(query);
 
     // Senden der Antwort zurück
     res.status(200).json(results);
   } catch (error) {
     console.error("Fehler beim Abrufen der API:", error);
     res.status(500).json({ error: "Fehler bei der Abfrage" });
+  } finally {
+    if (connection) connection.release(); // Gib die Verbindung in den Pool zurück
   }
 }

pages/api/talas_v5_DB/pois/updateLocation.js

@@ -1,20 +1,9 @@
 // pages/api/talas_v5_DB/pois/updateLocation.js
-import mysql from "mysql2/promise";
-
-// Erstellen eines Pools von Datenbankverbindungen
-const pool = mysql.createPool({
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-  port: process.env.DB_PORT,
-  charset: "utf8mb4",
-  waitForConnections: true,
-  connectionLimit: 10,
-  queueLimit: 0,
-});
+import getPool from "../../../../utils/mysqlPool"; // Singleton-Pool importieren
 
 export default async function handler(req, res) {
+  const pool = getPool(); // Singleton-Pool verwenden
+
   if (req.method !== "POST") {
     res.setHeader("Allow", ["POST"]);
     return res.status(405).end(`Method ${req.method} Not Allowed`);
@@ -28,8 +17,12 @@ export default async function handler(req, res) {
 
   const query = "UPDATE poi SET position = POINT(?, ?) WHERE idPoi = ?";
 
+  let connection;
+
   try {
-    const [result] = await pool.query(query, [longitude, latitude, id]);
+    connection = await pool.getConnection(); // Hole eine Verbindung aus dem Pool
+
+    const [result] = await connection.query(query, [longitude, latitude, id]);
 
     if (result.affectedRows > 0) {
       res.status(200).json({ success: true });
@@ -39,44 +32,7 @@ export default async function handler(req, res) {
   } catch (error) {
     console.error("Fehler beim Aktualisieren der Position:", error);
     res.status(500).json({ error: "Ein Fehler ist aufgetreten" });
+  } finally {
+    if (connection) connection.release(); // Gib die Verbindung in den Pool zurück
   }
 }
-
-/* import mysql from "mysql";
-import util from "util";
-
-const dbConfig = {
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-  port: process.env.DB_PORT,
-  charset: "utf8mb4",
-};
-
-export default async function handler(req, res) {
-  if (req.method !== "POST") {
-    res.setHeader("Allow", ["POST"]);
-    return res.status(405).end(`Method ${req.method} Not Allowed`);
-  }
-
-  const { id, latitude, longitude } = req.body;
-
-  const connection = mysql.createConnection(dbConfig);
-  // Promisify the query method
-  const query = util.promisify(connection.query).bind(connection);
-
-  try {
-    await query("UPDATE poi SET position = POINT(?, ?) WHERE idPoi = ?", [
-      longitude,
-      latitude,
-      id,
-    ]);
-    res.status(200).json({ success: true });
-  } catch (error) {
-    console.error(error);
-    res.status(500).json({ error: "Ein Fehler ist aufgetreten" });
-  } finally {
-    connection.end();
-  }
-} */

pages/api/talas_v5_DB/pois/updatePoi.js

@@ -1,19 +1,9 @@
 // pages/api/talas_v5_DB/pois/updatePoi.js
-import mysql from "mysql2/promise";
-
-// Erstellen eines Pools von Datenbankverbindungen
-const pool = mysql.createPool({
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-  port: process.env.DB_PORT,
-  waitForConnections: true,
-  connectionLimit: 10,
-  queueLimit: 0,
-});
+import getPool from "../../../../utils/mysqlPool"; // Singleton-Pool importieren
 
 export default async function handler(req, res) {
+  const pool = getPool(); // Verwende den Singleton-Pool
+
   if (req.method !== "POST") {
     return res.status(405).json({ error: "Nur POST Methode erlaubt" });
   }
@@ -30,8 +20,12 @@ export default async function handler(req, res) {
     WHERE idPoi = ?
   `;
 
+  let connection;
+
   try {
-    const [results] = await pool.query(query, [description, idPoiTyp, idLD, idPoi]);
+    connection = await pool.getConnection(); // Hole eine Verbindung aus dem Pool
+
+    const [results] = await connection.query(query, [description, idPoiTyp, idLD, idPoi]);
 
     if (results.affectedRows > 0) {
       res.status(200).json({ message: "POI erfolgreich aktualisiert" });
@@ -41,5 +35,7 @@ export default async function handler(req, res) {
   } catch (error) {
     console.error("Fehler beim Aktualisieren des POI:", error);
     res.status(500).json({ error: "Fehler beim Aktualisieren des POI" });
+  } finally {
+    if (connection) connection.release(); // Gib die Verbindung zurück in den Pool
   }
 }

pages/api/talas_v5_DB/priorityConfig.js

@@ -2,28 +2,18 @@
 // in tals5 http://10.10.0.13/talas5/Management/PriorityConfig.aspx beinhaltet die Tabelle prio die Prioritäten der Meldungen (Level 1-4) oder (0-4) je nachdem DB-Design
 // das ist die API, die die Prioritäten zurückgibt
 
-import mysql from "mysql2/promise";
-
-// Erstellen eines Pools von Datenbankverbindungen
-const pool = mysql.createPool({
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-  port: process.env.DB_PORT,
-  waitForConnections: true,
-  connectionLimit: 10,
-  queueLimit: 0,
-});
+import getPool from "../../../utils/mysqlPool"; // Singleton-Pool importieren
 
 export default async function handler(req, res) {
+  const pool = getPool(); // Singleton-Pool verwenden
+
   try {
     // Ausführen der Datenbankabfrage
     const query = "SELECT idprio, level, name, color FROM prio";
-    const results = await pool.query(query);
+    const [results] = await pool.query(query);
 
     // Wichtig: Senden Sie die Antwort zurück
-    res.status(200).json(results[0]); // Da mysql2 Tuple [rows, fields] zurückgibt, wählen wir nur rows mit [0]
+    res.status(200).json(results); // Nur rows werden zurückgegeben
   } catch (error) {
     console.error("Fehler beim Abrufen der API", error);
     res.status(500).json({ error: "Fehler bei der Abfrage" });

pages/api/talas_v5_DB/station/getAllStationsNames.js

@@ -1,27 +1,21 @@
 // /pages/api/talas_v5_DB/station/getAllStationsNames.js
-import mysql from "mysql2/promise";
-
-// Verbindungspool-Konfiguration
-const pool = mysql.createPool({
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-  port: process.env.DB_PORT,
-  waitForConnections: true,
-  connectionLimit: 10,
-  queueLimit: 0,
-});
+import getPool from "../../../../utils/mysqlPool"; // Importiere den Singleton-Pool
 
 export default async function handler(req, res) {
+  const pool = getPool(); // Verwende den Singleton-Pool
+
   if (req.method !== "GET") {
     res.setHeader("Allow", ["GET"]);
     return res.status(405).end(`Method ${req.method} Not Allowed`);
   }
 
+  let connection;
+
   try {
+    connection = await pool.getConnection(); // Hole eine Verbindung aus dem Pool
+
     // Abrufen aller idLD und ihrer Namen
-    const [results] = await pool.query("SELECT idLD, name FROM location_device");
+    const [results] = await connection.query("SELECT idLD, name FROM location_device");
 
     if (results.length === 0) {
       return res.status(404).json({ error: "No data found" });
@@ -39,5 +33,7 @@ export default async function handler(req, res) {
   } catch (err) {
     console.error("Fehler beim Abrufen der Daten:", err);
     res.status(500).json({ error: "Error retrieving data from the database" });
+  } finally {
+    if (connection) connection.release(); // Gib die Verbindung zurück in den Pool
   }
 }