forked from Simnation/Main
616 lines
24 KiB
Lua
616 lines
24 KiB
Lua
local QBCore = exports['qb-core']:GetCoreObject()
|
|
|
|
-- Datenbank Setup
|
|
CreateThread(function()
|
|
MySQL.query([[
|
|
CREATE TABLE IF NOT EXISTS infopoint_events (
|
|
id INT AUTO_INCREMENT PRIMARY KEY,
|
|
title VARCHAR(255) NOT NULL,
|
|
description TEXT,
|
|
category VARCHAR(100),
|
|
location VARCHAR(255),
|
|
event_date DATETIME,
|
|
created_by VARCHAR(50),
|
|
created_by_name VARCHAR(255),
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
active BOOLEAN DEFAULT TRUE
|
|
)
|
|
]])
|
|
|
|
MySQL.query([[
|
|
CREATE TABLE IF NOT EXISTS infopoint_incidents (
|
|
id INT AUTO_INCREMENT PRIMARY KEY,
|
|
title VARCHAR(255) NOT NULL,
|
|
description TEXT,
|
|
category VARCHAR(100),
|
|
location VARCHAR(255),
|
|
reported_by VARCHAR(50),
|
|
reported_by_name VARCHAR(255),
|
|
status VARCHAR(50) DEFAULT 'open',
|
|
assigned_to VARCHAR(50),
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
|
)
|
|
]])
|
|
|
|
MySQL.query([[
|
|
CREATE TABLE IF NOT EXISTS infopoint_job_offers (
|
|
id INT AUTO_INCREMENT PRIMARY KEY,
|
|
job_name VARCHAR(100),
|
|
title VARCHAR(255),
|
|
description TEXT,
|
|
requirements TEXT,
|
|
salary VARCHAR(100),
|
|
contact VARCHAR(255),
|
|
created_by VARCHAR(50),
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
active BOOLEAN DEFAULT TRUE
|
|
)
|
|
]])
|
|
|
|
-- Neue Tabelle für Lizenz-Informationen
|
|
MySQL.query([[
|
|
CREATE TABLE IF NOT EXISTS infopoint_license_info (
|
|
id INT AUTO_INCREMENT PRIMARY KEY,
|
|
license_type VARCHAR(100) NOT NULL,
|
|
price VARCHAR(50),
|
|
requirements TEXT,
|
|
description TEXT,
|
|
processing_time VARCHAR(100),
|
|
valid_duration VARCHAR(100),
|
|
created_by VARCHAR(50),
|
|
updated_by VARCHAR(50),
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
|
|
active BOOLEAN DEFAULT TRUE
|
|
)
|
|
]])
|
|
|
|
-- Neue Tabelle für allgemeine Informationen
|
|
MySQL.query([[
|
|
CREATE TABLE IF NOT EXISTS infopoint_general_info (
|
|
id INT AUTO_INCREMENT PRIMARY KEY,
|
|
title VARCHAR(255) NOT NULL,
|
|
content TEXT,
|
|
category VARCHAR(100),
|
|
importance VARCHAR(50) DEFAULT 'normal',
|
|
created_by VARCHAR(50),
|
|
created_by_job VARCHAR(50),
|
|
created_by_name VARCHAR(255),
|
|
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
expires_at DATETIME NULL,
|
|
active BOOLEAN DEFAULT TRUE
|
|
)
|
|
]])
|
|
|
|
-- Standard Lizenz-Informationen einfügen falls nicht vorhanden
|
|
MySQL.query('SELECT COUNT(*) as count FROM infopoint_license_info', {}, function(result)
|
|
if result[1].count == 0 then
|
|
local defaultLicenses = {
|
|
{
|
|
license_type = 'Führerschein',
|
|
price = '$500',
|
|
requirements = 'Mindestalter 18 Jahre, Theorieprüfung bestehen, Praktische Prüfung bestehen',
|
|
description = 'Berechtigt zum Führen von PKW und leichten Nutzfahrzeugen',
|
|
processing_time = '1-2 Werktage',
|
|
valid_duration = 'Unbegrenzt'
|
|
},
|
|
{
|
|
license_type = 'Waffenschein',
|
|
price = '$2000',
|
|
requirements = 'Saubere Akte, Psychologisches Gutachten, Waffenprüfung bestehen, Mindestalter 21 Jahre',
|
|
description = 'Berechtigt zum Führen von Schusswaffen',
|
|
processing_time = '2-4 Wochen',
|
|
valid_duration = '5 Jahre'
|
|
},
|
|
{
|
|
license_type = 'Pilotenschein',
|
|
price = '$10000',
|
|
requirements = 'Flugstunden nachweisen, Medizinische Untersuchung, Theorieprüfung, Praktische Prüfung',
|
|
description = 'Berechtigt zum Führen von Luftfahrzeugen',
|
|
processing_time = '4-8 Wochen',
|
|
valid_duration = '2 Jahre'
|
|
},
|
|
{
|
|
license_type = 'Motorradführerschein',
|
|
price = '$750',
|
|
requirements = 'Mindestalter 18 Jahre, Theorieprüfung bestehen, Praktische Prüfung bestehen',
|
|
description = 'Berechtigt zum Führen von Motorrädern',
|
|
processing_time = '1-2 Werktage',
|
|
valid_duration = 'Unbegrenzt'
|
|
},
|
|
{
|
|
license_type = 'Bootslizenz',
|
|
price = '$1500',
|
|
requirements = 'Mindestalter 16 Jahre, Theorieprüfung bestehen, Praktische Prüfung bestehen',
|
|
description = 'Berechtigt zum Führen von Wasserfahrzeugen',
|
|
processing_time = '3-5 Werktage',
|
|
valid_duration = '10 Jahre'
|
|
}
|
|
}
|
|
|
|
for _, license in pairs(defaultLicenses) do
|
|
MySQL.insert('INSERT INTO infopoint_license_info (license_type, price, requirements, description, processing_time, valid_duration, created_by) VALUES (?, ?, ?, ?, ?, ?, ?)', {
|
|
license.license_type,
|
|
license.price,
|
|
license.requirements,
|
|
license.description,
|
|
license.processing_time,
|
|
license.valid_duration,
|
|
'system'
|
|
})
|
|
end
|
|
end
|
|
end)
|
|
end)
|
|
|
|
-- Events abrufen
|
|
QBCore.Functions.CreateCallback('infopoint:getEvents', function(source, cb)
|
|
MySQL.query('SELECT * FROM infopoint_events WHERE active = 1 ORDER BY event_date ASC', {}, function(result)
|
|
cb(result)
|
|
end)
|
|
end)
|
|
|
|
-- Vorfälle abrufen (nur für berechtigte Jobs)
|
|
QBCore.Functions.CreateCallback('infopoint:getIncidents', function(source, cb)
|
|
local Player = QBCore.Functions.GetPlayer(source)
|
|
if not Player then return cb({}) end
|
|
|
|
local job = Player.PlayerData.job.name
|
|
if Config.JobPermissions and Config.JobPermissions.jobSpecificInfo and
|
|
Config.JobPermissions.jobSpecificInfo[job] and
|
|
Config.JobPermissions.jobSpecificInfo[job].showIncidents then
|
|
MySQL.query('SELECT * FROM infopoint_incidents ORDER BY created_at DESC', {}, function(result)
|
|
cb(result)
|
|
end)
|
|
else
|
|
cb({})
|
|
end
|
|
end)
|
|
|
|
-- Job Angebote abrufen
|
|
QBCore.Functions.CreateCallback('infopoint:getJobOffers', function(source, cb, jobName)
|
|
local query = 'SELECT * FROM infopoint_job_offers WHERE active = 1'
|
|
local params = {}
|
|
|
|
if jobName then
|
|
query = query .. ' AND job_name = ?'
|
|
params = {jobName}
|
|
end
|
|
|
|
query = query .. ' ORDER BY created_at DESC'
|
|
|
|
MySQL.query(query, params, function(result)
|
|
cb(result)
|
|
end)
|
|
end)
|
|
|
|
-- Lizenz Informationen abrufen
|
|
QBCore.Functions.CreateCallback('infopoint:getLicenseInfo', function(source, cb)
|
|
MySQL.query('SELECT * FROM infopoint_license_info WHERE active = 1 ORDER BY license_type ASC', {}, function(result)
|
|
cb(result)
|
|
end)
|
|
end)
|
|
|
|
-- Allgemeine Informationen abrufen
|
|
QBCore.Functions.CreateCallback('infopoint:getGeneralInfo', function(source, cb)
|
|
local currentDate = os.date('%Y-%m-%d')
|
|
|
|
MySQL.query('SELECT * FROM infopoint_general_info WHERE active = 1 AND (expires_at IS NULL OR expires_at >= ?) ORDER BY importance DESC, created_at DESC', {currentDate}, function(result)
|
|
cb(result)
|
|
end)
|
|
end)
|
|
|
|
-- Prüfen ob Spieler Lizenz-Informationen verwalten kann
|
|
QBCore.Functions.CreateCallback('infopoint:canManageLicenses', function(source, cb)
|
|
local Player = QBCore.Functions.GetPlayer(source)
|
|
if not Player then return cb(false) end
|
|
|
|
local job = Player.PlayerData.job.name
|
|
local canManage = false
|
|
|
|
-- Sicherheitsprüfung für Config
|
|
if Config and Config.JobPermissions and Config.JobPermissions.canManageLicenses then
|
|
if type(Config.JobPermissions.canManageLicenses) == 'table' then
|
|
for _, allowedJob in pairs(Config.JobPermissions.canManageLicenses) do
|
|
if job == allowedJob then
|
|
canManage = true
|
|
break
|
|
end
|
|
end
|
|
elseif type(Config.JobPermissions.canManageLicenses) == 'string' then
|
|
canManage = (job == Config.JobPermissions.canManageLicenses)
|
|
end
|
|
end
|
|
|
|
cb(canManage)
|
|
end)
|
|
|
|
-- Event erstellen
|
|
RegisterNetEvent('infopoint:createEvent', function(eventData)
|
|
local src = source
|
|
local Player = QBCore.Functions.GetPlayer(src)
|
|
if not Player then return end
|
|
|
|
local job = Player.PlayerData.job.name
|
|
local canCreate = false
|
|
|
|
-- Sicherheitsprüfung für Config
|
|
if Config and Config.JobPermissions and Config.JobPermissions.canCreateEvents then
|
|
if type(Config.JobPermissions.canCreateEvents) == 'table' then
|
|
for _, allowedJob in pairs(Config.JobPermissions.canCreateEvents) do
|
|
if job == allowedJob then
|
|
canCreate = true
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if not canCreate then
|
|
TriggerClientEvent('QBCore:Notify', src, 'Du hast keine Berechtigung Events zu erstellen!', 'error')
|
|
return
|
|
end
|
|
|
|
MySQL.insert('INSERT INTO infopoint_events (title, description, category, location, event_date, created_by, created_by_name) VALUES (?, ?, ?, ?, ?, ?, ?)', {
|
|
eventData.title,
|
|
eventData.description,
|
|
eventData.category,
|
|
eventData.location,
|
|
eventData.date,
|
|
Player.PlayerData.citizenid,
|
|
Player.PlayerData.charinfo.firstname .. ' ' .. Player.PlayerData.charinfo.lastname
|
|
}, function(insertId)
|
|
if insertId then
|
|
TriggerClientEvent('QBCore:Notify', src, 'Event erfolgreich erstellt!', 'success')
|
|
TriggerClientEvent('infopoint:refreshData', -1)
|
|
end
|
|
end)
|
|
end)
|
|
|
|
-- Vorfall melden
|
|
RegisterNetEvent('infopoint:reportIncident', function(incidentData)
|
|
local src = source
|
|
local Player = QBCore.Functions.GetPlayer(src)
|
|
if not Player then return end
|
|
|
|
MySQL.insert('INSERT INTO infopoint_incidents (title, description, category, location, reported_by, reported_by_name) VALUES (?, ?, ?, ?, ?, ?)', {
|
|
incidentData.title,
|
|
incidentData.description,
|
|
incidentData.category,
|
|
incidentData.location,
|
|
Player.PlayerData.citizenid,
|
|
Player.PlayerData.charinfo.firstname .. ' ' .. Player.PlayerData.charinfo.lastname
|
|
}, function(insertId)
|
|
if insertId then
|
|
TriggerClientEvent('QBCore:Notify', src, 'Vorfall erfolgreich gemeldet!', 'success')
|
|
|
|
-- Benachrichtigung an alle Polizisten senden
|
|
local Players = QBCore.Functions.GetQBPlayers()
|
|
for _, player in pairs(Players) do
|
|
if player.PlayerData.job.name == 'police' and player.PlayerData.job.onduty then
|
|
TriggerClientEvent('QBCore:Notify', player.PlayerData.source, 'Neuer Vorfall gemeldet: ' .. incidentData.title, 'primary')
|
|
end
|
|
end
|
|
end
|
|
end)
|
|
end)
|
|
|
|
-- Job Angebot erstellen
|
|
RegisterNetEvent('infopoint:createJobOffer', function(jobData)
|
|
local src = source
|
|
local Player = QBCore.Functions.GetPlayer(src)
|
|
if not Player then return end
|
|
|
|
local job = Player.PlayerData.job.name
|
|
local canCreate = false
|
|
|
|
-- Sicherheitsprüfung für Config
|
|
if Config and Config.JobPermissions and Config.JobPermissions.canCreateEvents then
|
|
if type(Config.JobPermissions.canCreateEvents) == 'table' then
|
|
for _, allowedJob in pairs(Config.JobPermissions.canCreateEvents) do
|
|
if job == allowedJob then
|
|
canCreate = true
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if not canCreate then
|
|
TriggerClientEvent('QBCore:Notify', src, 'Du hast keine Berechtigung Job-Angebote zu erstellen!', 'error')
|
|
return
|
|
end
|
|
|
|
MySQL.insert('INSERT INTO infopoint_job_offers (job_name, title, description, requirements, salary, contact, created_by) VALUES (?, ?, ?, ?, ?, ?, ?)', {
|
|
job,
|
|
jobData.title,
|
|
jobData.description,
|
|
jobData.requirements,
|
|
jobData.salary,
|
|
jobData.contact,
|
|
Player.PlayerData.citizenid
|
|
}, function(insertId)
|
|
if insertId then
|
|
TriggerClientEvent('QBCore:Notify', src, 'Job-Angebot erfolgreich erstellt!', 'success')
|
|
end
|
|
end)
|
|
end)
|
|
|
|
-- Lizenz-Information erstellen
|
|
RegisterNetEvent('infopoint:createLicenseInfo', function(licenseData)
|
|
local src = source
|
|
local Player = QBCore.Functions.GetPlayer(src)
|
|
if not Player then return end
|
|
|
|
local job = Player.PlayerData.job.name
|
|
local canManage = false
|
|
|
|
-- Sicherheitsprüfung für Config
|
|
if Config and Config.JobPermissions and Config.JobPermissions.canManageLicenses then
|
|
if type(Config.JobPermissions.canManageLicenses) == 'table' then
|
|
for _, allowedJob in pairs(Config.JobPermissions.canManageLicenses) do
|
|
if job == allowedJob then
|
|
canManage = true
|
|
break
|
|
end
|
|
end
|
|
elseif type(Config.JobPermissions.canManageLicenses) == 'string' then
|
|
canManage = (job == Config.JobPermissions.canManageLicenses)
|
|
end
|
|
end
|
|
|
|
if not canManage then
|
|
TriggerClientEvent('QBCore:Notify', src, 'Du hast keine Berechtigung Lizenz-Informationen zu verwalten!', 'error')
|
|
return
|
|
end
|
|
|
|
MySQL.insert('INSERT INTO infopoint_license_info (license_type, price, requirements, description, processing_time, valid_duration, created_by) VALUES (?, ?, ?, ?, ?, ?, ?)', {
|
|
licenseData.license_type,
|
|
licenseData.price,
|
|
licenseData.requirements,
|
|
licenseData.description,
|
|
licenseData.processing_time,
|
|
licenseData.valid_duration,
|
|
Player.PlayerData.citizenid
|
|
}, function(insertId)
|
|
if insertId then
|
|
TriggerClientEvent('QBCore:Notify', src, 'Lizenz-Information erfolgreich erstellt!', 'success')
|
|
end
|
|
end)
|
|
end)
|
|
|
|
-- Lizenz-Information bearbeiten
|
|
RegisterNetEvent('infopoint:updateLicenseInfo', function(licenseId, licenseData)
|
|
local src = source
|
|
local Player = QBCore.Functions.GetPlayer(src)
|
|
if not Player then return end
|
|
|
|
local job = Player.PlayerData.job.name
|
|
local canManage = false
|
|
|
|
-- Sicherheitsprüfung für Config
|
|
if Config and Config.JobPermissions and Config.JobPermissions.canManageLicenses then
|
|
if type(Config.JobPermissions.canManageLicenses) == 'table' then
|
|
for _, allowedJob in pairs(Config.JobPermissions.canManageLicenses) do
|
|
if job == allowedJob then
|
|
canManage = true
|
|
break
|
|
end
|
|
end
|
|
elseif type(Config.JobPermissions.canManageLicenses) == 'string' then
|
|
canManage = (job == Config.JobPermissions.canManageLicenses)
|
|
end
|
|
end
|
|
|
|
if not canManage then
|
|
TriggerClientEvent('QBCore:Notify', src, 'Du hast keine Berechtigung Lizenz-Informationen zu verwalten!', 'error')
|
|
return
|
|
end
|
|
|
|
MySQL.update('UPDATE infopoint_license_info SET license_type = ?, price = ?, requirements = ?, description = ?, processing_time = ?, valid_duration = ?, updated_by = ? WHERE id = ?', {
|
|
licenseData.license_type,
|
|
licenseData.price,
|
|
licenseData.requirements,
|
|
licenseData.description,
|
|
licenseData.processing_time,
|
|
licenseData.valid_duration,
|
|
Player.PlayerData.citizenid,
|
|
licenseId
|
|
}, function(affectedRows)
|
|
if affectedRows > 0 then
|
|
TriggerClientEvent('QBCore:Notify', src, 'Lizenz-Information erfolgreich aktualisiert!', 'success')
|
|
else
|
|
TriggerClientEvent('QBCore:Notify', src, 'Fehler beim Aktualisieren der Lizenz-Information!', 'error')
|
|
end
|
|
end)
|
|
end)
|
|
|
|
-- Lizenz-Information löschen
|
|
RegisterNetEvent('infopoint:deleteLicenseInfo', function(licenseId)
|
|
local src = source
|
|
local Player = QBCore.Functions.GetPlayer(src)
|
|
if not Player then return end
|
|
|
|
local job = Player.PlayerData.job.name
|
|
local canManage = false
|
|
|
|
-- Sicherheitsprüfung für Config
|
|
if Config and Config.JobPermissions and Config.JobPermissions.canManageLicenses then
|
|
if type(Config.JobPermissions.canManageLicenses) == 'table' then
|
|
for _, allowedJob in pairs(Config.JobPermissions.canManageLicenses) do
|
|
if job == allowedJob then
|
|
canManage = true
|
|
break
|
|
end
|
|
end
|
|
elseif type(Config.JobPermissions.canManageLicenses) == 'string' then
|
|
canManage = (job == Config.JobPermissions.canManageLicenses)
|
|
end
|
|
end
|
|
|
|
if not canManage then
|
|
TriggerClientEvent('QBCore:Notify', src, 'Du hast keine Berechtigung Lizenz-Informationen zu verwalten!', 'error')
|
|
return
|
|
end
|
|
|
|
MySQL.update('UPDATE infopoint_license_info SET active = 0 WHERE id = ?', {licenseId}, function(affectedRows)
|
|
if affectedRows > 0 then
|
|
TriggerClientEvent('QBCore:Notify', src, 'Lizenz-Information erfolgreich gelöscht!', 'success')
|
|
else
|
|
TriggerClientEvent('QBCore:Notify', src, 'Fehler beim Löschen der Lizenz-Information!', 'error')
|
|
end
|
|
end)
|
|
end)
|
|
|
|
-- Allgemeine Information erstellen
|
|
RegisterNetEvent('infopoint:createGeneralInfo', function(infoData)
|
|
local src = source
|
|
local Player = QBCore.Functions.GetPlayer(src)
|
|
if not Player then return end
|
|
|
|
local job = Player.PlayerData.job.name
|
|
local canPost = false
|
|
|
|
-- Sicherheitsprüfung für Config
|
|
if Config and Config.JobPermissions and Config.JobPermissions.canPostGeneralInfo then
|
|
if type(Config.JobPermissions.canPostGeneralInfo) == 'table' then
|
|
for _, allowedJob in pairs(Config.JobPermissions.canPostGeneralInfo) do
|
|
if job == allowedJob then
|
|
canPost = true
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if not canPost then
|
|
TriggerClientEvent('QBCore:Notify', src, 'Du hast keine Berechtigung allgemeine Informationen zu veröffentlichen!', 'error')
|
|
return
|
|
end
|
|
|
|
MySQL.insert('INSERT INTO infopoint_general_info (title, content, category, importance, expires_at, created_by, created_by_job, created_by_name) VALUES (?, ?, ?, ?, ?, ?, ?, ?)', {
|
|
infoData.title,
|
|
infoData.content,
|
|
infoData.category,
|
|
infoData.importance,
|
|
infoData.expires_at,
|
|
Player.PlayerData.citizenid,
|
|
Player.PlayerData.job.name,
|
|
Player.PlayerData.charinfo.firstname .. ' ' .. Player.PlayerData.charinfo.lastname
|
|
}, function(insertId)
|
|
if insertId then
|
|
TriggerClientEvent('QBCore:Notify', src, 'Information erfolgreich veröffentlicht!', 'success')
|
|
TriggerClientEvent('infopoint:refreshData', -1)
|
|
end
|
|
end)
|
|
end)
|
|
|
|
-- Allgemeine Information bearbeiten
|
|
RegisterNetEvent('infopoint:updateGeneralInfo', function(infoId, infoData)
|
|
local src = source
|
|
local Player = QBCore.Functions.GetPlayer(src)
|
|
if not Player then return end
|
|
|
|
-- First check if this player created the info or has permission to post general info
|
|
MySQL.query('SELECT created_by FROM infopoint_general_info WHERE id = ?', {infoId}, function(result)
|
|
if result[1] then
|
|
local canEdit = false
|
|
|
|
-- Check if player created this info
|
|
if result[1].created_by == Player.PlayerData.citizenid then
|
|
canEdit = true
|
|
end
|
|
|
|
-- Check if player has permission to post general info (they can also edit)
|
|
if not canEdit then
|
|
local job = Player.PlayerData.job.name
|
|
if Config and Config.JobPermissions and Config.JobPermissions.canPostGeneralInfo then
|
|
if type(Config.JobPermissions.canPostGeneralInfo) == 'table' then
|
|
for _, allowedJob in pairs(Config.JobPermissions.canPostGeneralInfo) do
|
|
if job == allowedJob then
|
|
canEdit = true
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if not canEdit then
|
|
TriggerClientEvent('QBCore:Notify', src, 'Du hast keine Berechtigung diese Information zu bearbeiten!', 'error')
|
|
return
|
|
end
|
|
|
|
-- Update the info
|
|
MySQL.update('UPDATE infopoint_general_info SET title = ?, content = ?, category = ?, importance = ?, expires_at = ? WHERE id = ?', {
|
|
infoData.title,
|
|
infoData.content,
|
|
infoData.category,
|
|
infoData.importance,
|
|
infoData.expires_at,
|
|
infoId
|
|
}, function(affectedRows)
|
|
if affectedRows > 0 then
|
|
TriggerClientEvent('QBCore:Notify', src, 'Information erfolgreich aktualisiert!', 'success')
|
|
TriggerClientEvent('infopoint:refreshData', -1)
|
|
else
|
|
TriggerClientEvent('QBCore:Notify', src, 'Fehler beim Aktualisieren der Information!', 'error')
|
|
end
|
|
end)
|
|
else
|
|
TriggerClientEvent('QBCore:Notify', src, 'Information nicht gefunden!', 'error')
|
|
end
|
|
end)
|
|
end)
|
|
|
|
-- Allgemeine Information löschen
|
|
RegisterNetEvent('infopoint:deleteGeneralInfo', function(infoId)
|
|
local src = source
|
|
local Player = QBCore.Functions.GetPlayer(src)
|
|
if not Player then return end
|
|
|
|
-- First check if this player created the info or has permission to post general info
|
|
MySQL.query('SELECT created_by FROM infopoint_general_info WHERE id = ?', {infoId}, function(result)
|
|
if result[1] then
|
|
local canDelete = false
|
|
|
|
-- Check if player created this info
|
|
if result[1].created_by == Player.PlayerData.citizenid then
|
|
canDelete = true
|
|
end
|
|
|
|
-- Check if player has permission to post general info (they can also delete)
|
|
if not canDelete then
|
|
local job = Player.PlayerData.job.name
|
|
if Config and Config.JobPermissions and Config.JobPermissions.canPostGeneralInfo then
|
|
if type(Config.JobPermissions.canPostGeneralInfo) == 'table' then
|
|
for _, allowedJob in pairs(Config.JobPermissions.canPostGeneralInfo) do
|
|
if job == allowedJob then
|
|
canDelete = true
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if not canDelete then
|
|
TriggerClientEvent('QBCore:Notify', src, 'Du hast keine Berechtigung diese Information zu löschen!', 'error')
|
|
return
|
|
end
|
|
|
|
-- Delete (set inactive) the info
|
|
MySQL.update('UPDATE infopoint_general_info SET active = 0 WHERE id = ?', {infoId}, function(affectedRows)
|
|
if affectedRows > 0 then
|
|
TriggerClientEvent('QBCore:Notify', src, 'Information erfolgreich gelöscht!', 'success')
|
|
TriggerClientEvent('infopoint:refreshData', -1)
|
|
else
|
|
TriggerClientEvent('QBCore:Notify', src, 'Fehler beim Löschen der Information!', 'error')
|
|
end
|
|
end)
|
|
else
|
|
TriggerClientEvent('QBCore:Notify', src, 'Information nicht gefunden!', 'error')
|
|
end
|
|
end)
|
|
end)
|
|
|