595 lines
26 KiB
Lua
595 lines
26 KiB
Lua
|
|
-----------------------------------------------------------------------------------------------------------------------------------------
|
|
-- Versioning
|
|
-----------------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
version = ''
|
|
subversion = ''
|
|
api_response = {}
|
|
local utils_required_version = '1.2.1'
|
|
local utils_outdated = false
|
|
|
|
function checkVersion()
|
|
CreateThread(function()
|
|
local connected = false
|
|
local attempts = 0
|
|
while not connected and attempts < 3 do
|
|
attempts = attempts + 1
|
|
|
|
PerformHttpRequest("https://raw.githubusercontent.com/LeonardoSoares98/lc_fuel/main/version", function(errorCode, resultData)
|
|
if errorCode == 200 and resultData then
|
|
connected = true
|
|
local latest_version = Utils.Math.trim(resultData)
|
|
|
|
api_response.latest_version = latest_version
|
|
if Utils.Math.checkIfCurrentVersionisOutdated(latest_version, version) then
|
|
api_response.has_update = true
|
|
print("^4["..GetCurrentResourceName().."] An update is available, download it in https://github.com/LeonardoSoares98/lc_fuel/releases/latest/download/lc_fuel.zip^7 ^3[v"..api_response.latest_version.."]^7")
|
|
else
|
|
api_response.has_update = false
|
|
end
|
|
end
|
|
end, "GET", "", {})
|
|
|
|
Wait(10000)
|
|
end
|
|
end)
|
|
end
|
|
|
|
-----------------------------------------------------------------------------------------------------------------------------------------
|
|
-- Script global variables
|
|
-----------------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
Utils = Utils or exports['lc_utils']:GetUtils()
|
|
local cooldown = {}
|
|
local playerVehiclesFuelType = {}
|
|
local fuelPurchased = {}
|
|
|
|
-----------------------------------------------------------------------------------------------------------------------------------------
|
|
-- Script functions
|
|
-----------------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
RegisterServerEvent("lc_fuel:serverOpenUI")
|
|
AddEventHandler("lc_fuel:serverOpenUI",function(isElectric, pumpModel, vehicleFuel, vehicleTankSize, vehiclePlate)
|
|
local source = source
|
|
Wrapper(source,function(user_id)
|
|
local gasStationId = getCurrentGasStationId(source)
|
|
serverOpenUI(source, isElectric, pumpModel, gasStationId, vehicleFuel, vehicleTankSize, vehiclePlate)
|
|
end)
|
|
end)
|
|
|
|
RegisterServerEvent("lc_fuel:confirmRefuel")
|
|
AddEventHandler("lc_fuel:confirmRefuel",function(data)
|
|
local source = source
|
|
Wrapper(source,function(user_id)
|
|
if not data or data.fuelAmount <= 0 or not isFuelTypeValid(data.selectedFuelType) or not isPaymentMethodValid(data.paymentMethod) then
|
|
TriggerClientEvent("lc_fuel:Notify", source, "error", Utils.translate('invalid_value'))
|
|
return
|
|
end
|
|
|
|
local gasStationId = getCurrentGasStationId(source)
|
|
local stationData = getStationData(gasStationId)
|
|
local pricePerLiter = stationData.pricePerLiter[data.selectedFuelType]
|
|
local initialPrice = pricePerLiter * data.fuelAmount
|
|
|
|
local discount = getPlayerDiscountAmount(source)
|
|
local finalPrice = initialPrice * (1 - (discount / 100))
|
|
if Utils.Framework.getPlayerAccountMoney(source, Config.Accounts[data.paymentMethod]) < finalPrice then
|
|
TriggerClientEvent("lc_fuel:Notify", source, "error", Utils.translate('not_enough_money'):format(Utils.numberFormat(finalPrice)))
|
|
return
|
|
end
|
|
|
|
if not removeStockFromStation(gasStationId, finalPrice, data.fuelAmount, data.selectedFuelType, false) then
|
|
TriggerClientEvent("lc_fuel:Notify", source, "error", Utils.translate('not_enough_stock'))
|
|
return
|
|
end
|
|
|
|
Utils.Framework.tryRemoveAccountMoney(source, finalPrice, Config.Accounts[data.paymentMethod])
|
|
|
|
fuelPurchased[source] = {
|
|
finalPrice = finalPrice,
|
|
account = Config.Accounts[data.paymentMethod],
|
|
selectedFuelType = data.selectedFuelType,
|
|
fuelAmount = data.fuelAmount,
|
|
pricePerLiter = pricePerLiter,
|
|
}
|
|
|
|
TriggerClientEvent("lc_fuel:getPumpNozzle", source, data.fuelAmount, data.selectedFuelType)
|
|
TriggerClientEvent("lc_fuel:Notify", source, "success", Utils.translate('refuel_paid'):format(Utils.numberFormat(finalPrice)))
|
|
end)
|
|
end)
|
|
|
|
|
|
RegisterServerEvent("lc_fuel:returnNozzle")
|
|
AddEventHandler("lc_fuel:returnNozzle",function(remainingFuel, isElectric)
|
|
local source = source
|
|
Wrapper(source,function(user_id)
|
|
|
|
if not Config.ReturnNozzleRefund then
|
|
return
|
|
end
|
|
|
|
if not fuelPurchased[source] then
|
|
return
|
|
end
|
|
|
|
if remainingFuel < 1 then
|
|
fuelPurchased[source] = nil
|
|
return
|
|
end
|
|
|
|
local discount = getPlayerDiscountAmount(source)
|
|
local amountToReturn = math.floor(remainingFuel * (fuelPurchased[source].pricePerLiter * (1 - (discount / 100))))
|
|
|
|
if amountToReturn > fuelPurchased[source].finalPrice or remainingFuel > fuelPurchased[source].fuelAmount then
|
|
print("User "..user_id.." initially purchased "..fuelPurchased[source].fuelAmount.."L of fuel but now is returning "..remainingFuel.."L. Is this user trying to glitch something?")
|
|
print("User coords: "..GetEntityCoords(GetPlayerPed(source)))
|
|
fuelPurchased[source] = nil
|
|
return
|
|
end
|
|
|
|
local gasStationId = getCurrentGasStationId(source)
|
|
local _, returnedAmount = returnStockToGasStation(gasStationId, amountToReturn, remainingFuel, fuelPurchased[source].selectedFuelType)
|
|
|
|
if isElectric then
|
|
TriggerClientEvent("lc_fuel:Notify", source, "success", Utils.translate('returned_charge'):format(Utils.Math.round(remainingFuel, 1), returnedAmount))
|
|
else
|
|
TriggerClientEvent("lc_fuel:Notify", source, "success", Utils.translate('returned_fuel'):format(Utils.Math.round(remainingFuel, 1), returnedAmount))
|
|
end
|
|
Utils.Framework.giveAccountMoney(source, returnedAmount, fuelPurchased[source].account)
|
|
|
|
fuelPurchased[source] = nil
|
|
end)
|
|
end)
|
|
|
|
RegisterServerEvent("lc_fuel:confirmJerryCanPurchase")
|
|
AddEventHandler("lc_fuel:confirmJerryCanPurchase",function(data)
|
|
if not Config.JerryCan.enabled then return end
|
|
local source = source
|
|
Wrapper(source,function(user_id)
|
|
if not isPaymentMethodValid(data.paymentMethod) then
|
|
TriggerClientEvent("lc_fuel:Notify", source, "error", Utils.translate('invalid_value'))
|
|
return
|
|
end
|
|
|
|
local gasStationId = getCurrentGasStationId(source)
|
|
local stationData = getStationData(gasStationId)
|
|
local fuelType = nil
|
|
-- Check which type has enough stock
|
|
if stationData.stationStock.regular >= Config.JerryCan.requiredStock then
|
|
fuelType = "regular"
|
|
elseif stationData.stationStock.plus >= Config.JerryCan.requiredStock then
|
|
fuelType = "plus"
|
|
elseif stationData.stationStock.premium >= Config.JerryCan.requiredStock then
|
|
fuelType = "premium"
|
|
elseif stationData.stationStock.diesel >= Config.JerryCan.requiredStock then
|
|
fuelType = "diesel"
|
|
end
|
|
|
|
if fuelType == nil then
|
|
TriggerClientEvent("lc_fuel:Notify", source, "error", Utils.translate('not_enough_stock'))
|
|
return
|
|
end
|
|
|
|
if Utils.Framework.getPlayerAccountMoney(source, Config.Accounts[data.paymentMethod]) < Config.JerryCan.price then
|
|
TriggerClientEvent("lc_fuel:Notify", source, "error", Utils.translate('not_enough_money'):format(Config.JerryCan.price))
|
|
return
|
|
end
|
|
|
|
if not removeStockFromStation(gasStationId, Config.JerryCan.price, Config.JerryCan.requiredStock, fuelType, true) then
|
|
TriggerClientEvent("lc_fuel:Notify", source, "error", Utils.translate('not_enough_stock'))
|
|
return
|
|
end
|
|
Utils.Framework.tryRemoveAccountMoney(source, Config.JerryCan.price, Config.Accounts[data.paymentMethod])
|
|
|
|
|
|
-- Gives the jerry can to the player
|
|
local itemMetadata = {}
|
|
for k, v in pairs(Config.JerryCan.metadata or {}) do
|
|
itemMetadata[k] = v
|
|
end
|
|
|
|
-- Add all required fields for tgiann-inventory weapon items
|
|
itemMetadata.serie = "JERRYCAN-" .. math.random(100000, 999999)
|
|
itemMetadata.durabilityPercent = 100 -- Set to 100% durability for new jerry can
|
|
itemMetadata.usedTotalAmmo = 0 -- No ammo used yet
|
|
itemMetadata.ammo = itemMetadata.ammo or 20 -- Use existing ammo value or default to 20
|
|
|
|
if Config.JerryCan.giveAsWeapon then
|
|
Utils.Framework.givePlayerWeapon(source, Config.JerryCan.item, 1, itemMetadata)
|
|
else
|
|
Utils.Framework.givePlayerItem(source, Config.JerryCan.item, 1, itemMetadata)
|
|
end
|
|
|
|
|
|
TriggerClientEvent("lc_fuel:Notify", source, "success", Utils.translate('jerry_can_paid'):format(Config.JerryCan.price))
|
|
TriggerClientEvent("lc_fuel:closeUI", source, data.fuelAmount, data.selectedFuelType)
|
|
end)
|
|
end)
|
|
|
|
function serverOpenUI(source, isElectric, pumpModel, gasStationId, vehicleFuel, vehicleTankSize, vehiclePlate)
|
|
local stationData = getStationData(gasStationId)
|
|
local discount = getPlayerDiscountAmount(source)
|
|
|
|
local data = {
|
|
pricePerLiter = stationData.pricePerLiter,
|
|
stationStock = stationData.stationStock,
|
|
currentFuelType = getVehicleFuelType(vehiclePlate),
|
|
vehicleFuel = vehicleFuel or 0,
|
|
vehicleTankSize = vehicleTankSize or 100,
|
|
cashBalance = Utils.Framework.getPlayerAccountMoney(source, Config.Accounts.account1),
|
|
bankBalance = Utils.Framework.getPlayerAccountMoney(source, Config.Accounts.account2),
|
|
jerryCan = Config.JerryCan,
|
|
isElectric = isElectric,
|
|
electric = Config.Electric,
|
|
pumpModel = pumpModel,
|
|
}
|
|
|
|
-- Apply the discount to each fuel type price based on player job
|
|
for fuelType, price in pairs(stationData.pricePerLiter) do
|
|
data.pricePerLiter[fuelType] = price * (1 - (discount / 100))
|
|
end
|
|
|
|
TriggerClientEvent("lc_fuel:clientOpenUI", source, data)
|
|
end
|
|
|
|
-----------------------------------------------------------------------------------------------------------------------------------------
|
|
-- Gas Station stock functions
|
|
-----------------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
function getCurrentGasStationId(source)
|
|
if not Config.PlayerOwnedGasStations.enabled then return nil end
|
|
local playerCoords = GetEntityCoords(GetPlayerPed(source))
|
|
for k,v in pairs(Config.PlayerOwnedGasStations.gasStations) do
|
|
if #(v.vector - playerCoords) <= v.radius then
|
|
return k
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
function getStationData(gasStationId)
|
|
local stationData = getStationDataFromConfig()
|
|
if not gasStationId then
|
|
return stationData
|
|
end
|
|
|
|
local sql = "SELECT price, stock, price_plus, stock_plus, price_premium, stock_premium, price_diesel, stock_diesel, price_electricfast, stock_electricfast, price_electricnormal, stock_electricnormal FROM gas_station_business WHERE gas_station_id = @gas_station_id";
|
|
local query = Utils.Database.fetchAll(sql, {['@gas_station_id'] = gasStationId})[1];
|
|
|
|
if not query then
|
|
return stationData
|
|
end
|
|
|
|
local sql = "UPDATE `gas_station_business` SET total_visits = total_visits + 1 WHERE gas_station_id = @gas_station_id";
|
|
Utils.Database.execute(sql, {['@gas_station_id'] = gasStationId});
|
|
|
|
stationData = {
|
|
pricePerLiter = {
|
|
regular = query.price/100,
|
|
plus = query.price_plus/100,
|
|
premium = query.price_premium/100,
|
|
diesel = query.price_diesel/100,
|
|
electricfast = query.price_electricfast/100,
|
|
electricnormal = query.price_electricnormal/100,
|
|
},
|
|
stationStock = {
|
|
regular = query.stock,
|
|
plus = query.stock_plus,
|
|
premium = query.stock_premium,
|
|
diesel = query.stock_diesel,
|
|
electricfast = query.stock_electricfast == 1 and 100 or 0,
|
|
electricnormal = query.stock_electricnormal == 1 and 100 or 0,
|
|
}
|
|
}
|
|
|
|
return stationData
|
|
end
|
|
|
|
function removeStockFromStation(gasStationId, pricePaid, fuelAmount, fuelType, isJerryCan)
|
|
pricePaid = math.floor(pricePaid)
|
|
|
|
if not isFuelTypeValid(fuelType) then
|
|
print("Invalid fuel type: "..(fuelType or "nil"))
|
|
return false
|
|
end
|
|
|
|
-- If not owned
|
|
local stationData = getStationDataFromConfig()
|
|
if not gasStationId then
|
|
if stationData.stationStock[fuelType] >= fuelAmount then
|
|
-- If set in config to unowed gas stations have stock
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
local column = "stock_"..fuelType
|
|
if fuelType == "regular" then
|
|
column = "stock"
|
|
end
|
|
|
|
local sql = "SELECT "..column.." as stock FROM gas_station_business WHERE gas_station_id = @gas_station_id";
|
|
local query = Utils.Database.fetchAll(sql, {['@gas_station_id'] = gasStationId})[1];
|
|
|
|
if not query then
|
|
if stationData.stationStock[fuelType] >= fuelAmount then
|
|
-- If set in config to unowed gas stations have stock
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
if isFuelTypeElectric(fuelType) then
|
|
if query.stock < 1 then
|
|
return false
|
|
end
|
|
|
|
local sql = "UPDATE `gas_station_business` SET customers = customers + 1, money = money + @price, total_money_earned = total_money_earned + @price WHERE gas_station_id = @gas_station_id";
|
|
Utils.Database.execute(sql, {['@gas_station_id'] = gasStationId, ['@price'] = pricePaid, ['@amount'] = fuelAmount});
|
|
|
|
if isJerryCan then
|
|
print("Jerry can in electric charger???")
|
|
return false
|
|
else
|
|
local sql = "INSERT INTO `gas_station_balance` (gas_station_id,income,title,amount,date) VALUES (@gas_station_id,@income,@title,@amount,@date)";
|
|
Utils.Database.execute(sql, {['@gas_station_id'] = gasStationId, ['@income'] = 0, ['@title'] = Utils.translate('owned_gas_stations.balance_electric'):format(fuelAmount), ['@amount'] = pricePaid, ['@date'] = os.time()});
|
|
end
|
|
else
|
|
if query.stock < fuelAmount then
|
|
return false
|
|
end
|
|
|
|
local sql = "UPDATE `gas_station_business` SET "..column.." = @stock, customers = customers + 1, money = money + @price, total_money_earned = total_money_earned + @price, gas_sold = gas_sold + @amount WHERE gas_station_id = @gas_station_id";
|
|
Utils.Database.execute(sql, {['@gas_station_id'] = gasStationId, ['@stock'] = (query.stock - fuelAmount), ['@price'] = pricePaid, ['@amount'] = fuelAmount});
|
|
|
|
if isJerryCan then
|
|
local sql = "INSERT INTO `gas_station_balance` (gas_station_id,income,title,amount,date) VALUES (@gas_station_id,@income,@title,@amount,@date)";
|
|
Utils.Database.execute(sql, {['@gas_station_id'] = gasStationId, ['@income'] = 0, ['@title'] = Utils.translate('owned_gas_stations.balance_jerry_can'):format(fuelAmount), ['@amount'] = pricePaid, ['@date'] = os.time()});
|
|
else
|
|
local sql = "INSERT INTO `gas_station_balance` (gas_station_id,income,title,amount,date) VALUES (@gas_station_id,@income,@title,@amount,@date)";
|
|
Utils.Database.execute(sql, {['@gas_station_id'] = gasStationId, ['@income'] = 0, ['@title'] = Utils.translate('owned_gas_stations.balance_fuel'):format(fuelAmount), ['@amount'] = pricePaid, ['@date'] = os.time()});
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
function returnStockToGasStation(gasStationId, priceRefunded, fuelAmount, fuelType)
|
|
priceRefunded = math.floor(priceRefunded)
|
|
|
|
if not isFuelTypeValid(fuelType) then
|
|
print("Invalid fuel type: "..(fuelType or "nil"))
|
|
return false, 0
|
|
end
|
|
|
|
-- If not owned
|
|
local stationData = getStationDataFromConfig()
|
|
if not gasStationId then
|
|
if stationData.stationStock[fuelType] >= fuelAmount then
|
|
-- If set in config to unowed gas stations have stock
|
|
return true, priceRefunded
|
|
else
|
|
return false, 0
|
|
end
|
|
end
|
|
|
|
local column = "stock_"..fuelType
|
|
if fuelType == "regular" then
|
|
column = "stock"
|
|
end
|
|
|
|
local sql = "SELECT "..column.." as stock, money, total_money_earned, gas_sold FROM gas_station_business WHERE gas_station_id = @gas_station_id";
|
|
local query = Utils.Database.fetchAll(sql, {['@gas_station_id'] = gasStationId})[1];
|
|
|
|
if not query then
|
|
if stationData.stationStock[fuelType] >= fuelAmount then
|
|
-- If set in config to unowed gas stations have stock
|
|
return true, priceRefunded
|
|
else
|
|
return false, 0
|
|
end
|
|
end
|
|
|
|
local actualRefund = 0
|
|
|
|
if isFuelTypeElectric(fuelType) then
|
|
actualRefund = math.min(priceRefunded, query.money)
|
|
|
|
local newMoney = math.max(query.money - actualRefund, 0)
|
|
local newTotalEarned = math.max(query.total_money_earned - actualRefund, 0)
|
|
|
|
local sql = "UPDATE `gas_station_business` SET money = @money, total_money_earned = @total WHERE gas_station_id = @gas_station_id";
|
|
Utils.Database.execute(sql, { ['@gas_station_id'] = gasStationId, ['@money'] = newMoney, ['@total'] = newTotalEarned })
|
|
|
|
local sql = "INSERT INTO `gas_station_balance` (gas_station_id,income,title,amount,date) VALUES (@gas_station_id,@income,@title,@amount,@date)";
|
|
Utils.Database.execute(sql, { ['@gas_station_id'] = gasStationId, ['@income'] = 1, ['@title'] = Utils.translate('owned_gas_stations.refund_electric'):format(fuelAmount), ['@amount'] = actualRefund, ['@date'] = os.time() })
|
|
else
|
|
actualRefund = math.min(priceRefunded, query.money)
|
|
|
|
local newStock = query.stock + fuelAmount
|
|
local newMoney = math.max(query.money - actualRefund, 0)
|
|
local newTotalEarned = math.max(query.total_money_earned - actualRefund, 0)
|
|
local newGasSold = math.max((query.gas_sold or 0) - fuelAmount, 0)
|
|
|
|
local sql = "UPDATE `gas_station_business` SET "..column.." = @stock, money = @money, total_money_earned = @total, gas_sold = @sold WHERE gas_station_id = @gas_station_id";
|
|
Utils.Database.execute(sql, { ['@gas_station_id'] = gasStationId, ['@stock'] = newStock, ['@money'] = newMoney, ['@total'] = newTotalEarned, ['@sold'] = newGasSold })
|
|
|
|
local sql = "INSERT INTO `gas_station_balance` (gas_station_id,income,title,amount,date) VALUES (@gas_station_id,@income,@title,@amount,@date)";
|
|
Utils.Database.execute(sql, { ['@gas_station_id'] = gasStationId, ['@income'] = 1, ['@title'] = Utils.translate('owned_gas_stations.refund_fuel'):format(fuelAmount), ['@amount'] = actualRefund, ['@date'] = os.time() })
|
|
end
|
|
return true, actualRefund
|
|
end
|
|
|
|
-----------------------------------------------------------------------------------------------------------------------------------------
|
|
-- Utils functions
|
|
-----------------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
function getStationDataFromConfig()
|
|
return {
|
|
pricePerLiter = {
|
|
regular = Config.DefaultValues.fuelPrice.regular,
|
|
plus = Config.DefaultValues.fuelPrice.plus,
|
|
premium = Config.DefaultValues.fuelPrice.premium,
|
|
diesel = Config.DefaultValues.fuelPrice.diesel,
|
|
electricfast = Config.Electric.chargeTypes.fast.price,
|
|
electricnormal = Config.Electric.chargeTypes.normal.price,
|
|
},
|
|
stationStock = {
|
|
regular = Config.DefaultValues.fuelStock.regular and 1000 or 0,
|
|
plus = Config.DefaultValues.fuelStock.plus and 1000 or 0,
|
|
premium = Config.DefaultValues.fuelStock.premium and 1000 or 0,
|
|
diesel = Config.DefaultValues.fuelStock.diesel and 1000 or 0,
|
|
electricfast = Config.Electric.chargeTypes.fast.stock and 1000 or 0,
|
|
electricnormal = Config.Electric.chargeTypes.normal.stock and 1000 or 0,
|
|
}
|
|
}
|
|
end
|
|
|
|
function isFuelTypeValid(fuelType)
|
|
return Utils.Table.contains({"regular", "plus", "premium", "diesel", "electricfast", "electricnormal"}, fuelType)
|
|
end
|
|
|
|
function isFuelTypeElectric(fuelType)
|
|
return Utils.Table.contains({"electricnormal", "electricfast"}, fuelType)
|
|
end
|
|
|
|
function isPaymentMethodValid(paymentMethod)
|
|
return Utils.Table.contains({"account1", "account2"}, paymentMethod) -- These are not really the account, but the index to the Config.Accounts
|
|
end
|
|
|
|
function getPlayerDiscountAmount(source)
|
|
local job, onDuty = Utils.Framework.getPlayerJob(source)
|
|
if onDuty and job and Config.JobDiscounts[job] then
|
|
return Config.JobDiscounts[job]
|
|
end
|
|
return 0
|
|
end
|
|
|
|
Utils.Callback.RegisterServerCallback('lc_fuel:getVehicleFuelType', function(source, cb, plate)
|
|
cb(getVehicleFuelType(plate))
|
|
end)
|
|
|
|
RegisterServerEvent("lc_fuel:setVehicleFuelType")
|
|
AddEventHandler("lc_fuel:setVehicleFuelType",function(plate, fuelType)
|
|
setVehicleFuelType(plate, fuelType)
|
|
end)
|
|
|
|
function getVehicleFuelType(plate)
|
|
return playerVehiclesFuelType[plate] or "default"
|
|
end
|
|
|
|
function setVehicleFuelType(plate, fuelType)
|
|
if not isFuelTypeValid(fuelType) then
|
|
print("Invalid fuel type ("..fuelType..") set to vehicle ("..plate..")")
|
|
fuelType = "regular"
|
|
end
|
|
|
|
playerVehiclesFuelType[plate] = fuelType
|
|
-- Only store in database if the vehicle is in player vehicles table
|
|
if Config.SaveAllVehicleFuelTypes == true or (Utils.Framework.getVehicleOwner(Utils.Math.trim(plate)) ~= false or Utils.Framework.getVehicleOwner(plate) ~= false) then
|
|
local sql = [[
|
|
INSERT INTO `player_vehicles_fuel_type` (plate, fuelType)
|
|
VALUES (@plate, @fuelType)
|
|
ON DUPLICATE KEY UPDATE fuelType = @fuelType
|
|
]];
|
|
Utils.Database.execute(sql, {['@plate'] = plate, ['@fuelType'] = fuelType})
|
|
end
|
|
end
|
|
|
|
function cacheplayerVehiclesFuelTypeType()
|
|
local sql = "SELECT * FROM player_vehicles_fuel_type";
|
|
local queryData = Utils.Database.fetchAll(sql, {});
|
|
for _, value in pairs(queryData) do
|
|
playerVehiclesFuelType[value.plate] = value.fuelType
|
|
end
|
|
print("^2[lc_fuel] #"..#queryData.." Fuel types successfully fetched from database^7")
|
|
end
|
|
|
|
function Wrapper(source,cb)
|
|
if utils_outdated then
|
|
TriggerClientEvent("lc_fuel:Notify",source,"error","The script requires 'lc_utils' in version "..utils_required_version..", but you currently have version "..Utils.Version..". Please update your 'lc_utils' script to the latest version: https://github.com/LeonardoSoares98/lc_utils/releases/latest/download/lc_utils.zip")
|
|
return
|
|
end
|
|
|
|
if cooldown[source] == nil then
|
|
cooldown[source] = true
|
|
local user_id = Utils.Framework.getPlayerId(source)
|
|
if user_id then
|
|
cb(user_id)
|
|
else
|
|
print("User not found: "..source)
|
|
end
|
|
SetTimeout(100,function()
|
|
cooldown[source] = nil
|
|
end)
|
|
end
|
|
end
|
|
|
|
|
|
Citizen.CreateThread(function()
|
|
Wait(1000)
|
|
|
|
-- Load version number from file
|
|
local versionFile = LoadResourceFile("lc_fuel", "version")
|
|
if versionFile then
|
|
version = Utils.Math.trim(versionFile)
|
|
print("^2[lc_fuel] Loaded! Support discord: https://discord.gg/U5YDgbh ^3[v"..version..subversion.."]^7")
|
|
else
|
|
error("^1[lc_fuel] Warning: Could not load the version file.^7")
|
|
end
|
|
|
|
checkIfFrameworkWasLoaded()
|
|
checkScriptName()
|
|
|
|
-- Startup queries
|
|
runCreateTableQueries()
|
|
cacheplayerVehiclesFuelTypeType()
|
|
|
|
-- Config checker
|
|
assert(Config.FuelConsumptionPerClass, "^3You have errors in your config file, consider fixing it or redownload the original config.^7")
|
|
|
|
-- Check lc_utils dependency
|
|
assert(GetResourceState('lc_utils') == 'started', "^3The '^1lc_utils^3' file is missing. Please refer to the documentation for installation instructions: ^7https://docs.lixeirocharmoso.com/fuel/installation^7")
|
|
|
|
if Utils.Math.checkIfCurrentVersionisOutdated(utils_required_version, Utils.Version) then
|
|
utils_outdated = true
|
|
error("^3The script requires 'lc_utils' in version ^1"..utils_required_version.."^3, but you currently have version ^1"..Utils.Version.."^3. Please update your 'lc_utils' script to the latest version: https://github.com/LeonardoSoares98/lc_utils/releases/latest/download/lc_utils.zip^7")
|
|
end
|
|
|
|
-- Load langs
|
|
Utils.loadLanguageFile(Lang)
|
|
|
|
-- Config validator
|
|
local configs_to_validate = {
|
|
{ config_path = {"Blips", "onlyShowNearestBlip"}, default_value = false },
|
|
{ config_path = {"ReturnNozzleRefund"}, default_value = true },
|
|
}
|
|
Config = Utils.validateConfig(Config, configs_to_validate)
|
|
|
|
Wait(1000)
|
|
|
|
checkVersion()
|
|
end)
|
|
|
|
function checkIfFrameworkWasLoaded()
|
|
assert(Utils.Framework.getPlayerId, "^3The framework wasn't loaded in the '^1lc_utils^3' resource. Please check if the '^1Config.framework^3' is correctly set to your framework, and make sure there are no errors in your file. For more information, refer to the documentation at '^7https://docs.lixeirocharmoso.com/^3'.^7")
|
|
end
|
|
|
|
function checkScriptName()
|
|
assert(GetCurrentResourceName() == "lc_fuel", "^3The script name does not match the expected resource name. Please ensure that the current resource name is set to '^1lc_fuel^7'.")
|
|
end
|
|
|
|
function runCreateTableQueries()
|
|
Utils.Database.execute([[
|
|
CREATE TABLE IF NOT EXISTS `player_vehicles_fuel_type` (
|
|
`plate` VARCHAR(20) NOT NULL COLLATE 'utf8_general_ci',
|
|
`fuelType` VARCHAR(20) NOT NULL COLLATE 'utf8_general_ci',
|
|
PRIMARY KEY (`plate`) USING BTREE
|
|
)
|
|
COLLATE='utf8_general_ci'
|
|
ENGINE=InnoDB
|
|
;
|
|
]])
|
|
end
|