forked from Simnation/Main
530 lines
20 KiB
Lua
530 lines
20 KiB
Lua
local QBCore = exports['qb-core']:GetCoreObject()
|
|
|
|
-- Hilfsfunktionen
|
|
local function debugPrint(message)
|
|
if Config.Debug then
|
|
print("^2[License-System] " .. message .. "^7")
|
|
end
|
|
end
|
|
|
|
local function safeCallback(cb, ...)
|
|
if cb and type(cb) == "function" then
|
|
cb(...)
|
|
else
|
|
debugPrint("^1Callback ist keine Funktion!^7")
|
|
end
|
|
end
|
|
|
|
local function formatDate(date)
|
|
if not date then return nil end
|
|
return os.date("%d.%m.%Y", date)
|
|
end
|
|
|
|
local function addDaysToDate(days)
|
|
return os.time() + (days * 24 * 60 * 60)
|
|
end
|
|
|
|
local function isLicenseExpired(expireDate)
|
|
if not expireDate then return false end
|
|
return os.time() > expireDate
|
|
end
|
|
|
|
local function getDaysUntilExpiry(expireDate)
|
|
if not expireDate then return nil end
|
|
local diff = expireDate - os.time()
|
|
return math.ceil(diff / (24 * 60 * 60))
|
|
end
|
|
|
|
-- Spieler-Daten abrufen
|
|
local function getPlayerData(source)
|
|
local Player = QBCore.Functions.GetPlayer(source)
|
|
if not Player then return nil end
|
|
|
|
return {
|
|
citizenid = Player.PlayerData.citizenid,
|
|
name = Player.PlayerData.charinfo.firstname .. ' ' .. Player.PlayerData.charinfo.lastname,
|
|
birthday = Player.PlayerData.charinfo.birthdate,
|
|
gender = Player.PlayerData.charinfo.gender,
|
|
job = Player.PlayerData.job.name,
|
|
money = Player.PlayerData.money.cash
|
|
}
|
|
end
|
|
|
|
-- Berechtigung prüfen
|
|
local function hasPermission(source, licenseType)
|
|
local playerData = getPlayerData(source)
|
|
if not playerData then return false end
|
|
|
|
-- Admin-Check
|
|
if QBCore.Functions.HasPermission(source, 'admin') then
|
|
return true
|
|
end
|
|
|
|
-- Job-Check
|
|
if Config.AuthorizedJobs[playerData.job] then
|
|
return true
|
|
end
|
|
|
|
-- Spezifische Lizenz-Berechtigung
|
|
local licenseConfig = Config.LicenseTypes[licenseType]
|
|
if licenseConfig and licenseConfig.required_job then
|
|
return playerData.job == licenseConfig.required_job
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
-- Benötigte Items prüfen
|
|
local function hasRequiredItems(source, licenseType)
|
|
local Player = QBCore.Functions.GetPlayer(source)
|
|
if not Player then return false end
|
|
|
|
local licenseConfig = Config.LicenseTypes[licenseType]
|
|
if not licenseConfig or not licenseConfig.required_items then return true end
|
|
|
|
for _, item in ipairs(licenseConfig.required_items) do
|
|
local hasItem = Player.Functions.GetItemByName(item)
|
|
if not hasItem or hasItem.amount < 1 then
|
|
return false
|
|
end
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
-- Lizenz erstellen
|
|
local function createLicense(citizenid, licenseType, issuedBy, classes)
|
|
local licenseConfig = Config.LicenseTypes[licenseType]
|
|
if not licenseConfig then return false end
|
|
|
|
local issueDate = os.time()
|
|
local expireDate = nil
|
|
|
|
if licenseConfig.can_expire and licenseConfig.validity_days then
|
|
expireDate = addDaysToDate(licenseConfig.validity_days)
|
|
end
|
|
|
|
local licenseData = {
|
|
citizenid = citizenid,
|
|
license_type = licenseType,
|
|
issue_date = formatDate(issueDate),
|
|
expire_date = expireDate and formatDate(expireDate) or nil,
|
|
issued_by = issuedBy,
|
|
is_active = true,
|
|
classes = classes and json.encode(classes) or '[]',
|
|
created_at = issueDate
|
|
}
|
|
|
|
MySQL.Async.insert('INSERT INTO player_licenses (citizenid, license_type, issue_date, expire_date, issued_by, is_active, classes, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)', {
|
|
licenseData.citizenid,
|
|
licenseData.license_type,
|
|
licenseData.issue_date,
|
|
licenseData.expire_date,
|
|
licenseData.issued_by,
|
|
licenseData.is_active,
|
|
licenseData.classes,
|
|
licenseData.created_at
|
|
}, function(insertId)
|
|
if insertId then
|
|
debugPrint("Lizenz erstellt: " .. licenseType .. " für " .. citizenid)
|
|
return true
|
|
else
|
|
debugPrint("^1Fehler beim Erstellen der Lizenz!^7")
|
|
return false
|
|
end
|
|
end)
|
|
|
|
return true
|
|
end
|
|
|
|
-- Callbacks
|
|
QBCore.Functions.CreateCallback('license-system:server:getLicense', function(source, cb, targetId)
|
|
debugPrint("getLicense aufgerufen für Spieler: " .. tostring(targetId))
|
|
|
|
local TargetPlayer = QBCore.Functions.GetPlayer(targetId)
|
|
if not TargetPlayer then
|
|
debugPrint("^1Ziel-Spieler nicht gefunden!^7")
|
|
safeCallback(cb, nil)
|
|
return
|
|
end
|
|
|
|
local citizenid = TargetPlayer.PlayerData.citizenid
|
|
|
|
MySQL.Async.fetchAll('SELECT * FROM player_licenses WHERE citizenid = ? AND is_active = TRUE ORDER BY created_at DESC LIMIT 1', {
|
|
citizenid
|
|
}, function(result)
|
|
if result and result[1] then
|
|
local license = result[1]
|
|
|
|
-- Spieler-Daten hinzufügen
|
|
license.name = TargetPlayer.PlayerData.charinfo.firstname .. ' ' .. TargetPlayer.PlayerData.charinfo.lastname
|
|
license.birthday = TargetPlayer.PlayerData.charinfo.birthdate
|
|
license.gender = TargetPlayer.PlayerData.charinfo.gender
|
|
|
|
-- Aussteller-Name abrufen
|
|
if license.issued_by then
|
|
MySQL.Async.fetchScalar('SELECT CONCAT(JSON_UNQUOTE(JSON_EXTRACT(charinfo, "$.firstname")), " ", JSON_UNQUOTE(JSON_EXTRACT(charinfo, "$.lastname"))) FROM players WHERE citizenid = ?', {
|
|
license.issued_by
|
|
}, function(issuerName)
|
|
license.issued_by_name = issuerName or 'Unbekannt'
|
|
|
|
local licenseData = {
|
|
license = license,
|
|
config = Config.LicenseTypes[license.license_type] or {
|
|
label = license.license_type,
|
|
icon = 'fas fa-id-card'
|
|
}
|
|
}
|
|
|
|
debugPrint("Lizenz gefunden: " .. license.license_type)
|
|
safeCallback(cb, licenseData)
|
|
end)
|
|
else
|
|
license.issued_by_name = 'System'
|
|
|
|
local licenseData = {
|
|
license = license,
|
|
config = Config.LicenseTypes[license.license_type] or {
|
|
label = license.license_type,
|
|
icon = 'fas fa-id-card'
|
|
}
|
|
}
|
|
|
|
debugPrint("Lizenz gefunden: " .. license.license_type)
|
|
safeCallback(cb, licenseData)
|
|
end
|
|
else
|
|
debugPrint("Keine Lizenz gefunden für: " .. citizenid)
|
|
safeCallback(cb, nil)
|
|
end
|
|
end)
|
|
end)
|
|
|
|
QBCore.Functions.CreateCallback('license-system:server:getMyLicense', function(source, cb, licenseType)
|
|
debugPrint("getMyLicense aufgerufen für Typ: " .. tostring(licenseType))
|
|
|
|
local Player = QBCore.Functions.GetPlayer(source)
|
|
if not Player then
|
|
safeCallback(cb, nil)
|
|
return
|
|
end
|
|
|
|
local citizenid = Player.PlayerData.citizenid
|
|
|
|
MySQL.Async.fetchAll('SELECT * FROM player_licenses WHERE citizenid = ? AND license_type = ? AND is_active = TRUE ORDER BY created_at DESC LIMIT 1', {
|
|
citizenid,
|
|
licenseType
|
|
}, function(result)
|
|
if result and result[1] then
|
|
local license = result[1]
|
|
|
|
-- Spieler-Daten hinzufügen
|
|
license.name = Player.PlayerData.charinfo.firstname .. ' ' .. Player.PlayerData.charinfo.lastname
|
|
license.birthday = Player.PlayerData.charinfo.birthdate
|
|
license.gender = Player.PlayerData.charinfo.gender
|
|
|
|
-- Aussteller-Name abrufen
|
|
if license.issued_by then
|
|
MySQL.Async.fetchScalar('SELECT CONCAT(JSON_UNQUOTE(JSON_EXTRACT(charinfo, "$.firstname")), " ", JSON_UNQUOTE(JSON_EXTRACT(charinfo, "$.lastname"))) FROM players WHERE citizenid = ?', {
|
|
license.issued_by
|
|
}, function(issuerName)
|
|
license.issued_by_name = issuerName or 'Unbekannt'
|
|
|
|
local licenseData = {
|
|
license = license,
|
|
config = Config.LicenseTypes[license.license_type] or {
|
|
label = license.license_type,
|
|
icon = 'fas fa-id-card'
|
|
}
|
|
}
|
|
|
|
safeCallback(cb, licenseData)
|
|
end)
|
|
else
|
|
license.issued_by_name = 'System'
|
|
|
|
local licenseData = {
|
|
license = license,
|
|
config = Config.LicenseTypes[license.license_type] or {
|
|
label = license.license_type,
|
|
icon = 'fas fa-id-card'
|
|
}
|
|
}
|
|
|
|
safeCallback(cb, licenseData)
|
|
end
|
|
else
|
|
debugPrint("Keine Lizenz vom Typ " .. licenseType .. " gefunden")
|
|
safeCallback(cb, nil)
|
|
end
|
|
end)
|
|
end)
|
|
|
|
QBCore.Functions.CreateCallback('license-system:server:getPlayerLicenses', function(source, cb, targetId)
|
|
debugPrint("getPlayerLicenses aufgerufen für Spieler: " .. tostring(targetId))
|
|
|
|
local TargetPlayer = QBCore.Functions.GetPlayer(targetId)
|
|
if not TargetPlayer then
|
|
safeCallback(cb, {})
|
|
return
|
|
end
|
|
|
|
local citizenid = TargetPlayer.PlayerData.citizenid
|
|
|
|
MySQL.Async.fetchAll('SELECT * FROM player_licenses WHERE citizenid = ? ORDER BY created_at DESC', {
|
|
citizenid
|
|
}, function(result)
|
|
if result then
|
|
-- Spieler-Daten zu jeder Lizenz hinzufügen
|
|
for i, license in ipairs(result) do
|
|
license.name = TargetPlayer.PlayerData.charinfo.firstname .. ' ' .. TargetPlayer.PlayerData.charinfo.lastname
|
|
license.birthday = TargetPlayer.PlayerData.charinfo.birthdate
|
|
license.gender = TargetPlayer.PlayerData.charinfo.gender
|
|
end
|
|
|
|
debugPrint("Gefundene Lizenzen: " .. #result)
|
|
safeCallback(cb, result)
|
|
else
|
|
debugPrint("Keine Lizenzen gefunden")
|
|
safeCallback(cb, {})
|
|
end
|
|
end)
|
|
end)
|
|
|
|
QBCore.Functions.CreateCallback('license-system:server:canIssueLicense', function(source, cb, licenseType)
|
|
local hasAuth = hasPermission(source, licenseType)
|
|
safeCallback(cb, hasAuth)
|
|
end)
|
|
|
|
-- Events
|
|
RegisterNetEvent('license-system:server:issueLicense', function(targetId, licenseType, classes)
|
|
local src = source
|
|
local Player = QBCore.Functions.GetPlayer(src)
|
|
local TargetPlayer = QBCore.Functions.GetPlayer(targetId)
|
|
|
|
if not Player or not TargetPlayer then
|
|
TriggerClientEvent('QBCore:Notify', src, Config.Notifications.no_players_nearby.message, Config.Notifications.no_players_nearby.type)
|
|
return
|
|
end
|
|
|
|
-- Berechtigung prüfen
|
|
if not hasPermission(src, licenseType) then
|
|
TriggerClientEvent('QBCore:Notify', src, Config.Notifications.no_permission.message, Config.Notifications.no_permission.type)
|
|
return
|
|
end
|
|
|
|
-- Lizenz-Konfiguration prüfen
|
|
local licenseConfig = Config.LicenseTypes[licenseType]
|
|
if not licenseConfig then
|
|
TriggerClientEvent('QBCore:Notify', src, 'Unbekannter Lizenztyp!', 'error')
|
|
return
|
|
end
|
|
|
|
-- Benötigte Items prüfen
|
|
if not hasRequiredItems(targetId, licenseType) then
|
|
TriggerClientEvent('QBCore:Notify', src, Config.Notifications.missing_items.message, Config.Notifications.missing_items.type)
|
|
return
|
|
end
|
|
|
|
-- Geld prüfen (falls Kosten anfallen)
|
|
if licenseConfig.price > 0 then
|
|
if TargetPlayer.PlayerData.money.cash < licenseConfig.price then
|
|
TriggerClientEvent('QBCore:Notify', src, Config.Notifications.insufficient_funds.message, Config.Notifications.insufficient_funds.type)
|
|
return
|
|
end
|
|
|
|
-- Geld abziehen
|
|
TargetPlayer.Functions.RemoveMoney('cash', licenseConfig.price, 'license-fee')
|
|
end
|
|
|
|
-- Alte Lizenz deaktivieren
|
|
MySQL.Async.execute('UPDATE player_licenses SET is_active = FALSE WHERE citizenid = ? AND license_type = ?', {
|
|
TargetPlayer.PlayerData.citizenid,
|
|
licenseType
|
|
})
|
|
|
|
-- Neue Lizenz erstellen
|
|
local success = createLicense(TargetPlayer.PlayerData.citizenid, licenseType, Player.PlayerData.citizenid, classes)
|
|
|
|
if success then
|
|
TriggerClientEvent('QBCore:Notify', src, Config.Notifications.license_granted.message, Config.Notifications.license_granted.type)
|
|
TriggerClientEvent('QBCore:Notify', targetId, 'Du hast eine neue ' .. licenseConfig.label .. ' erhalten!', 'success')
|
|
|
|
-- Log erstellen
|
|
debugPrint(Player.PlayerData.charinfo.firstname .. ' ' .. Player.PlayerData.charinfo.lastname .. ' hat ' .. TargetPlayer.PlayerData.charinfo.firstname .. ' ' .. TargetPlayer.PlayerData.charinfo.lastname .. ' eine ' .. licenseConfig.label .. ' ausgestellt')
|
|
else
|
|
TriggerClientEvent('QBCore:Notify', src, 'Fehler beim Ausstellen der Lizenz!', 'error')
|
|
end
|
|
end)
|
|
|
|
RegisterNetEvent('license-system:server:revokeLicense', function(targetId, licenseType)
|
|
local src = source
|
|
local Player = QBCore.Functions.GetPlayer(src)
|
|
local TargetPlayer = QBCore.Functions.GetPlayer(targetId)
|
|
|
|
if not Player or not TargetPlayer then
|
|
TriggerClientEvent('QBCore:Notify', src, Config.Notifications.no_players_nearby.message, Config.Notifications.no_players_nearby.type)
|
|
return
|
|
end
|
|
|
|
-- Berechtigung prüfen
|
|
if not hasPermission(src, licenseType) then
|
|
TriggerClientEvent('QBCore:Notify', src, Config.Notifications.no_permission.message, Config.Notifications.no_permission.type)
|
|
return
|
|
end
|
|
|
|
-- Lizenz deaktivieren
|
|
MySQL.Async.execute('UPDATE player_licenses SET is_active = FALSE WHERE citizenid = ? AND license_type = ? AND is_active = TRUE', {
|
|
TargetPlayer.PlayerData.citizenid,
|
|
licenseType
|
|
}, function(affectedRows)
|
|
if affectedRows > 0 then
|
|
TriggerClientEvent('QBCore:Notify', src, Config.Notifications.license_revoked.message, Config.Notifications.license_revoked.type)
|
|
TriggerClientEvent('QBCore:Notify', targetId, 'Deine ' .. (Config.LicenseTypes[licenseType]?.label or licenseType) .. ' wurde entzogen!', 'error')
|
|
|
|
-- Log erstellen
|
|
debugPrint(Player.PlayerData.charinfo.firstname .. ' ' .. Player.PlayerData.charinfo.lastname .. ' hat ' .. TargetPlayer.PlayerData.charinfo.firstname .. ' ' .. TargetPlayer.PlayerData.charinfo.lastname .. ' die ' .. (Config.LicenseTypes[licenseType]?.label or licenseType) .. ' entzogen')
|
|
else
|
|
TriggerClientEvent('QBCore:Notify', src, 'Keine aktive Lizenz gefunden!', 'error')
|
|
end
|
|
end)
|
|
end)
|
|
|
|
RegisterNetEvent('license-system:server:savePhoto', function(citizenid, photoData)
|
|
local src = source
|
|
local Player = QBCore.Functions.GetPlayer(src)
|
|
|
|
if not Player then return end
|
|
|
|
-- Foto in der Datenbank speichern
|
|
MySQL.Async.execute('UPDATE player_licenses SET photo_url = ? WHERE citizenid = ? AND is_active = TRUE', {
|
|
photoData,
|
|
citizenid
|
|
}, function(affectedRows)
|
|
if affectedRows > 0 then
|
|
TriggerClientEvent('QBCore:Notify', src, Config.Notifications.photo_saved.message, Config.Notifications.photo_saved.type)
|
|
debugPrint("Foto gespeichert für: " .. citizenid)
|
|
else
|
|
TriggerClientEvent('QBCore:Notify', src, 'Fehler beim Speichern des Fotos!', 'error')
|
|
end
|
|
end)
|
|
end)
|
|
|
|
-- Admin-Kommandos
|
|
QBCore.Commands.Add('givelicense', 'Lizenz an Spieler vergeben', {
|
|
{name = 'id', help = 'Spieler ID'},
|
|
{name = 'type', help = 'Lizenztyp'},
|
|
{name = 'classes', help = 'Klassen (optional)'}
|
|
}, true, function(source, args)
|
|
local targetId = tonumber(args[1])
|
|
local licenseType = args[2]
|
|
local classes = args[3] and {args[3]} or nil
|
|
|
|
if not targetId or not licenseType then
|
|
TriggerClientEvent('QBCore:Notify', source, 'Verwendung: /givelicense [id] [typ] [klassen]', 'error')
|
|
return
|
|
end
|
|
|
|
if not Config.LicenseTypes[licenseType] then
|
|
TriggerClientEvent('QBCore:Notify', source, 'Unbekannter Lizenztyp!', 'error')
|
|
return
|
|
end
|
|
|
|
TriggerEvent('license-system:server:issueLicense', targetId, licenseType, classes)
|
|
end, 'admin')
|
|
|
|
QBCore.Commands.Add('revokelicense', 'Lizenz entziehen', {
|
|
{name = 'id', help = 'Spieler ID'},
|
|
{name = 'type', help = 'Lizenztyp'}
|
|
}, true, function(source, args)
|
|
local targetId = tonumber(args[1])
|
|
local licenseType = args[2]
|
|
|
|
if not targetId or not licenseType then
|
|
TriggerClientEvent('QBCore:Notify', source, 'Verwendung: /revokelicense [id] [typ]', 'error')
|
|
return
|
|
end
|
|
|
|
TriggerEvent('license-system:server:revokeLicense', targetId, licenseType)
|
|
end, 'admin')
|
|
|
|
-- Cleanup-Task für abgelaufene Lizenzen
|
|
if Config.Database.auto_cleanup then
|
|
CreateThread(function()
|
|
while true do
|
|
Wait(24 * 60 * 60 * 1000) -- Einmal täglich
|
|
|
|
local cutoffDate = os.time() - (Config.Database.cleanup_days * 24 * 60 * 60)
|
|
|
|
MySQL.Async.execute('DELETE FROM player_licenses WHERE is_active = FALSE AND created_at < ?', {
|
|
cutoffDate
|
|
}, function(affectedRows)
|
|
if affectedRows > 0 then
|
|
debugPrint("Cleanup: " .. affectedRows .. " alte Lizenzen gelöscht")
|
|
end
|
|
end)
|
|
end
|
|
end)
|
|
end
|
|
|
|
-- Lizenz-Ablauf-Checker
|
|
CreateThread(function()
|
|
while true do
|
|
Wait(60 * 60 * 1000) -- Jede Stunde
|
|
|
|
MySQL.Async.fetchAll('SELECT * FROM player_licenses WHERE is_active = TRUE AND expire_date IS NOT NULL', {}, function(result)
|
|
if result then
|
|
for _, license in ipairs(result) do
|
|
local expireTime = os.time({
|
|
year = tonumber(string.sub(license.expire_date, 7, 10)),
|
|
month = tonumber(string.sub(license.expire_date, 4, 5)),
|
|
day = tonumber(string.sub(license.expire_date, 1, 2))
|
|
})
|
|
|
|
if isLicenseExpired(expireTime) then
|
|
-- Lizenz als abgelaufen markieren
|
|
MySQL.Async.execute('UPDATE player_licenses SET is_active = FALSE WHERE id = ?', {
|
|
license.id
|
|
})
|
|
|
|
debugPrint("Lizenz abgelaufen: " .. license.license_type .. " für " .. license.citizenid)
|
|
end
|
|
end
|
|
end
|
|
end)
|
|
end
|
|
end)
|
|
|
|
-- Resource Start/Stop Events
|
|
AddEventHandler('onResourceStart', function(resourceName)
|
|
if GetCurrentResourceName() == resourceName then
|
|
debugPrint("License-System Server gestartet")
|
|
|
|
-- Datenbank-Tabelle erstellen falls nicht vorhanden
|
|
MySQL.Async.execute([[
|
|
CREATE TABLE IF NOT EXISTS player_licenses (
|
|
id INT AUTO_INCREMENT PRIMARY KEY,
|
|
citizenid VARCHAR(50) NOT NULL,
|
|
license_type VARCHAR(50) NOT NULL,
|
|
issue_date VARCHAR(20) NOT NULL,
|
|
expire_date VARCHAR(20) NULL,
|
|
issued_by VARCHAR(50) NULL,
|
|
is_active BOOLEAN DEFAULT TRUE,
|
|
classes TEXT NULL,
|
|
photo_url TEXT NULL,
|
|
notes TEXT NULL,
|
|
created_at BIGINT NOT NULL,
|
|
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
|
|
INDEX idx_citizenid (citizenid),
|
|
INDEX idx_license_type (license_type),
|
|
INDEX idx_active (is_active)
|
|
)
|
|
]])
|
|
end
|
|
end)
|
|
|
|
AddEventHandler('onResourceStop', function(resourceName)
|
|
if GetCurrentResourceName() == resourceName then
|
|
debugPrint("License-System Server gestoppt")
|
|
end
|
|
end)
|