nodeMap/services/apiService.js

// services/apiService.js
import * as config from "../config/config";
import SERVER_URL from "../config/urls";
const url = new URL(window.location.origin);
const originWithoutPort = `${url.protocol}//${url.hostname}`;

let timeoutId;

const fetchWithTimeout = async (url, options, timeout = 5000) => {
  const controller = new AbortController();
  const id = setTimeout(() => controller.abort(), timeout);

  try {
    const response = await fetch(url, {
      ...options,
      signal: controller.signal,
    });
    clearTimeout(id);
    return response;
  } catch (error) {
    clearTimeout(id); // Im Falle eines Fehlers den Timeout abbrechen
    throw error;
  }
};

export const fetchGisStatusStations = async () => {
  //idMap und idUser von URL Parameter hersuslesen
  const idMap = url.searchParams.get("m");
  const idUser = url.searchParams.get("u");
  // Verhindere wiederholte schnelle API-Aufrufe durch Debouncing
  if (timeoutId) {
    clearTimeout(timeoutId);
  }

  timeoutId = setTimeout(async () => {
    //const SERVER_URL = process.env.NEXT_PUBLIC_SERVER_URL;

    try {
      // Verwende das Timeout für die API-Anfrage
      const response = await fetchWithTimeout(
        `${originWithoutPort}/talas5/ClientData/WebServiceMap.asmx/GisStationsStatusDistrict?idMap=${idMap}&idUser=${idUser}`,
        {
          method: "GET",
          headers: {
            Connection: "close", // Dieser Header stellt sicher, dass die Verbindung nach dem Abruf geschlossen wird
          },
        },
        5000 // Timeout auf 5 Sekunden gesetzt
      );

      if (!response.ok) {
        throw new Error(`Error: ${response.statusText}`);
      }

      const data = await response.json();
      return data;
    } catch (error) {
      console.error("Fehler beim Abrufen der Daten:", error);
      throw error;
    }
  }, 500); // Debounce-Zeit auf 500ms gesetzt
};

// ----------------------------------------------
/* export const fetchPriorityConfig = async () => {
  try {
    const response = await fetch("/api/talas_v5_DB/priorityConfig");
    const data = await response.json();
    console.log("Prioritätskonfiguration:", data);
    setPriorityConfig(data);
  } catch (error) {
    console.error("Fehler beim Laden der Prioritätskonfiguration:", error);
  }
}; */

// ----------------------------------------------
export const fetchPoiData = async (idPoi) => {
  try {
    const response = await fetch(`/api/talas_v5_DB/pois/getPoiById?idPoi=${idPoi}`);
    if (!response.ok) {
      throw new Error("Fehler beim Abrufen der POI-Daten");
    }
    const data = await response.json();
    return {
      idPoi,
      name: data.name,
      description: data.description,
      idLD: data.idLD,
    };
  } catch (error) {
    console.error("Fehler beim Abrufen der POI-Daten", error);
    return null;
  }
};
// ----------------------------------------------
// Funktion zum Aktualisieren der Position in der Datenbank
export const updateLocationInDatabase = async (id, newLatitude, newLongitude) => {
  const response = await fetch("/api/talas_v5_DB/pois/updateLocation", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      id,
      latitude: newLatitude,
      longitude: newLongitude,
    }),
  });

  if (response.ok) {
    //schreib die neue Kooridnaten in die Console
    //akuellisiere die Position in der Datenbank mit den neuen Koordinaten mit updateLocation mit SQL Anweisung UPDATE
  } else {
    console.error("Fehler beim Aktualisieren der Position");
  }
};

// ----------------------------------------------
// Funktionen zur Überwachung der Internetverbindung
export const checkInternet = () => {
  fetch("https://tile.openstreetmap.org/1/1/1.png", { method: "HEAD" })
    .then((response) => setOnline(response.ok))
    .catch(() => setOnline(false));
};

// ----------------------------------------------
export const fetchDeviceNameById = async (idLD) => {
  try {
    const response = await fetch(`/api/talas_v5_DB/locationDevice/locationDeviceNameById?idLD=${idLD}`);
    const data = await response.json();
    if (response.ok) {
      return data.name;
    } else {
      //throw new Error(data.error || "Gerät nicht gefunden");
      throw new Error("Gerät nicht gefunden in apiService.js");
    }
  } catch (error) {
    console.error("Fehler beim Abrufen des Gerätenamens in apiService.js:", error);
    return "Unbekannt";
  }
};

// ----------------------------------------------
// services/apiService.js
export const fetchUserRights = async () => {
  // Aktuelle URL abrufen
  const url = new URL(window.location.href);

  // idMap und idUser von URL-Parametern abrufen
  const idMap = url.searchParams.get("m");
  const idUser = url.searchParams.get("u");

  // Zähler für API-Aufrufe in localStorage speichern
  let userRightsRequestCount = localStorage.getItem("userRightsRequestCount") || 0;
  userRightsRequestCount++;
  localStorage.setItem("userRightsRequestCount", userRightsRequestCount);
  console.log(`fetchUserRights wurde ${userRightsRequestCount} Mal aufgerufen.`);

  try {
    // Basis-URL ohne Port abrufen
    const protocol = window.location.protocol; // z. B. 'http:' oder 'https:'
    const hostname = window.location.hostname; // z. B. 'example.com'
    const originWithoutPort = `${protocol}//${hostname}`; // z. B. 'https://example.com'

    console.log("originWithoutPort in fetchUserRights", originWithoutPort);
    console.log("idMap in fetchUserRights", idMap);
    console.log("idUser in fetchUserRights", idUser);

    const response = await fetch(`${originWithoutPort}/talas5/ClientData/WebserviceMap.asmx/GisSystemStatic?idMap=${idMap}&idUser=${idUser}`, {
      method: "GET",
      headers: {
        Connection: "close",
      },
    });

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const data = await response.json();

    // Überprüfen der Struktur der Antwort
    if (!data || !data.Rights || !Array.isArray(data.Rights)) {
      throw new Error("Invalid response structure");
    }

    const rightsArray = data.Rights; // Rechte-Array abrufen
    const userRightsIds = rightsArray.map((right) => right.IdRight);

    return userRightsIds;
  } catch (error) {
    console.error("Fehler beim Abrufen der Benutzerrechte", error);
    return [];
  }
};