forked from Simnation/Main
1174 lines
41 KiB
Lua
1174 lines
41 KiB
Lua
local QBCore = exports['qb-core']:GetCoreObject()
|
|
|
|
-- Lokale Variablen
|
|
local licenseCache = {}
|
|
local cacheTimeout = 300000 -- 5 Minuten
|
|
|
|
-- Debug-Funktion
|
|
local function debugPrint(message)
|
|
if Config.Debug then
|
|
print("^3[License-System Server] " .. message .. "^7")
|
|
end
|
|
end
|
|
|
|
-- Spieler-Name abrufen
|
|
local function getPlayerName(src)
|
|
local Player = QBCore.Functions.GetPlayer(src)
|
|
if not Player then return "Unbekannt" end
|
|
|
|
local charinfo = Player.PlayerData.charinfo
|
|
if charinfo and charinfo.firstname and charinfo.lastname then
|
|
return charinfo.firstname .. " " .. charinfo.lastname
|
|
end
|
|
|
|
return "Unbekannt"
|
|
end
|
|
|
|
-- Berechtigung prüfen
|
|
local function hasPermission(src)
|
|
local Player = QBCore.Functions.GetPlayer(src)
|
|
if not Player then return false end
|
|
|
|
local job = Player.PlayerData.job
|
|
if not job then return false end
|
|
|
|
return Config.AuthorizedJobs[job.name] or false
|
|
end
|
|
|
|
-- Cache-Funktionen (KORRIGIERT - Aggressive Cache-Invalidierung)
|
|
local function getCachedLicense(citizenid, licenseType)
|
|
local cacheKey = citizenid .. "_" .. licenseType
|
|
local cached = licenseCache[cacheKey]
|
|
|
|
if cached and (os.time() * 1000 - cached.timestamp) < cacheTimeout then
|
|
debugPrint("Cache-Hit für: " .. cacheKey)
|
|
return cached.data
|
|
end
|
|
|
|
return nil
|
|
end
|
|
|
|
local function setCachedLicense(citizenid, licenseType, data)
|
|
local cacheKey = citizenid .. "_" .. licenseType
|
|
licenseCache[cacheKey] = {
|
|
data = data,
|
|
timestamp = os.time() * 1000
|
|
}
|
|
debugPrint("Lizenz gecacht: " .. cacheKey)
|
|
end
|
|
|
|
-- Cache invalidieren (ERWEITERT)
|
|
local function invalidateCache(citizenid, licenseType)
|
|
if licenseType then
|
|
-- Spezifische Lizenz invalidieren
|
|
local cacheKey = citizenid .. "_" .. licenseType
|
|
licenseCache[cacheKey] = nil
|
|
debugPrint("Cache invalidiert für: " .. cacheKey)
|
|
else
|
|
-- Alle Lizenzen des Spielers invalidieren
|
|
for key, _ in pairs(licenseCache) do
|
|
if string.find(key, citizenid .. "_") then
|
|
licenseCache[key] = nil
|
|
debugPrint("Cache invalidiert für: " .. key)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Spieler-Name aus JSON extrahieren
|
|
local function extractPlayerName(charinfo_json)
|
|
if not charinfo_json then return "Unbekannt" end
|
|
|
|
local success, charinfo = pcall(json.decode, charinfo_json)
|
|
if success and charinfo and charinfo.firstname and charinfo.lastname then
|
|
return charinfo.firstname .. " " .. charinfo.lastname
|
|
end
|
|
|
|
return "Unbekannt"
|
|
end
|
|
|
|
-- Sichere DB-Operation
|
|
local function safeDBOperation(operation, errorMessage, maxRetries)
|
|
maxRetries = maxRetries or 3
|
|
local retries = 0
|
|
|
|
while retries < maxRetries do
|
|
retries = retries + 1
|
|
local success, result = pcall(operation)
|
|
|
|
if success then
|
|
return result
|
|
else
|
|
debugPrint("^3DB-Retry " .. retries .. "/" .. maxRetries .. ": " .. tostring(result) .. "^7")
|
|
if retries >= maxRetries then
|
|
debugPrint("^1DB-Fehler: " .. (errorMessage or "Unbekannt") .. "^7")
|
|
debugPrint("^1Details: " .. tostring(result) .. "^7")
|
|
return nil
|
|
end
|
|
Wait(1000)
|
|
end
|
|
end
|
|
|
|
return nil
|
|
end
|
|
|
|
-- Lizenz-Status prüfen (NEUE FUNKTION)
|
|
local function isLicenseActive(license)
|
|
if not license then return false end
|
|
|
|
-- is_active prüfen (1 = aktiv, 0 = inaktiv, nil = aktiv per default)
|
|
local isActive = license.is_active
|
|
if isActive == nil then
|
|
isActive = 1 -- Default: aktiv
|
|
end
|
|
|
|
if isActive ~= 1 then
|
|
debugPrint("Lizenz inaktiv (is_active = " .. tostring(isActive) .. ")")
|
|
return false
|
|
end
|
|
|
|
-- Ablaufdatum prüfen (falls vorhanden)
|
|
if license.expire_date and license.expire_date ~= "" then
|
|
local expireDate = license.expire_date
|
|
local currentDate = os.date("%d.%m.%Y")
|
|
|
|
-- Einfache Datumsvergleich (DD.MM.YYYY)
|
|
local function parseDate(dateStr)
|
|
local day, month, year = dateStr:match("(%d+)%.(%d+)%.(%d+)")
|
|
if day and month and year then
|
|
return os.time({year = tonumber(year), month = tonumber(month), day = tonumber(day)})
|
|
end
|
|
return nil
|
|
end
|
|
|
|
local expireTimestamp = parseDate(expireDate)
|
|
local currentTimestamp = parseDate(currentDate)
|
|
|
|
if expireTimestamp and currentTimestamp and expireTimestamp < currentTimestamp then
|
|
debugPrint("Lizenz abgelaufen: " .. expireDate .. " < " .. currentDate)
|
|
return false
|
|
end
|
|
end
|
|
|
|
debugPrint("Lizenz ist aktiv und gültig")
|
|
return true
|
|
end
|
|
|
|
-- KORRIGIERTE Lizenz-Abfrage (Ohne Cache für frische Daten)
|
|
local function getLicenseFromDB(citizenid, licenseType, skipCache)
|
|
debugPrint("=== getLicenseFromDB START ===")
|
|
debugPrint("CitizenID: " .. tostring(citizenid))
|
|
debugPrint("LicenseType: " .. tostring(licenseType))
|
|
debugPrint("SkipCache: " .. tostring(skipCache))
|
|
|
|
-- Cache prüfen (nur wenn nicht übersprungen)
|
|
if not skipCache then
|
|
local cached = getCachedLicense(citizenid, licenseType)
|
|
if cached then
|
|
debugPrint("Lizenz aus Cache geladen")
|
|
return cached
|
|
end
|
|
end
|
|
|
|
-- Direkte DB-Abfrage (VEREINFACHT - nur aktive Lizenzen)
|
|
local query = [[
|
|
SELECT * FROM player_licenses
|
|
WHERE citizenid = ? AND license_type = ?
|
|
ORDER BY created_at DESC
|
|
LIMIT 1
|
|
]]
|
|
|
|
local result = safeDBOperation(function()
|
|
return MySQL.query.await(query, {citizenid, licenseType})
|
|
end, "Fehler beim Abrufen der Lizenz")
|
|
|
|
if not result or #result == 0 then
|
|
debugPrint("^1Keine Lizenz in DB gefunden für " .. citizenid .. " / " .. licenseType .. "^7")
|
|
return nil
|
|
end
|
|
|
|
local license = result[1]
|
|
debugPrint("Rohe Lizenz-Daten aus DB:")
|
|
debugPrint("ID: " .. tostring(license.id))
|
|
debugPrint("is_active: " .. tostring(license.is_active))
|
|
debugPrint("created_at: " .. tostring(license.created_at))
|
|
|
|
-- Spieler-Namen abrufen
|
|
local holderQuery = "SELECT charinfo FROM players WHERE citizenid = ?"
|
|
local holderResult = safeDBOperation(function()
|
|
return MySQL.query.await(holderQuery, {citizenid})
|
|
end, "Fehler beim Abrufen des Spieler-Namens")
|
|
|
|
if holderResult and #holderResult > 0 then
|
|
license.holder_name = extractPlayerName(holderResult[1].charinfo)
|
|
else
|
|
license.holder_name = "Unbekannt"
|
|
end
|
|
|
|
-- Aussteller-Namen abrufen
|
|
if license.issued_by then
|
|
local issuerQuery = "SELECT charinfo FROM players WHERE citizenid = ?"
|
|
local issuerResult = safeDBOperation(function()
|
|
return MySQL.query.await(issuerQuery, {license.issued_by})
|
|
end, "Fehler beim Abrufen des Aussteller-Namens")
|
|
|
|
if issuerResult and #issuerResult > 0 then
|
|
license.issued_by_name = extractPlayerName(issuerResult[1].charinfo)
|
|
else
|
|
license.issued_by_name = "System"
|
|
end
|
|
else
|
|
license.issued_by_name = "System"
|
|
end
|
|
|
|
-- Classes parsen
|
|
if license.classes then
|
|
local success, classes = pcall(json.decode, license.classes)
|
|
if success and type(classes) == "table" then
|
|
license.classes = classes
|
|
else
|
|
license.classes = {}
|
|
end
|
|
else
|
|
license.classes = {}
|
|
end
|
|
|
|
-- is_active normalisieren (WICHTIG!)
|
|
if license.is_active == nil then
|
|
license.is_active = 1
|
|
debugPrint("is_active war nil, auf 1 gesetzt")
|
|
end
|
|
|
|
-- Status prüfen
|
|
local isActive = isLicenseActive(license)
|
|
debugPrint("Lizenz-Status-Prüfung: " .. tostring(isActive))
|
|
|
|
if not isActive then
|
|
debugPrint("Lizenz ist nicht aktiv/gültig")
|
|
return nil
|
|
end
|
|
|
|
debugPrint("Lizenz erfolgreich geladen: " .. license.license_type .. " (Active: " .. tostring(license.is_active) .. ")")
|
|
|
|
-- In Cache speichern (nur wenn aktiv)
|
|
if not skipCache then
|
|
setCachedLicense(citizenid, licenseType, license)
|
|
end
|
|
|
|
return license
|
|
end
|
|
|
|
-- Alle Lizenzen eines Spielers abrufen (KORRIGIERT)
|
|
local function getAllPlayerLicenses(citizenid)
|
|
debugPrint("=== getAllPlayerLicenses START ===")
|
|
debugPrint("CitizenID: " .. tostring(citizenid))
|
|
|
|
-- Alle Lizenzen abrufen (ohne is_active Filter)
|
|
local query = "SELECT * FROM player_licenses WHERE citizenid = ? ORDER BY license_type, created_at DESC"
|
|
|
|
local result = safeDBOperation(function()
|
|
return MySQL.query.await(query, {citizenid})
|
|
end, "Fehler beim Abrufen aller Lizenzen")
|
|
|
|
if not result or #result == 0 then
|
|
debugPrint("Keine Lizenzen gefunden für: " .. citizenid)
|
|
return {}
|
|
end
|
|
|
|
local licenses = {}
|
|
local seenTypes = {}
|
|
|
|
-- Spieler-Namen einmal abrufen
|
|
local holderQuery = "SELECT charinfo FROM players WHERE citizenid = ?"
|
|
local holderResult = safeDBOperation(function()
|
|
return MySQL.query.await(holderQuery, {citizenid})
|
|
end, "Fehler beim Abrufen des Spieler-Namens")
|
|
|
|
local holderName = "Unbekannt"
|
|
if holderResult and #holderResult > 0 then
|
|
holderName = extractPlayerName(holderResult[1].charinfo)
|
|
end
|
|
|
|
for _, license in ipairs(result) do
|
|
-- Nur die neueste Lizenz pro Typ nehmen
|
|
if not seenTypes[license.license_type] then
|
|
seenTypes[license.license_type] = true
|
|
|
|
license.holder_name = holderName
|
|
|
|
-- Aussteller-Namen abrufen
|
|
if license.issued_by then
|
|
local issuerQuery = "SELECT charinfo FROM players WHERE citizenid = ?"
|
|
local issuerResult = safeDBOperation(function()
|
|
return MySQL.query.await(issuerQuery, {license.issued_by})
|
|
end, "Fehler beim Abrufen des Aussteller-Namens")
|
|
|
|
if issuerResult and #issuerResult > 0 then
|
|
license.issued_by_name = extractPlayerName(issuerResult[1].charinfo)
|
|
else
|
|
license.issued_by_name = "System"
|
|
end
|
|
else
|
|
license.issued_by_name = "System"
|
|
end
|
|
|
|
-- Classes parsen
|
|
if license.classes then
|
|
local success, classes = pcall(json.decode, license.classes)
|
|
if success and type(classes) == "table" then
|
|
license.classes = classes
|
|
else
|
|
license.classes = {}
|
|
end
|
|
else
|
|
license.classes = {}
|
|
end
|
|
|
|
-- is_active normalisieren
|
|
if license.is_active == nil then
|
|
license.is_active = 1
|
|
end
|
|
|
|
-- Status prüfen und nur aktive Lizenzen hinzufügen
|
|
if isLicenseActive(license) then
|
|
table.insert(licenses, license)
|
|
debugPrint("Aktive Lizenz hinzugefügt: " .. license.license_type)
|
|
else
|
|
debugPrint("Inaktive Lizenz übersprungen: " .. license.license_type)
|
|
end
|
|
end
|
|
end
|
|
|
|
debugPrint("Verarbeitete aktive Lizenzen: " .. #licenses)
|
|
return licenses
|
|
end
|
|
|
|
-- Lizenz in Datenbank speichern (KORRIGIERT - Explizite is_active Setzung)
|
|
local function saveLicenseToDB(citizenid, licenseType, issuedBy, classes)
|
|
debugPrint("=== saveLicenseToDB START ===")
|
|
debugPrint("CitizenID: " .. tostring(citizenid))
|
|
debugPrint("LicenseType: " .. tostring(licenseType))
|
|
debugPrint("IssuedBy: " .. tostring(issuedBy))
|
|
|
|
local config = Config.LicenseTypes[licenseType]
|
|
if not config then
|
|
debugPrint("^1Fehler: Unbekannter Lizenztyp: " .. licenseType .. "^7")
|
|
return false
|
|
end
|
|
|
|
-- Cache für diesen Spieler komplett invalidieren
|
|
invalidateCache(citizenid)
|
|
|
|
-- Spieler-Name abrufen
|
|
local holderQuery = "SELECT charinfo FROM players WHERE citizenid = ?"
|
|
local holderResult = safeDBOperation(function()
|
|
return MySQL.query.await(holderQuery, {citizenid})
|
|
end, "Fehler beim Abrufen des Spieler-Namens")
|
|
|
|
local holderName = "Unbekannt"
|
|
if holderResult and #holderResult > 0 and holderResult[1].charinfo then
|
|
holderName = extractPlayerName(holderResult[1].charinfo)
|
|
end
|
|
|
|
-- Datum berechnen
|
|
local issueDate = os.date("%d.%m.%Y")
|
|
local expireDate = nil
|
|
|
|
if config.validity_days then
|
|
local expireTimestamp = os.time() + (config.validity_days * 24 * 60 * 60)
|
|
expireDate = os.date("%d.%m.%Y", expireTimestamp)
|
|
end
|
|
|
|
-- Classes zu JSON konvertieren
|
|
local classesJson = json.encode(classes or {})
|
|
|
|
-- WICHTIG: Alte Lizenz explizit deaktivieren
|
|
local deactivateQuery = "UPDATE player_licenses SET is_active = 0 WHERE citizenid = ? AND license_type = ?"
|
|
local deactivateResult = safeDBOperation(function()
|
|
return MySQL.query.await(deactivateQuery, {citizenid, licenseType})
|
|
end, "Fehler beim Deaktivieren alter Lizenz")
|
|
|
|
debugPrint("Alte Lizenzen deaktiviert: " .. tostring(deactivateResult ~= nil))
|
|
|
|
-- Neue Lizenz einfügen (EXPLIZIT is_active = 1)
|
|
local insertQuery = [[
|
|
INSERT INTO player_licenses
|
|
(citizenid, license_type, name, issue_date, expire_date, issued_by, is_active, classes, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)
|
|
]]
|
|
|
|
local createdAt = os.time() -- Unix Timestamp
|
|
|
|
local insertData = {
|
|
citizenid,
|
|
licenseType,
|
|
holderName,
|
|
issueDate,
|
|
expireDate,
|
|
issuedBy,
|
|
-- is_active = 1 ist direkt in der Query
|
|
classesJson,
|
|
createdAt
|
|
}
|
|
|
|
debugPrint("Führe INSERT-Query aus...")
|
|
debugPrint("Daten: " .. json.encode(insertData))
|
|
|
|
local result = safeDBOperation(function()
|
|
return MySQL.insert.await(insertQuery, insertData)
|
|
end, "Fehler beim Speichern der Lizenz")
|
|
|
|
if result then
|
|
debugPrint("Lizenz erfolgreich gespeichert. ID: " .. result)
|
|
|
|
-- Cache komplett invalidieren (sicherstellen dass neue Daten geladen werden)
|
|
invalidateCache(citizenid)
|
|
|
|
-- Sofort neue Lizenz aus DB laden um zu verifizieren
|
|
Wait(100) -- Kurz warten
|
|
local newLicense = getLicenseFromDB(citizenid, licenseType, true) -- Skip Cache
|
|
|
|
if newLicense then
|
|
debugPrint("Neue Lizenz erfolgreich verifiziert: is_active = " .. tostring(newLicense.is_active))
|
|
else
|
|
debugPrint("^3Warnung: Neue Lizenz konnte nicht verifiziert werden^7")
|
|
end
|
|
|
|
return true
|
|
else
|
|
debugPrint("^1Fehler beim Speichern der Lizenz^7")
|
|
return false
|
|
end
|
|
end
|
|
|
|
-- Lizenz entziehen (KORRIGIERT)
|
|
local function revokeLicenseInDB(citizenid, licenseType)
|
|
debugPrint("=== revokeLicenseInDB START ===")
|
|
debugPrint("CitizenID: " .. tostring(citizenid))
|
|
debugPrint("LicenseType: " .. tostring(licenseType))
|
|
|
|
local query = "UPDATE player_licenses SET is_active = 0 WHERE citizenid = ? AND license_type = ? AND is_active = 1"
|
|
|
|
local result = safeDBOperation(function()
|
|
return MySQL.query.await(query, {citizenid, licenseType})
|
|
end, "Fehler beim Entziehen der Lizenz")
|
|
|
|
if result then
|
|
debugPrint("Lizenz erfolgreich entzogen")
|
|
|
|
-- Cache invalidieren
|
|
invalidateCache(citizenid, licenseType)
|
|
|
|
return true
|
|
else
|
|
debugPrint("^1Fehler beim Entziehen der Lizenz^7")
|
|
return false
|
|
end
|
|
end
|
|
|
|
-- Cache bereinigen
|
|
local function cleanupCache()
|
|
local now = os.time() * 1000
|
|
local cleaned = 0
|
|
|
|
for key, cached in pairs(licenseCache) do
|
|
if (now - cached.timestamp) > cacheTimeout then
|
|
licenseCache[key] = nil
|
|
cleaned = cleaned + 1
|
|
end
|
|
end
|
|
|
|
if cleaned > 0 then
|
|
debugPrint("Cache bereinigt: " .. cleaned .. " Einträge")
|
|
end
|
|
end
|
|
|
|
-- Cache-Cleanup Thread
|
|
CreateThread(function()
|
|
while true do
|
|
Wait(300000) -- 5 Minuten
|
|
cleanupCache()
|
|
end
|
|
end)
|
|
|
|
-- EVENT HANDLER: Lizenz anfordern
|
|
RegisterNetEvent('license-system:server:requestLicense', function(targetId)
|
|
local src = source
|
|
debugPrint("=== Event: requestLicense ===")
|
|
debugPrint("Source: " .. src .. ", Target: " .. targetId)
|
|
|
|
if not hasPermission(src) then
|
|
debugPrint("Keine Berechtigung für Spieler: " .. src)
|
|
TriggerClientEvent('license-system:client:receiveLicense', src, nil)
|
|
return
|
|
end
|
|
|
|
local targetPlayer = QBCore.Functions.GetPlayer(targetId)
|
|
if not targetPlayer then
|
|
debugPrint("Ziel-Spieler nicht gefunden: " .. targetId)
|
|
TriggerClientEvent('license-system:client:receiveLicense', src, nil)
|
|
return
|
|
end
|
|
|
|
local citizenid = targetPlayer.PlayerData.citizenid
|
|
|
|
-- PRIORITÄT: Erst nach Ausweis suchen, dann andere Lizenzen
|
|
local licenseTypes = {"id_card", "driver_license", "weapon_license", "pilot_license"}
|
|
local foundLicense = nil
|
|
|
|
for _, licenseType in ipairs(licenseTypes) do
|
|
if Config.LicenseTypes[licenseType] then
|
|
local license = getLicenseFromDB(citizenid, licenseType, true) -- Skip Cache für frische Daten
|
|
|
|
if license then
|
|
foundLicense = {
|
|
license = license,
|
|
config = Config.LicenseTypes[licenseType]
|
|
}
|
|
debugPrint("Lizenz gefunden: " .. licenseType)
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
if foundLicense then
|
|
debugPrint("Sende Lizenz an Client: " .. foundLicense.license.license_type)
|
|
TriggerClientEvent('license-system:client:receiveLicense', src, foundLicense)
|
|
else
|
|
debugPrint("Keine Lizenz gefunden")
|
|
TriggerClientEvent('license-system:client:receiveLicense', src, nil)
|
|
end
|
|
end)
|
|
|
|
-- EVENT HANDLER: Eigene Lizenz anfordern (KORRIGIERT)
|
|
RegisterNetEvent('license-system:server:requestMyLicense', function(licenseType)
|
|
local src = source
|
|
debugPrint("=== Event: requestMyLicense ===")
|
|
debugPrint("Source: " .. src .. ", LicenseType: " .. tostring(licenseType))
|
|
|
|
local Player = QBCore.Functions.GetPlayer(src)
|
|
if not Player then
|
|
debugPrint("Spieler nicht gefunden: " .. src)
|
|
TriggerClientEvent('license-system:client:receiveMyLicense', src, nil, licenseType)
|
|
return
|
|
end
|
|
|
|
local citizenid = Player.PlayerData.citizenid
|
|
|
|
-- Falls kein spezifischer Typ angegeben, suche nach Ausweis
|
|
if not licenseType or licenseType == "" then
|
|
licenseType = "id_card"
|
|
debugPrint("Kein Lizenztyp angegeben, verwende: " .. licenseType)
|
|
end
|
|
|
|
local license = getLicenseFromDB(citizenid, licenseType, true) -- Skip Cache für frische Daten
|
|
|
|
if license then
|
|
local licenseData = {
|
|
license = license,
|
|
config = Config.LicenseTypes[licenseType]
|
|
}
|
|
debugPrint("Sende eigene Lizenz an Client: " .. licenseType)
|
|
TriggerClientEvent('license-system:client:receiveMyLicense', src, licenseData, licenseType)
|
|
else
|
|
debugPrint("Keine aktive eigene Lizenz gefunden: " .. licenseType)
|
|
TriggerClientEvent('license-system:client:receiveMyLicense', src, nil, licenseType)
|
|
end
|
|
end)
|
|
|
|
-- EVENT HANDLER: Alle Spieler-Lizenzen anfordern
|
|
RegisterNetEvent('license-system:server:requestPlayerLicenses', function(targetId)
|
|
local src = source
|
|
debugPrint("=== Event: requestPlayerLicenses ===")
|
|
debugPrint("Source: " .. src .. ", Target: " .. targetId)
|
|
|
|
if not hasPermission(src) then
|
|
debugPrint("Keine Berechtigung für Spieler: " .. src)
|
|
TriggerClientEvent('license-system:client:receivePlayerLicenses', src, {}, targetId, "Unbekannt")
|
|
return
|
|
end
|
|
|
|
local targetPlayer = QBCore.Functions.GetPlayer(targetId)
|
|
if not targetPlayer then
|
|
debugPrint("Ziel-Spieler nicht gefunden: " .. targetId)
|
|
TriggerClientEvent('license-system:client:receivePlayerLicenses', src, {}, targetId, "Unbekannt")
|
|
return
|
|
end
|
|
|
|
local citizenid = targetPlayer.PlayerData.citizenid
|
|
local targetName = getPlayerName(targetId)
|
|
local licenses = getAllPlayerLicenses(citizenid)
|
|
|
|
debugPrint("Sende " .. #licenses .. " Lizenzen für " .. targetName)
|
|
TriggerClientEvent('license-system:client:receivePlayerLicenses', src, licenses, targetId, targetName)
|
|
end)
|
|
|
|
-- EVENT HANDLER: Lizenz ausstellen (KORRIGIERT)
|
|
RegisterNetEvent('license-system:server:issueLicense', function(targetId, licenseType, classes)
|
|
local src = source
|
|
debugPrint("=== Event: issueLicense ===")
|
|
debugPrint("Source: " .. src .. ", Target: " .. targetId .. ", Type: " .. licenseType)
|
|
|
|
if not hasPermission(src) then
|
|
debugPrint("Keine Berechtigung für Spieler: " .. src)
|
|
TriggerClientEvent('QBCore:Notify', src, Config.Notifications.no_permission.message, Config.Notifications.no_permission.type)
|
|
return
|
|
end
|
|
|
|
local targetPlayer = QBCore.Functions.GetPlayer(targetId)
|
|
if not targetPlayer then
|
|
debugPrint("Ziel-Spieler nicht gefunden: " .. targetId)
|
|
TriggerClientEvent('QBCore:Notify', src, 'Spieler nicht gefunden!', 'error')
|
|
return
|
|
end
|
|
|
|
local issuerPlayer = QBCore.Functions.GetPlayer(src)
|
|
if not issuerPlayer then
|
|
debugPrint("Aussteller nicht gefunden: " .. src)
|
|
return
|
|
end
|
|
|
|
local targetCitizenId = targetPlayer.PlayerData.citizenid
|
|
local issuerCitizenId = issuerPlayer.PlayerData.citizenid
|
|
|
|
-- Prüfen ob aktive Lizenz bereits existiert (Skip Cache)
|
|
local existingLicense = getLicenseFromDB(targetCitizenId, licenseType, true)
|
|
|
|
if existingLicense then
|
|
debugPrint("Lizenz bereits vorhanden und aktiv")
|
|
TriggerClientEvent('QBCore:Notify', src, 'Spieler hat bereits eine aktive ' .. (Config.LicenseTypes[licenseType].label or licenseType) .. '!', 'error')
|
|
return
|
|
end
|
|
|
|
-- Kosten prüfen
|
|
local config = Config.LicenseTypes[licenseType]
|
|
if config.price and config.price > 0 then
|
|
if issuerPlayer.PlayerData.money.cash < config.price then
|
|
debugPrint("Nicht genug Geld für Lizenz-Ausstellung")
|
|
TriggerClientEvent('QBCore:Notify', src, 'Nicht genug Bargeld! Benötigt: $' .. config.price, 'error')
|
|
return
|
|
end
|
|
|
|
-- Geld abziehen
|
|
issuerPlayer.Functions.RemoveMoney('cash', config.price, 'license-issued')
|
|
TriggerClientEvent('QBCore:Notify', src, 'Lizenz-Gebühr bezahlt: $' .. config.price, 'success')
|
|
end
|
|
|
|
-- Lizenz in Datenbank speichern
|
|
local success = saveLicenseToDB(targetCitizenId, licenseType, issuerCitizenId, classes)
|
|
|
|
if success then
|
|
local targetName = getPlayerName(targetId)
|
|
local issuerName = getPlayerName(src)
|
|
|
|
debugPrint("Lizenz erfolgreich ausgestellt")
|
|
|
|
-- Benachrichtigungen
|
|
TriggerClientEvent('QBCore:Notify', src, 'Lizenz erfolgreich ausgestellt für ' .. targetName, 'success')
|
|
TriggerClientEvent('QBCore:Notify', targetId, 'Du hast eine neue Lizenz erhalten: ' .. config.label, 'success')
|
|
|
|
-- Events senden
|
|
TriggerClientEvent('license-system:client:licenseIssued', src, targetId, licenseType)
|
|
TriggerClientEvent('license-system:client:refreshMenu', src)
|
|
|
|
-- Log
|
|
debugPrint("Lizenz " .. licenseType .. " ausgestellt von " .. issuerName .. " für " .. targetName)
|
|
else
|
|
debugPrint("^1Fehler beim Ausstellen der Lizenz^7")
|
|
TriggerClientEvent('QBCore:Notify', src, 'Fehler beim Ausstellen der Lizenz!', 'error')
|
|
end
|
|
end)
|
|
|
|
-- EVENT HANDLER: Lizenz entziehen
|
|
RegisterNetEvent('license-system:server:revokeLicense', function(targetId, licenseType)
|
|
local src = source
|
|
debugPrint("=== Event: revokeLicense ===")
|
|
debugPrint("Source: " .. src .. ", Target: " .. targetId .. ", Type: " .. licenseType)
|
|
|
|
if not hasPermission(src) then
|
|
debugPrint("Keine Berechtigung für Spieler: " .. src)
|
|
TriggerClientEvent('QBCore:Notify', src, Config.Notifications.no_permission.message, Config.Notifications.no_permission.type)
|
|
return
|
|
end
|
|
|
|
local targetPlayer = QBCore.Functions.GetPlayer(targetId)
|
|
if not targetPlayer then
|
|
debugPrint("Ziel-Spieler nicht gefunden: " .. targetId)
|
|
TriggerClientEvent('QBCore:Notify', src, 'Spieler nicht gefunden!', 'error')
|
|
return
|
|
end
|
|
|
|
local targetCitizenId = targetPlayer.PlayerData.citizenid
|
|
|
|
-- Lizenz entziehen
|
|
local success = revokeLicenseInDB(targetCitizenId, licenseType)
|
|
|
|
if success then
|
|
local targetName = getPlayerName(targetId)
|
|
local issuerName = getPlayerName(src)
|
|
local config = Config.LicenseTypes[licenseType]
|
|
|
|
debugPrint("Lizenz erfolgreich entzogen")
|
|
|
|
-- Benachrichtigungen
|
|
TriggerClientEvent('QBCore:Notify', src, 'Lizenz erfolgreich entzogen von ' .. targetName, 'success')
|
|
TriggerClientEvent('QBCore:Notify', targetId, 'Deine Lizenz wurde entzogen: ' .. (config.label or licenseType), 'error')
|
|
|
|
-- Events senden
|
|
TriggerClientEvent('license-system:client:licenseRevoked', src, targetId, licenseType)
|
|
TriggerClientEvent('license-system:client:refreshMenu', src)
|
|
|
|
-- Log
|
|
debugPrint("Lizenz " .. licenseType .. " entzogen von " .. issuerName .. " für " .. targetName)
|
|
else
|
|
debugPrint("^1Fehler beim Entziehen der Lizenz^7")
|
|
TriggerClientEvent('QBCore:Notify', src, 'Fehler beim Entziehen der Lizenz!',
|
|
'error')
|
|
end
|
|
end)
|
|
|
|
-- EXPORT FUNKTIONEN (KORRIGIERT)
|
|
exports('hasLicense', function(citizenid, licenseType)
|
|
if not citizenid or not licenseType then return false end
|
|
|
|
local license = getLicenseFromDB(citizenid, licenseType, true) -- Skip Cache für aktuelle Daten
|
|
return license ~= nil
|
|
end)
|
|
|
|
exports('issueLicense', function(citizenid, licenseType, issuedBy, classes)
|
|
if not citizenid or not licenseType then return false end
|
|
|
|
issuedBy = issuedBy or 'system'
|
|
return saveLicenseToDB(citizenid, licenseType, issuedBy, classes)
|
|
end)
|
|
|
|
exports('revokeLicense', function(citizenid, licenseType)
|
|
if not citizenid or not licenseType then return false end
|
|
|
|
return revokeLicenseInDB(citizenid, licenseType)
|
|
end)
|
|
|
|
exports('getPlayerLicenses', function(citizenid)
|
|
if not citizenid then return {} end
|
|
|
|
return getAllPlayerLicenses(citizenid)
|
|
end)
|
|
|
|
exports('getPlayerLicense', function(citizenid, licenseType)
|
|
if not citizenid or not licenseType then return nil end
|
|
|
|
return getLicenseFromDB(citizenid, licenseType, true) -- Skip Cache
|
|
end)
|
|
|
|
-- DEBUG COMMAND: Lizenz manuell erstellen
|
|
RegisterCommand('createlicense', function(source, args, rawCommand)
|
|
if source == 0 then -- Console only
|
|
if #args < 2 then
|
|
print("Usage: createlicense <citizenid> <license_type>")
|
|
return
|
|
end
|
|
|
|
local citizenid = args[1]
|
|
local licenseType = args[2]
|
|
|
|
if not Config.LicenseTypes[licenseType] then
|
|
print("Unbekannter Lizenztyp: " .. licenseType)
|
|
return
|
|
end
|
|
|
|
local success = saveLicenseToDB(citizenid, licenseType, 'console', {})
|
|
|
|
if success then
|
|
print("Lizenz erfolgreich erstellt: " .. licenseType .. " für " .. citizenid)
|
|
else
|
|
print("Fehler beim Erstellen der Lizenz")
|
|
end
|
|
end
|
|
end, true)
|
|
|
|
-- DEBUG COMMAND: Lizenz prüfen (ERWEITERT)
|
|
RegisterCommand('checklicense', function(source, args, rawCommand)
|
|
if source == 0 then -- Console only
|
|
if #args < 2 then
|
|
print("Usage: checklicense <citizenid> <license_type>")
|
|
return
|
|
end
|
|
|
|
local citizenid = args[1]
|
|
local licenseType = args[2]
|
|
|
|
-- Direkte DB-Abfrage ohne Cache
|
|
local query = "SELECT * FROM player_licenses WHERE citizenid = ? AND license_type = ? ORDER BY created_at DESC"
|
|
local result = MySQL.query.await(query, {citizenid, licenseType})
|
|
|
|
if result and #result > 0 then
|
|
print("=== ALLE LIZENZEN GEFUNDEN ===")
|
|
for i, license in ipairs(result) do
|
|
print("--- Lizenz " .. i .. " ---")
|
|
print("ID: " .. (license.id or "N/A"))
|
|
print("CitizenID: " .. (license.citizenid or "N/A"))
|
|
print("Typ: " .. (license.license_type or "N/A"))
|
|
print("Name: " .. (license.name or "N/A"))
|
|
print("Ausstellungsdatum: " .. (license.issue_date or "N/A"))
|
|
print("Ablaufdatum: " .. (license.expire_date or "N/A"))
|
|
print("Ausgestellt von: " .. (license.issued_by or "N/A"))
|
|
print("Aktiv (DB): " .. tostring(license.is_active))
|
|
print("Klassen: " .. (license.classes or "[]"))
|
|
print("Erstellt am: " .. (license.created_at or "N/A"))
|
|
print("---")
|
|
end
|
|
print("===============================")
|
|
|
|
-- Zusätzlich: Lizenz über Funktion prüfen
|
|
local license = getLicenseFromDB(citizenid, licenseType, true)
|
|
if license then
|
|
print("=== AKTIVE LIZENZ (über Funktion) ===")
|
|
print("Typ: " .. license.license_type)
|
|
print("Aktiv: " .. tostring(license.is_active))
|
|
print("Status-Check: " .. tostring(isLicenseActive(license)))
|
|
print("====================================")
|
|
else
|
|
print("=== KEINE AKTIVE LIZENZ (über Funktion) ===")
|
|
end
|
|
else
|
|
print("Keine Lizenz gefunden für: " .. citizenid .. " / " .. licenseType)
|
|
end
|
|
end
|
|
end, true)
|
|
|
|
-- DEBUG COMMAND: Alle Lizenzen eines Spielers anzeigen
|
|
RegisterCommand('checkalllicenses', function(source, args, rawCommand)
|
|
if source == 0 then -- Console only
|
|
if #args < 1 then
|
|
print("Usage: checkalllicenses <citizenid>")
|
|
return
|
|
end
|
|
|
|
local citizenid = args[1]
|
|
|
|
-- Direkte DB-Abfrage
|
|
local query = "SELECT * FROM player_licenses WHERE citizenid = ? ORDER BY license_type, created_at DESC"
|
|
local result = MySQL.query.await(query, {citizenid})
|
|
|
|
if result and #result > 0 then
|
|
print("=== ALLE LIZENZEN FÜR " .. citizenid .. " ===")
|
|
for i, license in ipairs(result) do
|
|
print(i .. ". " .. license.license_type .. " | Aktiv: " .. tostring(license.is_active) .. " | ID: " .. license.id)
|
|
end
|
|
print("=========================================")
|
|
|
|
-- Über Funktion
|
|
local activeLicenses = getAllPlayerLicenses(citizenid)
|
|
print("=== AKTIVE LIZENZEN (über Funktion) ===")
|
|
for i, license in ipairs(activeLicenses) do
|
|
print(i .. ". " .. license.license_type .. " | Aktiv: " .. tostring(license.is_active))
|
|
end
|
|
print("======================================")
|
|
else
|
|
print("Keine Lizenzen gefunden für: " .. citizenid)
|
|
end
|
|
end
|
|
end, true)
|
|
|
|
-- DEBUG COMMAND: Lizenz-Status forciert aktualisieren
|
|
RegisterCommand('fixlicense', function(source, args, rawCommand)
|
|
if source == 0 then -- Console only
|
|
if #args < 2 then
|
|
print("Usage: fixlicense <citizenid> <license_type>")
|
|
return
|
|
end
|
|
|
|
local citizenid = args[1]
|
|
local licenseType = args[2]
|
|
|
|
-- Neueste Lizenz auf aktiv setzen
|
|
local query = [[
|
|
UPDATE player_licenses
|
|
SET is_active = 1
|
|
WHERE citizenid = ? AND license_type = ? AND id = (
|
|
SELECT id FROM (
|
|
SELECT id FROM player_licenses
|
|
WHERE citizenid = ? AND license_type = ?
|
|
ORDER BY created_at DESC LIMIT 1
|
|
) as temp
|
|
)
|
|
]]
|
|
|
|
local result = MySQL.query.await(query, {citizenid, licenseType, citizenid, licenseType})
|
|
|
|
if result then
|
|
print("Lizenz-Status aktualisiert für: " .. citizenid .. " / " .. licenseType)
|
|
|
|
-- Cache invalidieren
|
|
invalidateCache(citizenid, licenseType)
|
|
|
|
-- Prüfen
|
|
local license = getLicenseFromDB(citizenid, licenseType, true)
|
|
if license then
|
|
print("Lizenz ist jetzt aktiv: " .. tostring(license.is_active))
|
|
else
|
|
print("Lizenz konnte nicht geladen werden")
|
|
end
|
|
else
|
|
print("Fehler beim Aktualisieren der Lizenz")
|
|
end
|
|
end
|
|
end, true)
|
|
|
|
-- INITIALISIERUNG
|
|
CreateThread(function()
|
|
debugPrint("License-System Server gestartet (Status-Fix)")
|
|
|
|
-- Warten bis QBCore geladen ist
|
|
while not QBCore do
|
|
Wait(100)
|
|
end
|
|
|
|
debugPrint("QBCore erfolgreich geladen")
|
|
|
|
-- Datenbank-Verbindung testen
|
|
local testResult = safeDBOperation(function()
|
|
return MySQL.query.await("SELECT 1 as test")
|
|
end, "Datenbank-Verbindungstest")
|
|
|
|
if testResult then
|
|
debugPrint("Datenbank-Verbindung erfolgreich")
|
|
else
|
|
debugPrint("^1Datenbank-Verbindung fehlgeschlagen^7")
|
|
end
|
|
|
|
debugPrint("License-System Server vollständig initialisiert")
|
|
end)
|
|
|
|
-- CLEANUP
|
|
AddEventHandler('onResourceStop', function(resourceName)
|
|
if GetCurrentResourceName() == resourceName then
|
|
debugPrint("License-System Server gestoppt")
|
|
licenseCache = {}
|
|
end
|
|
end)
|
|
|
|
-- DEBUG COMMANDS
|
|
RegisterCommand('licensestats', function(source, args, rawCommand)
|
|
if source == 0 then -- Console only
|
|
local cacheCount = 0
|
|
for _ in pairs(licenseCache) do
|
|
cacheCount = cacheCount + 1
|
|
end
|
|
|
|
print("=== LICENSE SYSTEM STATS ===")
|
|
print("Cache Entries: " .. cacheCount)
|
|
print("Config License Types: " .. (Config.LicenseTypes and table.count(Config.LicenseTypes) or 0))
|
|
print("============================")
|
|
end
|
|
end, true)
|
|
|
|
RegisterCommand('licenseclearcache', function(source, args, rawCommand)
|
|
if source == 0 then -- Console only
|
|
local oldCount = 0
|
|
for _ in pairs(licenseCache) do
|
|
oldCount = oldCount + 1
|
|
end
|
|
|
|
licenseCache = {}
|
|
print("License-Cache geleert. Entfernte Einträge: " .. oldCount)
|
|
end
|
|
end, true)
|
|
|
|
-- Hilfsfunktion für table.count
|
|
function table.count(t)
|
|
local count = 0
|
|
for _ in pairs(t) do
|
|
count = count + 1
|
|
end
|
|
return count
|
|
end
|
|
|
|
-- Neuer Event-Handler für benutzerdefinierte Lizenzen
|
|
RegisterNetEvent('license-system:server:issueCustomLicense', function(targetId, licenseType, customData, classes)
|
|
local src = source
|
|
local Player = QBCore.Functions.GetPlayer(src)
|
|
local TargetPlayer = QBCore.Functions.GetPlayer(targetId)
|
|
|
|
if not Player or not TargetPlayer then
|
|
debugPrint("Spieler nicht gefunden: " .. src .. " -> " .. targetId)
|
|
return
|
|
end
|
|
|
|
-- Berechtigung prüfen
|
|
if not isAuthorized(Player.PlayerData.job.name) then
|
|
TriggerClientEvent('QBCore:Notify', src, Config.Notifications.no_permission.message, Config.Notifications.no_permission.type)
|
|
return
|
|
end
|
|
|
|
-- Lizenz-Konfiguration prüfen
|
|
local config = Config.LicenseTypes[licenseType]
|
|
if not config then
|
|
debugPrint("Unbekannter Lizenztyp: " .. licenseType)
|
|
return
|
|
end
|
|
|
|
debugPrint("Erstelle benutzerdefinierte Lizenz: " .. licenseType .. " für " .. TargetPlayer.PlayerData.citizenid)
|
|
|
|
-- Benutzerdefinierte Daten validieren und bereinigen
|
|
local validatedData = {}
|
|
|
|
for _, field in ipairs(config.custom_fields or {}) do
|
|
local value = customData[field.name]
|
|
|
|
-- Pflichtfeld-Prüfung
|
|
if field.required and (not value or value == "") then
|
|
TriggerClientEvent('QBCore:Notify', src, "Feld '" .. field.label .. "' ist erforderlich", "error")
|
|
return
|
|
end
|
|
|
|
-- Wert bereinigen und validieren
|
|
if value and value ~= "" then
|
|
value = string.gsub(value, "'", "''") -- SQL-Injection Schutz
|
|
|
|
-- Typ-spezifische Validierung
|
|
if field.type == "url" and not string.match(value, "^https?://") then
|
|
TriggerClientEvent('QBCore:Notify', src, "Ungültige URL in Feld '" .. field.label .. "'", "error")
|
|
return
|
|
end
|
|
|
|
if field.type == "date" and not string.match(value, "^%d%d%.%d%d%.%d%d%d%d$") then
|
|
TriggerClientEvent('QBCore:Notify', src, "Ungültiges Datum in Feld '" .. field.label .. "'", "error")
|
|
return
|
|
end
|
|
|
|
validatedData[field.name] = value
|
|
end
|
|
end
|
|
|
|
-- Klassen validieren
|
|
local validatedClasses = {}
|
|
if config.classes and classes then
|
|
for _, class in ipairs(classes) do
|
|
if config.classes[class.key] then
|
|
table.insert(validatedClasses, class)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Lizenz in Datenbank speichern
|
|
local success = saveCustomLicenseToDB(
|
|
TargetPlayer.PlayerData.citizenid,
|
|
licenseType,
|
|
Player.PlayerData.charinfo.firstname .. " " .. Player.PlayerData.charinfo.lastname,
|
|
validatedData,
|
|
validatedClasses
|
|
)
|
|
|
|
if success then
|
|
debugPrint("Benutzerdefinierte Lizenz erfolgreich gespeichert")
|
|
|
|
-- Cache invalidieren
|
|
invalidateCache(TargetPlayer.PlayerData.citizenid, licenseType)
|
|
|
|
-- Benachrichtigungen
|
|
TriggerClientEvent('QBCore:Notify', src, Config.Notifications.license_issued.message, Config.Notifications.license_issued.type)
|
|
TriggerClientEvent('QBCore:Notify', targetId, "Du hast eine " .. config.label .. " erhalten!", "success")
|
|
|
|
-- Events
|
|
TriggerClientEvent('license-system:client:licenseIssued', src, targetId, licenseType)
|
|
TriggerClientEvent('license-system:client:refreshMenu', src)
|
|
|
|
-- Log
|
|
debugPrint("Lizenz ausgestellt: " .. licenseType .. " von " .. Player.PlayerData.name .. " an " .. TargetPlayer.PlayerData.name)
|
|
else
|
|
debugPrint("Fehler beim Speichern der benutzerdefinierten Lizenz")
|
|
TriggerClientEvent('QBCore:Notify', src, "Fehler beim Ausstellen der Lizenz", "error")
|
|
end
|
|
end)
|
|
|
|
-- Funktion zum Speichern benutzerdefinierter Lizenzen
|
|
function saveCustomLicenseToDB(citizenid, licenseType, issuedBy, customData, classes)
|
|
local config = Config.LicenseTypes[licenseType]
|
|
if not config then return false end
|
|
|
|
-- Ablaufdatum berechnen
|
|
local expireDate = nil
|
|
if config.validity_days then
|
|
expireDate = os.date('%Y-%m-%d %H:%M:%S', os.time() + (config.validity_days * 24 * 60 * 60))
|
|
end
|
|
|
|
-- Holder-Name aus Custom-Data oder Standard
|
|
local holderName = customData.holder_name or "Unbekannt"
|
|
|
|
return safeDBOperation(function()
|
|
-- Alte Lizenzen deaktivieren
|
|
local deactivateQuery = "UPDATE player_licenses SET is_active = 0 WHERE citizenid = ? AND license_type = ?"
|
|
MySQL.query.await(deactivateQuery, {citizenid, licenseType})
|
|
|
|
-- Neue Lizenz einfügen
|
|
local insertQuery = [[
|
|
INSERT INTO player_licenses
|
|
(citizenid, license_type, name, issue_date, expire_date, issued_by, is_active, classes, custom_data, holder_name)
|
|
VALUES (?, ?, ?, NOW(), ?, ?, 1, ?, ?, ?)
|
|
]]
|
|
|
|
local result = MySQL.insert.await(insertQuery, {
|
|
citizenid,
|
|
licenseType,
|
|
config.label,
|
|
expireDate,
|
|
issuedBy,
|
|
json.encode(classes or {}),
|
|
json.encode(customData or {}),
|
|
holderName
|
|
})
|
|
|
|
return result and result > 0
|
|
end, "Benutzerdefinierte Lizenz speichern")
|
|
end
|
|
|
|
-- Erweiterte Lizenz-Abruf-Funktion
|
|
function getLicenseFromDB(citizenid, licenseType, skipCache)
|
|
-- Cache prüfen
|
|
local cacheKey = citizenid .. "_" .. licenseType
|
|
if not skipCache and licenseCache[cacheKey] then
|
|
debugPrint("Lizenz aus Cache geladen: " .. licenseType)
|
|
return licenseCache[cacheKey]
|
|
end
|
|
|
|
local license = safeDBOperation(function()
|
|
local query = [[
|
|
SELECT *,
|
|
CASE
|
|
WHEN expire_date IS NULL THEN 1
|
|
WHEN expire_date > NOW() THEN 1
|
|
ELSE 0
|
|
END as is_valid
|
|
FROM player_licenses
|
|
WHERE citizenid = ? AND license_type = ? AND is_active = 1
|
|
ORDER BY created_at DESC
|
|
LIMIT 1
|
|
]]
|
|
|
|
local result = MySQL.query.await(query, {citizenid, licenseType})
|
|
return result and result[1] or nil
|
|
end, "Lizenz abrufen")
|
|
|
|
if license then
|
|
-- Custom-Data und Classes parsen
|
|
if license.custom_data then
|
|
license.custom_data_parsed = json.decode(license.custom_data)
|
|
end
|
|
|
|
if license.classes then
|
|
license.classes_parsed = json.decode(license.classes)
|
|
end
|
|
|
|
-- Cache speichern
|
|
licenseCache[cacheKey] = license
|
|
debugPrint("Lizenz in Cache gespeichert: " .. licenseType)
|
|
end
|
|
|
|
return license
|
|
end
|
|
|
|
debugPrint("License-System Server erweitert geladen (Custom License Support)")
|
|
|
|
|
|
|