forked from Simnation/Main
1450 lines
47 KiB
Lua
1450 lines
47 KiB
Lua
local QBCore = exports['qb-core']:GetCoreObject()
|
|
|
|
-- Lokale Variablen
|
|
local isMenuOpen = false
|
|
local currentTarget = nil
|
|
local nearbyPlayers = {}
|
|
local isLicenseShowing = false
|
|
local pendingRequests = {}
|
|
local currentLicenseData = nil
|
|
local currentTargetId = nil
|
|
|
|
-- Hilfsfunktionen
|
|
local function debugPrint(message)
|
|
if Config.Debug then
|
|
print("^3[License-System Client] " .. message .. "^7")
|
|
end
|
|
end
|
|
|
|
local function showNotification(message, type)
|
|
QBCore.Functions.Notify(message, type or 'primary')
|
|
end
|
|
|
|
-- Nearby Players abrufen
|
|
local function getNearbyPlayers(radius)
|
|
radius = radius or 5.0
|
|
local players = {}
|
|
local playerPed = PlayerPedId()
|
|
local playerCoords = GetEntityCoords(playerPed)
|
|
|
|
for _, playerId in ipairs(GetActivePlayers()) do
|
|
local targetPed = GetPlayerPed(playerId)
|
|
if targetPed ~= playerPed then
|
|
local targetCoords = GetEntityCoords(targetPed)
|
|
local distance = #(playerCoords - targetCoords)
|
|
|
|
if distance <= radius then
|
|
local serverId = GetPlayerServerId(playerId)
|
|
local playerName = GetPlayerName(playerId)
|
|
|
|
table.insert(players, {
|
|
id = serverId,
|
|
name = playerName,
|
|
distance = math.floor(distance * 100) / 100,
|
|
ped = targetPed
|
|
})
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Nach Entfernung sortieren
|
|
table.sort(players, function(a, b)
|
|
return a.distance < b.distance
|
|
end)
|
|
|
|
debugPrint("Gefundene Spieler in der Nähe: " .. #players)
|
|
return players
|
|
end
|
|
|
|
-- Berechtigung prüfen
|
|
local function hasPermission()
|
|
local PlayerData = QBCore.Functions.GetPlayerData()
|
|
if not PlayerData or not PlayerData.job then return false end
|
|
|
|
local hasAuth = Config.AuthorizedJobs[PlayerData.job.name] or false
|
|
debugPrint("Berechtigung für Job " .. PlayerData.job.name .. ": " .. tostring(hasAuth))
|
|
return hasAuth
|
|
end
|
|
|
|
-- Lizenz anzeigen
|
|
local function showLicense(licenseData)
|
|
if not licenseData then
|
|
showNotification(Config.Notifications.license_not_found.message, Config.Notifications.license_not_found.type)
|
|
return
|
|
end
|
|
|
|
debugPrint("Zeige Lizenz: " .. licenseData.license.license_type)
|
|
|
|
SendNUIMessage({
|
|
action = 'showLicense',
|
|
data = licenseData
|
|
})
|
|
|
|
SetNuiFocus(true, true)
|
|
isLicenseShowing = true
|
|
end
|
|
|
|
-- Lizenz schließen
|
|
local function closeLicense()
|
|
SendNUIMessage({
|
|
action = 'hideLicense'
|
|
})
|
|
|
|
SetNuiFocus(false, false)
|
|
isLicenseShowing = false
|
|
debugPrint("Lizenz geschlossen")
|
|
end
|
|
|
|
-- Spieler-Lizenz anzeigen
|
|
local function showPlayerLicense(targetId)
|
|
debugPrint("=== showPlayerLicense START ===")
|
|
debugPrint("Sende Event: requestLicense für Spieler: " .. tostring(targetId))
|
|
|
|
TriggerServerEvent('license-system:server:requestLicense', targetId)
|
|
end
|
|
|
|
-- Eigene Lizenz anzeigen
|
|
local function showMyLicense(licenseType)
|
|
debugPrint("=== showMyLicense START ===")
|
|
debugPrint("Sende Event: requestMyLicense für Typ: " .. tostring(licenseType))
|
|
|
|
TriggerServerEvent('license-system:server:requestMyLicense', licenseType)
|
|
end
|
|
|
|
-- FORWARD DECLARATIONS (Funktionen die später definiert werden)
|
|
local confirmIssueLicense
|
|
local openIssueLicenseMenu
|
|
local openDriversLicenseClassMenu
|
|
local openRevokeLicenseMenu
|
|
local openPlayerLicenseMenu
|
|
local openLicenseMenu
|
|
local openManualLicenseEntry
|
|
local openReactivateLicenseMenu
|
|
|
|
-- Helper function to get license type options
|
|
local function getLicenseTypeOptions()
|
|
local options = {}
|
|
for licenseType, config in pairs(Config.LicenseTypes) do
|
|
table.insert(options, {
|
|
value = licenseType,
|
|
label = config.label
|
|
})
|
|
end
|
|
return options
|
|
end
|
|
|
|
-- Lizenz-Ausstellung bestätigen (FRÜH DEFINIERT)
|
|
confirmIssueLicense = function(targetId, targetName, licenseType, classes)
|
|
local config = Config.LicenseTypes[licenseType]
|
|
if not config then
|
|
showNotification('Unbekannter Lizenztyp!', 'error')
|
|
return
|
|
end
|
|
|
|
local classText = classes and table.concat(classes, ', ') or 'Keine'
|
|
local priceText = config.price and (config.price .. ' $') or 'Kostenlos'
|
|
|
|
debugPrint("Bestätige Lizenz-Ausstellung: " .. licenseType .. " für " .. targetName)
|
|
|
|
lib.registerContext({
|
|
id = 'confirm_issue_license',
|
|
title = 'Lizenz ausstellen bestätigen',
|
|
options = {
|
|
{
|
|
title = 'Spieler: ' .. targetName,
|
|
disabled = true,
|
|
icon = 'fas fa-user'
|
|
},
|
|
{
|
|
title = 'Lizenztyp: ' .. config.label,
|
|
disabled = true,
|
|
icon = config.icon
|
|
},
|
|
{
|
|
title = 'Klassen: ' .. classText,
|
|
disabled = true,
|
|
icon = 'fas fa-list'
|
|
},
|
|
{
|
|
title = 'Kosten: ' .. priceText,
|
|
disabled = true,
|
|
icon = 'fas fa-dollar-sign'
|
|
},
|
|
{
|
|
title = '─────────────────',
|
|
disabled = true
|
|
},
|
|
{
|
|
title = '✅ Bestätigen',
|
|
description = 'Lizenz jetzt ausstellen',
|
|
icon = 'fas fa-check',
|
|
onSelect = function()
|
|
debugPrint("Sende Lizenz-Ausstellung an Server...")
|
|
TriggerServerEvent('license-system:server:issueLicense', targetId, licenseType, classes)
|
|
lib.hideContext()
|
|
end
|
|
},
|
|
{
|
|
title = '❌ Abbrechen',
|
|
description = 'Vorgang abbrechen',
|
|
icon = 'fas fa-times',
|
|
onSelect = function()
|
|
openIssueLicenseMenu(targetId, targetName)
|
|
end
|
|
}
|
|
}
|
|
})
|
|
|
|
lib.showContext('confirm_issue_license')
|
|
end
|
|
|
|
-- Führerschein-Klassen Menü
|
|
openDriversLicenseClassMenu = function(targetId, targetName, licenseType)
|
|
local config = Config.LicenseTypes[licenseType]
|
|
if not config then
|
|
showNotification('Lizenz-Konfiguration nicht gefunden!', 'error')
|
|
return
|
|
end
|
|
|
|
local selectedClasses = {}
|
|
|
|
local function updateMenu()
|
|
local menuOptions = {}
|
|
|
|
if config.classes then
|
|
for _, class in ipairs(config.classes) do
|
|
local isSelected = false
|
|
for _, selected in ipairs(selectedClasses) do
|
|
if selected == class then
|
|
isSelected = true
|
|
break
|
|
end
|
|
end
|
|
|
|
local classDescriptions = {
|
|
['A'] = 'Motorräder',
|
|
['A1'] = 'Leichte Motorräder (bis 125ccm)',
|
|
['A2'] = 'Mittlere Motorräder (bis 35kW)',
|
|
['B'] = 'PKW (bis 3,5t)',
|
|
['BE'] = 'PKW mit Anhänger',
|
|
['C'] = 'LKW (über 3,5t)',
|
|
['CE'] = 'LKW mit Anhänger',
|
|
['D'] = 'Bus (über 8 Personen)',
|
|
['DE'] = 'Bus mit Anhänger'
|
|
}
|
|
|
|
table.insert(menuOptions, {
|
|
title = 'Klasse ' .. class .. (isSelected and ' ✅' or ''),
|
|
description = classDescriptions[class] or 'Keine Beschreibung',
|
|
icon = isSelected and 'fas fa-check-square' or 'far fa-square',
|
|
onSelect = function()
|
|
if isSelected then
|
|
-- Klasse entfernen
|
|
for i, selected in ipairs(selectedClasses) do
|
|
if selected == class then
|
|
table.remove(selectedClasses, i)
|
|
break
|
|
end
|
|
end
|
|
else
|
|
-- Klasse hinzufügen
|
|
table.insert(selectedClasses, class)
|
|
end
|
|
updateMenu()
|
|
end
|
|
})
|
|
end
|
|
end
|
|
|
|
table.insert(menuOptions, {
|
|
title = '─────────────────',
|
|
disabled = true
|
|
})
|
|
|
|
table.insert(menuOptions, {
|
|
title = 'Bestätigen (' .. #selectedClasses .. ' Klassen)',
|
|
description = 'Führerschein mit ausgewählten Klassen ausstellen',
|
|
icon = 'fas fa-check',
|
|
disabled = #selectedClasses == 0,
|
|
onSelect = function()
|
|
confirmIssueLicense(targetId, targetName, licenseType, selectedClasses)
|
|
end
|
|
})
|
|
|
|
table.insert(menuOptions, {
|
|
title = '← Zurück',
|
|
icon = 'fas fa-arrow-left',
|
|
onSelect = function()
|
|
openIssueLicenseMenu(targetId, targetName)
|
|
end
|
|
})
|
|
|
|
lib.registerContext({
|
|
id = 'drivers_license_classes',
|
|
title = 'Führerschein-Klassen: ' .. targetName,
|
|
options = menuOptions
|
|
})
|
|
|
|
lib.showContext('drivers_license_classes')
|
|
end
|
|
|
|
updateMenu()
|
|
end
|
|
|
|
-- Lizenz ausstellen Menü
|
|
openIssueLicenseMenu = function(targetId, targetName)
|
|
debugPrint("Öffne Lizenz-Ausstellungs-Menü für: " .. targetName)
|
|
|
|
local menuOptions = {}
|
|
|
|
for licenseType, config in pairs(Config.LicenseTypes) do
|
|
local priceText = config.price and (config.price .. ' $') or 'Kostenlos'
|
|
local validityText = config.validity_days and (config.validity_days .. ' Tage') or 'Unbegrenzt'
|
|
|
|
table.insert(menuOptions, {
|
|
title = config.label,
|
|
description = config.description or 'Keine Beschreibung verfügbar',
|
|
icon = config.icon,
|
|
onSelect = function()
|
|
if licenseType == 'drivers_license' and config.classes then
|
|
openDriversLicenseClassMenu(targetId, targetName, licenseType)
|
|
else
|
|
confirmIssueLicense(targetId, targetName, licenseType, nil)
|
|
end
|
|
end,
|
|
metadata = {
|
|
{label = 'Preis', value = priceText},
|
|
{label = 'Gültigkeitsdauer', value = validityText}
|
|
}
|
|
})
|
|
end
|
|
|
|
table.insert(menuOptions, {
|
|
title = '← Zurück',
|
|
icon = 'fas fa-arrow-left',
|
|
onSelect = function()
|
|
openPlayerLicenseMenu(targetId, targetName)
|
|
end
|
|
})
|
|
|
|
lib.registerContext({
|
|
id = 'issue_license',
|
|
title = 'Lizenz ausstellen: ' .. targetName,
|
|
options = menuOptions
|
|
})
|
|
|
|
lib.showContext('issue_license')
|
|
end
|
|
|
|
-- Lizenz entziehen Menü
|
|
openRevokeLicenseMenu = function(targetId, targetName, licenses)
|
|
debugPrint("Öffne Lizenz-Entziehungs-Menü für: " .. targetName)
|
|
|
|
local menuOptions = {}
|
|
|
|
for _, license in ipairs(licenses) do
|
|
if license.is_active == 1 then
|
|
local config = Config.LicenseTypes[license.license_type] or {
|
|
label = license.license_type,
|
|
icon = 'fas fa-id-card'
|
|
}
|
|
|
|
table.insert(menuOptions, {
|
|
title = config.label,
|
|
description = 'Diese Lizenz entziehen',
|
|
icon = config.icon,
|
|
onSelect = function()
|
|
lib.registerContext({
|
|
id = 'confirm_revoke_license',
|
|
title = 'Lizenz entziehen bestätigen',
|
|
options = {
|
|
{
|
|
title = 'Spieler: ' .. targetName,
|
|
disabled = true,
|
|
icon = 'fas fa-user'
|
|
},
|
|
{
|
|
title = 'Lizenztyp: ' .. config.label,
|
|
disabled = true,
|
|
icon = config.icon
|
|
},
|
|
{
|
|
title = '─────────────────',
|
|
disabled = true
|
|
},
|
|
{
|
|
title = '✅ Bestätigen',
|
|
description = 'Lizenz jetzt entziehen',
|
|
icon = 'fas fa-check',
|
|
onSelect = function()
|
|
debugPrint("Sende Lizenz-Entziehung an Server...")
|
|
TriggerServerEvent('license-system:server:revokeLicense', targetId, license.license_type)
|
|
lib.hideContext()
|
|
end
|
|
},
|
|
{
|
|
title = '❌ Abbrechen',
|
|
description = 'Vorgang abbrechen',
|
|
icon = 'fas fa-times',
|
|
onSelect = function()
|
|
openRevokeLicenseMenu(targetId, targetName, licenses)
|
|
end
|
|
}
|
|
}
|
|
})
|
|
|
|
lib.showContext('confirm_revoke_license')
|
|
end
|
|
})
|
|
end
|
|
end
|
|
|
|
if #menuOptions == 0 then
|
|
table.insert(menuOptions, {
|
|
title = 'Keine aktiven Lizenzen',
|
|
description = 'Dieser Spieler hat keine aktiven Lizenzen',
|
|
icon = 'fas fa-exclamation-triangle',
|
|
disabled = true
|
|
})
|
|
end
|
|
|
|
table.insert(menuOptions, {
|
|
title = '← Zurück',
|
|
icon = 'fas fa-arrow-left',
|
|
onSelect = function()
|
|
openPlayerLicenseMenu(targetId, targetName)
|
|
end
|
|
})
|
|
|
|
lib.registerContext({
|
|
id = 'revoke_license',
|
|
title = 'Lizenz entziehen: ' .. targetName,
|
|
options = menuOptions
|
|
})
|
|
|
|
lib.showContext('revoke_license')
|
|
end
|
|
|
|
-- Manual License Entry Menu
|
|
openManualLicenseEntry = function(targetId, targetName)
|
|
debugPrint("Öffne manuelle Lizenz-Eingabe für: " .. targetName)
|
|
|
|
local input = lib.inputDialog('Lizenz manuell ausstellen', {
|
|
{type = 'select', label = 'Lizenztyp', options = getLicenseTypeOptions()},
|
|
{type = 'input', label = 'Name', default = targetName},
|
|
{type = 'input', label = 'Geburtsdatum', description = 'Format: DD.MM.YYYY'},
|
|
{type = 'select', label = 'Geschlecht', options = {
|
|
{value = 'male', label = 'Männlich'},
|
|
{value = 'female', label = 'Weiblich'},
|
|
{value = 'other', label = 'Divers'}
|
|
}},
|
|
{type = 'date', label = 'Ausstellungsdatum', default = os.date("%Y-%m-%d")},
|
|
{type = 'date', label = 'Ablaufdatum', default = os.date("%Y-%m-%d", os.time() + 365*24*60*60)},
|
|
{type = 'checkbox', label = 'Foto aufnehmen?'}
|
|
})
|
|
|
|
if not input then return end
|
|
|
|
local licenseType = input[1]
|
|
local licenseData = {
|
|
name = input[2],
|
|
birthday = input[3],
|
|
gender = input[4],
|
|
issue_date = os.date("%d.%m.%Y", os.time(os.date("!*t", input[5] / 1000))),
|
|
expire_date = os.date("%d.%m.%Y", os.time(os.date("!*t", input[6] / 1000))),
|
|
license_type = licenseType
|
|
}
|
|
|
|
if input[7] then -- Take photo
|
|
TriggerEvent('license-system:client:openCamera', targetId, licenseData)
|
|
else
|
|
TriggerServerEvent('license-system:server:issueManualLicense', targetId, licenseData)
|
|
end
|
|
end
|
|
|
|
-- License Reactivation Menu
|
|
openReactivateLicenseMenu = function(targetId, targetName)
|
|
debugPrint("Öffne Lizenz-Reaktivierungs-Menü für: " .. targetName)
|
|
|
|
-- Request all licenses including inactive ones
|
|
TriggerServerEvent('license-system:server:requestAllPlayerLicenses', targetId, true)
|
|
end
|
|
|
|
-- Spieler-Lizenz-Menü
|
|
openPlayerLicenseMenu = function(targetId, targetName)
|
|
debugPrint("=== openPlayerLicenseMenu START ===")
|
|
debugPrint("Sende Event: requestPlayerLicenses für: " .. targetName .. " (ID: " .. targetId .. ")")
|
|
|
|
TriggerServerEvent('license-system:server:requestPlayerLicenses', targetId)
|
|
end
|
|
|
|
-- Hauptmenü für Lizenz-System
|
|
openLicenseMenu = function()
|
|
debugPrint("Öffne Hauptmenü für Lizenz-System")
|
|
|
|
if not hasPermission() then
|
|
showNotification(Config.Notifications.no_permission.message, Config.Notifications.no_permission.type)
|
|
return
|
|
end
|
|
|
|
nearbyPlayers = getNearbyPlayers(5.0)
|
|
|
|
if #nearbyPlayers == 0 then
|
|
showNotification(Config.Notifications.no_players_nearby.message, Config.Notifications.no_players_nearby.type)
|
|
return
|
|
end
|
|
|
|
local menuOptions = {}
|
|
|
|
for _, player in ipairs(nearbyPlayers) do
|
|
table.insert(menuOptions, {
|
|
title = player.name,
|
|
description = 'Entfernung: ' .. player.distance .. 'm',
|
|
icon = 'fas fa-user',
|
|
onSelect = function()
|
|
openPlayerLicenseMenu(player.id, player.name)
|
|
end
|
|
})
|
|
end
|
|
|
|
lib.registerContext({
|
|
id = 'license_nearby_players',
|
|
title = 'Spieler in der Nähe (' .. #nearbyPlayers .. ')',
|
|
options = menuOptions
|
|
})
|
|
|
|
lib.showContext('license_nearby_players')
|
|
end
|
|
|
|
-- Eigene Lizenzen anzeigen
|
|
local function showMyLicenses()
|
|
debugPrint("Öffne Menü für eigene Lizenzen")
|
|
|
|
local menuOptions = {}
|
|
|
|
for licenseType, config in pairs(Config.LicenseTypes) do
|
|
table.insert(menuOptions, {
|
|
title = config.label,
|
|
description = 'Deine ' .. config.label .. ' anzeigen',
|
|
icon = config.icon,
|
|
onSelect = function()
|
|
showMyLicense(licenseType)
|
|
end
|
|
})
|
|
end
|
|
|
|
lib.registerContext({
|
|
id = 'my_licenses',
|
|
title = 'Meine Lizenzen',
|
|
options = menuOptions
|
|
})
|
|
|
|
lib.showContext('my_licenses')
|
|
end
|
|
|
|
-- EVENT HANDLER: Einzelne Lizenz erhalten
|
|
RegisterNetEvent('license-system:client:receiveLicense', function(licenseData)
|
|
debugPrint("=== Event: receiveLicense ===")
|
|
debugPrint("LicenseData-Typ: " .. type(licenseData))
|
|
|
|
if licenseData then
|
|
debugPrint("Lizenz-Daten erhalten: " .. licenseData.license.license_type)
|
|
showLicense(licenseData)
|
|
else
|
|
debugPrint("Keine Lizenz-Daten erhalten")
|
|
showNotification(Config.Notifications.license_not_found.message, Config.Notifications.license_not_found.type)
|
|
end
|
|
end)
|
|
|
|
-- EVENT HANDLER: Eigene Lizenz erhalten
|
|
RegisterNetEvent('license-system:client:receiveMyLicense', function(licenseData, licenseType)
|
|
debugPrint("=== Event: receiveMyLicense ===")
|
|
debugPrint("LicenseType: " .. tostring(licenseType))
|
|
debugPrint("LicenseData-Typ: " .. type(licenseData))
|
|
|
|
if licenseData then
|
|
debugPrint("Eigene Lizenz-Daten erhalten: " .. licenseData.license.license_type)
|
|
showLicense(licenseData)
|
|
else
|
|
debugPrint("Keine eigene Lizenz gefunden")
|
|
local config = Config.LicenseTypes[licenseType]
|
|
local licenseName = config and config.label or licenseType
|
|
showNotification('Du hast keine ' .. licenseName .. '!', 'error')
|
|
end
|
|
end)
|
|
|
|
-- EVENT HANDLER: Alle Spieler-Lizenzen erhalten
|
|
RegisterNetEvent('license-system:client:receivePlayerLicenses', function(licenses, targetId, targetName)
|
|
debugPrint("=== Event: receivePlayerLicenses ===")
|
|
debugPrint("Erhaltene Lizenzen: " .. #licenses)
|
|
debugPrint("TargetName: " .. tostring(targetName))
|
|
|
|
local menuOptions = {}
|
|
|
|
if licenses and #licenses > 0 then
|
|
for _, license in ipairs(licenses) do
|
|
local licenseConfig = Config.LicenseTypes[license.license_type] or {
|
|
label = license.license_type,
|
|
icon = 'fas fa-id-card',
|
|
color = '#667eea'
|
|
}
|
|
|
|
local statusIcon = (license.is_active == 1) and '✅' or '❌'
|
|
local statusText = (license.is_active == 1) and 'Gültig' or 'Ungültig'
|
|
local expireText = license.expire_date or 'Unbegrenzt'
|
|
|
|
table.insert(menuOptions, {
|
|
title = licenseConfig.label .. ' ' .. statusIcon,
|
|
description = 'Status: ' .. statusText .. ' | Gültig bis: ' .. expireText,
|
|
icon = licenseConfig.icon,
|
|
onSelect = function()
|
|
local licenseData = {
|
|
license = license,
|
|
config = licenseConfig
|
|
}
|
|
showLicense(licenseData)
|
|
end,
|
|
metadata = {
|
|
{label = 'Status', value = statusText},
|
|
{label = 'Ausgestellt', value = license.issue_date or 'Unbekannt'},
|
|
{label = 'Gültig bis', value = expireText},
|
|
{label = 'Aussteller', value = license.issued_by_name or 'System'}
|
|
}
|
|
})
|
|
end
|
|
else
|
|
table.insert(menuOptions, {
|
|
title = 'Keine Lizenzen gefunden',
|
|
description = 'Dieser Spieler hat keine Lizenzen',
|
|
icon = 'fas fa-exclamation-triangle',
|
|
disabled = true
|
|
})
|
|
end
|
|
|
|
-- Aktionen hinzufügen
|
|
table.insert(menuOptions, {
|
|
title = '─────────────────',
|
|
disabled = true
|
|
})
|
|
|
|
table.insert(menuOptions, {
|
|
title = 'Neue Lizenz ausstellen',
|
|
description = 'Eine neue Lizenz für diesen Spieler ausstellen',
|
|
icon = 'fas fa-plus',
|
|
onSelect = function()
|
|
openIssueLicenseMenu(targetId, targetName)
|
|
end
|
|
})
|
|
|
|
table.insert(menuOptions, {
|
|
title = 'Lizenz manuell ausstellen',
|
|
description = 'Lizenz mit benutzerdefinierten Daten ausstellen',
|
|
icon = 'fas fa-edit',
|
|
onSelect = function()
|
|
openManualLicenseEntry(targetId, targetName)
|
|
end
|
|
})
|
|
|
|
if licenses and #licenses > 0 then
|
|
table.insert(menuOptions, {
|
|
title = 'Lizenz entziehen',
|
|
description = 'Eine bestehende Lizenz entziehen',
|
|
icon = 'fas fa-minus',
|
|
onSelect = function()
|
|
openRevokeLicenseMenu(targetId, targetName, licenses)
|
|
end
|
|
})
|
|
end
|
|
|
|
table.insert(menuOptions, {
|
|
title = 'Lizenz reaktivieren',
|
|
description = 'Eine inaktive Lizenz wieder aktivieren',
|
|
icon = 'fas fa-redo',
|
|
onSelect = function()
|
|
openReactivateLicenseMenu(targetId, targetName)
|
|
end
|
|
})
|
|
|
|
table.insert(menuOptions, {
|
|
title = '← Zurück',
|
|
icon = 'fas fa-arrow-left',
|
|
onSelect = function()
|
|
openLicenseMenu()
|
|
end
|
|
})
|
|
|
|
lib.registerContext({
|
|
id = 'player_licenses',
|
|
title = 'Lizenzen: ' .. targetName,
|
|
options = menuOptions
|
|
})
|
|
|
|
lib.showContext('player_licenses')
|
|
end)
|
|
|
|
-- EVENT HANDLER: Alle Spieler-Lizenzen (inkl. inaktive) erhalten
|
|
RegisterNetEvent('license-system:client:receiveAllPlayerLicenses', function(licenses, targetId, targetName)
|
|
debugPrint("=== Event: receiveAllPlayerLicenses ===")
|
|
debugPrint("Erhaltene Lizenzen: " .. #licenses)
|
|
|
|
local menuOptions = {}
|
|
|
|
if licenses and #licenses > 0 then
|
|
for _, license in ipairs(licenses) do
|
|
if license.is_active == 0 then -- Only show inactive licenses
|
|
local licenseConfig = Config.LicenseTypes[license.license_type] or {
|
|
label = license.license_type,
|
|
icon = 'fas fa-id-card',
|
|
color = '#667eea'
|
|
}
|
|
|
|
table.insert(menuOptions, {
|
|
title = licenseConfig.label .. ' ❌',
|
|
description = 'Status: Ungültig | Ausgestellt: ' .. (license.issue_date or 'Unbekannt'),
|
|
icon = licenseConfig.icon,
|
|
onSelect = function()
|
|
-- Confirmation dialog
|
|
lib.registerContext({
|
|
id = 'confirm_reactivate_license',
|
|
title = 'Lizenz reaktivieren bestätigen',
|
|
options = {
|
|
{
|
|
title = 'Spieler: ' .. targetName,
|
|
disabled = true,
|
|
icon = 'fas fa-user'
|
|
},
|
|
{
|
|
title = 'Lizenztyp: ' .. licenseConfig.label,
|
|
disabled = true,
|
|
icon = licenseConfig.icon
|
|
},
|
|
{
|
|
title = '─────────────────',
|
|
disabled = true
|
|
},
|
|
{
|
|
title = '✅ Bestätigen',
|
|
description = 'Lizenz jetzt reaktivieren',
|
|
icon = 'fas fa-check',
|
|
onSelect = function()
|
|
debugPrint("Sende Lizenz-Reaktivierung an Server...")
|
|
TriggerServerEvent('license-system:server:reactivateLicense', targetId, license.license_type)
|
|
lib.hideContext()
|
|
end
|
|
},
|
|
{
|
|
title = '❌ Abbrechen',
|
|
description = 'Vorgang abbrechen',
|
|
icon = 'fas fa-times',
|
|
onSelect = function()
|
|
openReactivateLicenseMenu(targetId, targetName)
|
|
end
|
|
}
|
|
}
|
|
})
|
|
|
|
lib.showContext('confirm_reactivate_license')
|
|
end
|
|
})
|
|
end
|
|
end
|
|
end
|
|
|
|
if #menuOptions == 0 then
|
|
table.insert(menuOptions, {
|
|
title = 'Keine inaktiven Lizenzen',
|
|
description = 'Dieser Spieler hat keine inaktiven Lizenzen',
|
|
icon = 'fas fa-exclamation-triangle',
|
|
disabled = true
|
|
})
|
|
end
|
|
|
|
table.insert(menuOptions, {
|
|
title = '← Zurück',
|
|
icon = 'fas fa-arrow-left',
|
|
onSelect = function()
|
|
openPlayerLicenseMenu(targetId, targetName)
|
|
end
|
|
})
|
|
|
|
lib.registerContext({
|
|
id = 'reactivate_license',
|
|
title = 'Lizenz reaktivieren: ' .. targetName,
|
|
options = menuOptions
|
|
})
|
|
|
|
lib.showContext('reactivate_license')
|
|
end)
|
|
|
|
-- EVENT HANDLER: Berechtigung erhalten
|
|
RegisterNetEvent('license-system:client:receivePermission', function(hasAuth, licenseType)
|
|
debugPrint("=== Event: receivePermission ===")
|
|
debugPrint("Berechtigung für " .. licenseType .. ": " .. tostring(hasAuth))
|
|
|
|
if not hasAuth then
|
|
showNotification(Config.Notifications.no_permission.message, Config.Notifications.no_permission.type)
|
|
end
|
|
end)
|
|
|
|
-- EVENT HANDLER: Lizenz erfolgreich ausgestellt
|
|
RegisterNetEvent('license-system:client:licenseIssued', function(targetId, licenseType)
|
|
debugPrint("=== Event: licenseIssued ===")
|
|
debugPrint("Lizenz " .. licenseType .. " für Spieler " .. targetId .. " ausgestellt")
|
|
|
|
-- Menü aktualisieren
|
|
if lib.getOpenContextMenu() then
|
|
lib.hideContext()
|
|
Wait(100)
|
|
openLicenseMenu()
|
|
end
|
|
end)
|
|
|
|
-- EVENT HANDLER: Lizenz erfolgreich entzogen
|
|
RegisterNetEvent('license-system:client:licenseRevoked', function(targetId, licenseType)
|
|
debugPrint("=== Event: licenseRevoked ===")
|
|
debugPrint("Lizenz " .. licenseType .. " für Spieler " .. targetId .. " entzogen")
|
|
|
|
-- Menü aktualisieren
|
|
if lib.getOpenContextMenu() then
|
|
lib.hideContext()
|
|
Wait(100)
|
|
openLicenseMenu()
|
|
end
|
|
end)
|
|
|
|
-- EVENT HANDLER: Lizenz erfolgreich reaktiviert
|
|
RegisterNetEvent('license-system:client:licenseReactivated', function(targetId, licenseType)
|
|
debugPrint("=== Event: licenseReactivated ===")
|
|
debugPrint("Lizenz " .. licenseType .. " für Spieler " .. targetId .. " reaktiviert")
|
|
|
|
-- Menü aktualisieren
|
|
if lib.getOpenContextMenu() then
|
|
lib.hideContext()
|
|
Wait(100)
|
|
openLicenseMenu()
|
|
end
|
|
end)
|
|
|
|
-- EVENT HANDLER: Lizenz anzeigen (von anderen Spielern)
|
|
RegisterNetEvent('license-system:client:showLicense', function(targetId)
|
|
debugPrint("Event erhalten: showLicense für ID " .. tostring(targetId))
|
|
showPlayerLicense(targetId)
|
|
end)
|
|
|
|
-- EVENT HANDLER: Eigene Lizenz anzeigen
|
|
RegisterNetEvent('license-system:client:showMyLicense', function(licenseType)
|
|
debugPrint("Event erhalten: showMyLicense für Typ " .. tostring(licenseType))
|
|
showMyLicense(licenseType)
|
|
end)
|
|
|
|
-- EVENT HANDLER: Kamera öffnen
|
|
RegisterNetEvent('license-system:client:openCamera', function(targetId, licenseData)
|
|
debugPrint("Event erhalten: openCamera für Spieler " .. tostring(targetId))
|
|
|
|
-- Store the data temporarily
|
|
currentLicenseData = licenseData
|
|
currentTargetId = targetId
|
|
|
|
SendNUIMessage({
|
|
action = 'openCamera',
|
|
citizenid = QBCore.Functions.GetPlayerData().citizenid
|
|
})
|
|
end)
|
|
|
|
-- EVENT HANDLER: Menü aktualisieren
|
|
RegisterNetEvent('license-system:client:refreshMenu', function()
|
|
debugPrint("Event erhalten: refreshMenu")
|
|
if lib.getOpenContextMenu() then
|
|
lib.hideContext()
|
|
Wait(100)
|
|
openLicenseMenu()
|
|
end
|
|
end)
|
|
|
|
-- NUI CALLBACKS
|
|
RegisterNUICallback('closeLicense', function(data, cb)
|
|
debugPrint("NUI Callback: closeLicense")
|
|
closeLicense()
|
|
|
|
if cb and type(cb) == "function" then
|
|
cb('ok')
|
|
end
|
|
end)
|
|
|
|
RegisterNUICallback('savePhoto', function(data, cb)
|
|
debugPrint("NUI Callback: savePhoto")
|
|
|
|
if data.photo and currentLicenseData and currentTargetId then
|
|
-- Add photo to license data
|
|
currentLicenseData.photo_url = data.photo
|
|
|
|
-- Issue the license with the photo
|
|
TriggerServerEvent('license-system:server:issueManualLicense', currentTargetId, currentLicenseData)
|
|
|
|
-- Reset temporary data
|
|
currentLicenseData = nil
|
|
currentTargetId = nil
|
|
|
|
if cb and type(cb) == "function" then
|
|
cb('ok')
|
|
end
|
|
else
|
|
debugPrint("^1Fehler: Foto-Daten unvollständig oder keine aktuelle Lizenz-Ausstellung^7")
|
|
|
|
if cb and type(cb) == "function" then
|
|
cb('error')
|
|
end
|
|
end
|
|
end)
|
|
|
|
RegisterNUICallback('takePicture', function(data, cb)
|
|
debugPrint("NUI Callback: takePicture")
|
|
|
|
-- Hier könnte eine Kamera-Funktion implementiert werden
|
|
if cb and type(cb) == "function" then
|
|
cb('ok')
|
|
end
|
|
end)
|
|
|
|
-- COMMANDS
|
|
RegisterCommand(Config.Commands.license.name, function()
|
|
debugPrint("Command ausgeführt: " .. Config.Commands.license.name)
|
|
openLicenseMenu()
|
|
end, Config.Commands.license.restricted)
|
|
|
|
RegisterCommand(Config.Commands.mylicense.name, function()
|
|
debugPrint("Command ausgeführt: " .. Config.Commands.mylicense.name)
|
|
showMyLicenses()
|
|
end, Config.Commands.mylicense.restricted)
|
|
|
|
-- Zusätzliche Commands für schnellen Zugriff
|
|
RegisterCommand('ausweis', function()
|
|
debugPrint("Command ausgeführt: ausweis")
|
|
showMyLicense('id_card')
|
|
end, false)
|
|
|
|
RegisterCommand('führerschein', function()
|
|
debugPrint("Command ausgeführt: führerschein")
|
|
showMyLicense('drivers_license')
|
|
end, false)
|
|
|
|
RegisterCommand('waffenschein', function()
|
|
debugPrint("Command ausgeführt: waffenschein")
|
|
showMyLicense('weapon_license')
|
|
end, false)
|
|
|
|
RegisterCommand('pass', function()
|
|
debugPrint("Command ausgeführt: pass")
|
|
showMyLicense('passport')
|
|
end, false)
|
|
|
|
-- KEYBINDS
|
|
if Config.Keybinds and Config.Keybinds.open_license_menu then
|
|
RegisterKeyMapping(Config.Commands.license.name, Config.Keybinds.open_license_menu.description, 'keyboard', Config.Keybinds.open_license_menu.key)
|
|
end
|
|
|
|
if Config.Keybinds and Config.Keybinds.show_my_licenses then
|
|
RegisterKeyMapping(Config.Commands.mylicense.name, Config.Keybinds.show_my_licenses.description, 'keyboard', Config.Keybinds.show_my_licenses.key)
|
|
end
|
|
|
|
-- ESC-Taste zum Schließen der Lizenz
|
|
CreateThread(function()
|
|
while true do
|
|
Wait(0)
|
|
|
|
if isLicenseShowing then
|
|
if IsControlJustPressed(0, 322) then -- ESC-Taste
|
|
closeLicense()
|
|
end
|
|
else
|
|
Wait(500)
|
|
end
|
|
end
|
|
end)
|
|
|
|
-- CLEANUP UND INITIALISIERUNG
|
|
AddEventHandler('onResourceStop', function(resourceName)
|
|
if GetCurrentResourceName() == resourceName then
|
|
if isLicenseShowing then
|
|
closeLicense()
|
|
end
|
|
|
|
if lib.getOpenContextMenu() then
|
|
lib.hideContext()
|
|
end
|
|
|
|
-- Reset temporary data
|
|
currentLicenseData = nil
|
|
currentTargetId = nil
|
|
|
|
debugPrint("License-System Client gestoppt")
|
|
end
|
|
end)
|
|
|
|
AddEventHandler('onResourceStart', function(resourceName)
|
|
if GetCurrentResourceName() == resourceName then
|
|
debugPrint("License-System Client gestartet (Event-basiert)")
|
|
|
|
-- Warten bis QBCore geladen ist
|
|
while not QBCore do
|
|
Wait(100)
|
|
end
|
|
|
|
debugPrint("QBCore erfolgreich geladen")
|
|
end
|
|
end)
|
|
|
|
-- Player laden Event
|
|
RegisterNetEvent('QBCore:Client:OnPlayerLoaded', function()
|
|
debugPrint("Spieler geladen - License-System bereit")
|
|
end)
|
|
|
|
-- Job Update Event
|
|
RegisterNetEvent('QBCore:Client:OnJobUpdate', function(JobInfo)
|
|
debugPrint("Job aktualisiert: " .. JobInfo.name)
|
|
end)
|
|
|
|
-- Initialisierung
|
|
CreateThread(function()
|
|
debugPrint("License-System Client Thread gestartet")
|
|
|
|
-- Warten bis Spieler gespawnt ist
|
|
while not NetworkIsPlayerActive(PlayerId()) do
|
|
Wait(100)
|
|
end
|
|
|
|
debugPrint("Spieler ist aktiv - System bereit")
|
|
end)
|
|
|
|
-- Zusätzliche Utility-Funktionen
|
|
local function requestLicenseWithTimeout(eventName, targetId, timeout)
|
|
timeout = timeout or 5000
|
|
local requestId = math.random(1000, 9999)
|
|
|
|
pendingRequests[requestId] = {
|
|
timestamp = GetGameTimer(),
|
|
timeout = timeout
|
|
}
|
|
|
|
debugPrint("Sende Request mit Timeout: " .. eventName .. " (ID: " .. requestId .. ")")
|
|
TriggerServerEvent(eventName, targetId, requestId)
|
|
|
|
-- Timeout-Handler
|
|
CreateThread(function()
|
|
Wait(timeout)
|
|
if pendingRequests[requestId] then
|
|
pendingRequests[requestId] = nil
|
|
debugPrint("^1Request Timeout: " .. eventName .. " (ID: " .. requestId .. ")^7")
|
|
showNotification('Anfrage-Timeout! Versuche es erneut.', 'error')
|
|
end
|
|
end)
|
|
|
|
return requestId
|
|
end
|
|
|
|
-- Erweiterte Error-Handling
|
|
local function safeExecute(func, errorMessage)
|
|
local success, error = pcall(func)
|
|
if not success then
|
|
debugPrint("^1Fehler: " .. (errorMessage or "Unbekannter Fehler") .. "^7")
|
|
debugPrint("^1Details: " .. tostring(error) .. "^7")
|
|
showNotification('Ein Fehler ist aufgetreten!', 'error')
|
|
end
|
|
return success
|
|
end
|
|
|
|
-- Performance-Monitoring
|
|
local performanceStats = {
|
|
menuOpens = 0,
|
|
licenseShows = 0,
|
|
errors = 0
|
|
}
|
|
|
|
CreateThread(function()
|
|
while true do
|
|
Wait(60000) -- Jede Minute
|
|
|
|
if Config.Debug then
|
|
debugPrint("=== Performance Stats ===")
|
|
debugPrint("Menü-Öffnungen: " .. performanceStats.menuOpens)
|
|
debugPrint("Lizenz-Anzeigen: " .. performanceStats.licenseShows)
|
|
debugPrint("Fehler: " .. performanceStats.errors)
|
|
end
|
|
end
|
|
end)
|
|
|
|
-- Stats aktualisieren
|
|
local originalOpenLicenseMenu = openLicenseMenu
|
|
openLicenseMenu = function()
|
|
performanceStats.menuOpens = performanceStats.menuOpens + 1
|
|
return originalOpenLicenseMenu()
|
|
end
|
|
|
|
local originalShowLicense = showLicense
|
|
showLicense = function(licenseData)
|
|
performanceStats.licenseShows = performanceStats.licenseShows + 1
|
|
return originalShowLicense(licenseData)
|
|
end
|
|
|
|
-- Erweiterte Fehlerbehandlung für Events
|
|
local function safeEventHandler(eventName, handler)
|
|
RegisterNetEvent(eventName, function(...)
|
|
local success, error = pcall(handler, ...)
|
|
if not success then
|
|
debugPrint("^1Fehler in Event " .. eventName .. ": " .. tostring(error) .. "^7")
|
|
performanceStats.errors = performanceStats.errors + 1
|
|
showNotification('Ein Fehler ist aufgetreten!', 'error')
|
|
end
|
|
end)
|
|
end
|
|
|
|
-- Zusätzliche Validierungen
|
|
local function validateLicenseData(licenseData)
|
|
if not licenseData then
|
|
debugPrint("^1Validierung fehlgeschlagen: licenseData ist nil^7")
|
|
return false
|
|
end
|
|
|
|
if not licenseData.license then
|
|
debugPrint("^1Validierung fehlgeschlagen: license-Objekt fehlt^7")
|
|
return false
|
|
end
|
|
|
|
if not licenseData.license.license_type then
|
|
debugPrint("^1Validierung fehlgeschlagen: license_type fehlt^7")
|
|
return false
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
-- Erweiterte showLicense Funktion mit Validierung
|
|
local function showLicenseWithValidation(licenseData)
|
|
if not validateLicenseData(licenseData) then
|
|
showNotification('Ungültige Lizenz-Daten!', 'error')
|
|
return
|
|
end
|
|
|
|
debugPrint("Zeige Lizenz: " .. licenseData.license.license_type)
|
|
|
|
-- Zusätzliche Daten für NUI vorbereiten
|
|
local nuitData = {
|
|
license = licenseData.license,
|
|
config = licenseData.config or Config.LicenseTypes[licenseData.license.license_type],
|
|
timestamp = GetGameTimer(),
|
|
playerData = QBCore.Functions.GetPlayerData()
|
|
}
|
|
|
|
SendNUIMessage({
|
|
action = 'showLicense',
|
|
data = nuitData
|
|
})
|
|
|
|
SetNuiFocus(true, true)
|
|
isLicenseShowing = true
|
|
performanceStats.licenseShows = performanceStats.licenseShows + 1
|
|
end
|
|
|
|
-- Überschreibe die ursprüngliche showLicense Funktion
|
|
showLicense = showLicenseWithValidation
|
|
|
|
-- Erweiterte Menü-Funktionen mit Error-Handling
|
|
local function safeMenuAction(action, errorMessage)
|
|
return function(...)
|
|
local success, error = pcall(action, ...)
|
|
if not success then
|
|
debugPrint("^1Menü-Fehler: " .. (errorMessage or "Unbekannt") .. "^7")
|
|
debugPrint("^1Details: " .. tostring(error) .. "^7")
|
|
performanceStats.errors = performanceStats.errors + 1
|
|
showNotification('Menü-Fehler aufgetreten!', 'error')
|
|
|
|
-- Menü schließen bei Fehler
|
|
if lib.getOpenContextMenu() then
|
|
lib.hideContext()
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Cache für Spieler-Daten
|
|
local playerCache = {}
|
|
local cacheTimeout = 30000 -- 30 Sekunden
|
|
|
|
local function getCachedPlayerData(playerId)
|
|
local now = GetGameTimer()
|
|
local cached = playerCache[playerId]
|
|
|
|
if cached and (now - cached.timestamp) < cacheTimeout then
|
|
debugPrint("Verwende gecachte Spieler-Daten für ID: " .. playerId)
|
|
return cached.data
|
|
end
|
|
|
|
return nil
|
|
end
|
|
|
|
local function setCachedPlayerData(playerId, data)
|
|
playerCache[playerId] = {
|
|
data = data,
|
|
timestamp = GetGameTimer()
|
|
}
|
|
debugPrint("Spieler-Daten gecacht für ID: " .. playerId)
|
|
end
|
|
|
|
-- Cache-Cleanup
|
|
CreateThread(function()
|
|
while true do
|
|
Wait(60000) -- Jede Minute
|
|
|
|
local now = GetGameTimer()
|
|
local cleaned = 0
|
|
|
|
for playerId, cached in pairs(playerCache) do
|
|
if (now - cached.timestamp) > cacheTimeout then
|
|
playerCache[playerId] = nil
|
|
cleaned = cleaned + 1
|
|
end
|
|
end
|
|
|
|
if cleaned > 0 then
|
|
debugPrint("Cache bereinigt: " .. cleaned .. " Einträge entfernt")
|
|
end
|
|
end
|
|
end)
|
|
|
|
-- Erweiterte Nearby-Players Funktion mit Cache
|
|
local function getNearbyPlayersWithCache(radius)
|
|
radius = radius or 5.0
|
|
local players = {}
|
|
local playerPed = PlayerPedId()
|
|
local playerCoords = GetEntityCoords(playerPed)
|
|
|
|
for _, playerId in ipairs(GetActivePlayers()) do
|
|
local targetPed = GetPlayerPed(playerId)
|
|
if targetPed ~= playerPed then
|
|
local targetCoords = GetEntityCoords(targetPed)
|
|
local distance = #(playerCoords - targetCoords)
|
|
|
|
if distance <= radius then
|
|
local serverId = GetPlayerServerId(playerId)
|
|
local playerName = GetPlayerName(playerId)
|
|
|
|
-- Cache-Daten verwenden wenn verfügbar
|
|
local cachedData = getCachedPlayerData(serverId)
|
|
local playerData = cachedData or {
|
|
id = serverId,
|
|
name = playerName,
|
|
ped = targetPed
|
|
}
|
|
|
|
playerData.distance = math.floor(distance * 100) / 100
|
|
|
|
-- Daten cachen wenn nicht bereits gecacht
|
|
if not cachedData then
|
|
setCachedPlayerData(serverId, playerData)
|
|
end
|
|
|
|
table.insert(players, playerData)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Nach Entfernung sortieren
|
|
table.sort(players, function(a, b)
|
|
return a.distance < b.distance
|
|
end)
|
|
|
|
debugPrint("Gefundene Spieler in der Nähe: " .. #players)
|
|
return players
|
|
end
|
|
|
|
-- Überschreibe die ursprüngliche getNearbyPlayers Funktion
|
|
getNearbyPlayers = getNearbyPlayersWithCache
|
|
|
|
-- Erweiterte Notification-Funktion
|
|
local function showNotificationWithSound(message, type, sound)
|
|
QBCore.Functions.Notify(message, type or 'primary')
|
|
|
|
if sound and Config.Sounds and Config.Sounds[sound] then
|
|
PlaySoundFrontend(-1, Config.Sounds[sound].name, Config.Sounds[sound].set, true)
|
|
end
|
|
end
|
|
|
|
-- Erweiterte Event-Handler mit besserer Fehlerbehandlung
|
|
RegisterNetEvent('license-system:client:receiveLicenseWithValidation', function(licenseData)
|
|
debugPrint("=== Event: receiveLicenseWithValidation ===")
|
|
|
|
if not validateLicenseData(licenseData) then
|
|
showNotificationWithSound('Ungültige Lizenz-Daten erhalten!', 'error', 'error')
|
|
return
|
|
end
|
|
|
|
debugPrint("Gültige Lizenz-Daten erhalten: " .. licenseData.license.license_type)
|
|
showLicense(licenseData)
|
|
end)
|
|
|
|
-- Erweiterte Lizenz-Anzeige mit Animationen
|
|
local function showLicenseWithAnimation(licenseData)
|
|
if not validateLicenseData(licenseData) then
|
|
showNotification('Ungültige Lizenz-Daten!', 'error')
|
|
return
|
|
end
|
|
|
|
-- Animation starten
|
|
local playerPed = PlayerPedId()
|
|
|
|
-- Lizenz-Animation (falls gewünscht)
|
|
if Config.Animations and Config.Animations.show_license then
|
|
local anim = Config.Animations.show_license
|
|
RequestAnimDict(anim.dict)
|
|
|
|
while not HasAnimDictLoaded(anim.dict) do
|
|
Wait(10)
|
|
end
|
|
|
|
TaskPlayAnim(playerPed, anim.dict, anim.name, 8.0, -8.0, -1, anim.flag or 49, 0, false, false, false)
|
|
end
|
|
|
|
-- Lizenz anzeigen
|
|
showLicense(licenseData)
|
|
|
|
-- Animation nach kurzer Zeit stoppen
|
|
if Config.Animations and Config.Animations.show_license then
|
|
CreateThread(function()
|
|
Wait(2000)
|
|
ClearPedTasks(playerPed)
|
|
end)
|
|
end
|
|
end
|
|
|
|
-- Erweiterte Menü-Navigation
|
|
local menuHistory = {}
|
|
|
|
local function pushMenuHistory(menuId)
|
|
table.insert(menuHistory, menuId)
|
|
debugPrint("Menü-Historie: " .. menuId .. " hinzugefügt")
|
|
end
|
|
|
|
local function popMenuHistory()
|
|
if #menuHistory > 0 then
|
|
local lastMenu = table.remove(menuHistory)
|
|
debugPrint("Menü-Historie: " .. lastMenu .. " entfernt")
|
|
return lastMenu
|
|
end
|
|
return nil
|
|
end
|
|
|
|
local function clearMenuHistory()
|
|
menuHistory = {}
|
|
debugPrint("Menü-Historie geleert")
|
|
end
|
|
|
|
-- Erweiterte Cleanup-Funktion
|
|
local function cleanup()
|
|
debugPrint("Führe erweiterte Cleanup-Routine aus...")
|
|
|
|
-- NUI schließen
|
|
if isLicenseShowing then
|
|
closeLicense()
|
|
end
|
|
|
|
-- Menüs schließen
|
|
if lib.getOpenContextMenu() then
|
|
lib.hideContext()
|
|
end
|
|
|
|
-- Cache leeren
|
|
playerCache = {}
|
|
|
|
-- Historie leeren
|
|
clearMenuHistory()
|
|
|
|
-- Pending Requests leeren
|
|
pendingRequests = {}
|
|
|
|
-- Temporary data leeren
|
|
currentLicenseData = nil
|
|
currentTargetId = nil
|
|
|
|
-- Animationen stoppen
|
|
local playerPed = PlayerPedId()
|
|
if DoesEntityExist(playerPed) then
|
|
ClearPedTasks(playerPed)
|
|
end
|
|
|
|
debugPrint("Cleanup abgeschlossen")
|
|
end
|
|
|
|
-- Erweiterte Resource-Stop Handler
|
|
AddEventHandler('onResourceStop', function(resourceName)
|
|
if GetCurrentResourceName() == resourceName then
|
|
cleanup()
|
|
debugPrint("License-System Client gestoppt (erweitert)")
|
|
end
|
|
end)
|
|
|
|
-- Erweiterte Resource-Start Handler
|
|
AddEventHandler('onResourceStart', function(resourceName)
|
|
if GetCurrentResourceName() == resourceName then
|
|
debugPrint("License-System Client gestartet (erweitert)")
|
|
|
|
-- Initialisierung
|
|
CreateThread(function()
|
|
-- Warten bis QBCore geladen ist
|
|
while not QBCore do
|
|
Wait(100)
|
|
end
|
|
|
|
debugPrint("QBCore erfolgreich geladen (erweitert)")
|
|
|
|
-- Zusätzliche Initialisierung
|
|
Wait(1000)
|
|
|
|
-- Performance-Stats zurücksetzen
|
|
performanceStats = {
|
|
menuOpens = 0,
|
|
licenseShows = 0,
|
|
errors = 0
|
|
}
|
|
|
|
debugPrint("Erweiterte Initialisierung abgeschlossen")
|
|
end)
|
|
end
|
|
end)
|
|
|
|
-- Erweiterte Debug-Funktionen
|
|
local function debugPlayerInfo()
|
|
if not Config.Debug then return end
|
|
|
|
local PlayerData = QBCore.Functions.GetPlayerData()
|
|
debugPrint("=== PLAYER DEBUG INFO ===")
|
|
debugPrint("Name: " .. (PlayerData.charinfo and PlayerData.charinfo.firstname .. " " .. PlayerData.charinfo.lastname or "Unbekannt"))
|
|
debugPrint("Job: " .. (PlayerData.job and PlayerData.job.name or "Unbekannt"))
|
|
debugPrint("CitizenID: " .. (PlayerData.citizenid or "Unbekannt"))
|
|
debugPrint("Server ID: " .. GetPlayerServerId(PlayerId()))
|
|
debugPrint("========================")
|
|
end
|
|
|
|
-- Debug-Command
|
|
RegisterCommand('licensedebug', function()
|
|
if not Config.Debug then
|
|
showNotification('Debug-Modus ist deaktiviert!', 'error')
|
|
return
|
|
end
|
|
|
|
debugPlayerInfo()
|
|
|
|
debugPrint("=== SYSTEM DEBUG INFO ===")
|
|
debugPrint("Nearby Players: " .. #nearbyPlayers)
|
|
debugPrint("License Showing: " .. tostring(isLicenseShowing))
|
|
debugPrint("Menu Open: " .. tostring(lib.getOpenContextMenu() ~= nil))
|
|
debugPrint("Cached Players: " .. #playerCache)
|
|
debugPrint("Menu History: " .. #menuHistory)
|
|
debugPrint("Pending Requests: " .. #pendingRequests)
|
|
debugPrint("========================")
|
|
|
|
showNotification('Debug-Informationen in der Konsole ausgegeben!', 'success')
|
|
end, false)
|
|
|
|
-- Finaler Debug-Output
|
|
debugPrint("License-System Client vollständig geladen - Alle Funktionen verfügbar")
|
|
|