# vRP

## Server

```lua
if Config.Framework ~= 'vrp' then
    return
end

local Tunnel = module("vrp", "lib/Tunnel")
local Proxy = module("vrp", "lib/Proxy")
local vRP = Proxy.getInterface("vRP")
local vRPclient = Tunnel.getInterface("vRP", "axr_octastore")

Framework = {}

---@param identifier integer
---@return boolean
Framework.canAccesMenu = function(identifier)
    if identifier then
        -- your custom functions to open menu (coma status/handcuff etc)
        return true;
    end
    return false;
end

---@param source integer
---@return integer
Framework.getPlayerIdentifier = function(source)
    return vRP.getUserId { source };
end

---@param identifier integer
---@return integer
Framework.getIdentifierSource = function(identifier)
    return vRP.getUserSource { identifier };
end

---@param identifier integer
---@return table (keep the specific format)
Framework.getPlayerIdentity = function(identifier)
    local response = promise.new();
    vRP.getUserIdentity({ identifier, function(identity)
        if identifier then
            response.resolve({
                firstname = identity.firstname,
                secondname = identity.name,
                phone_numner = identity.phoneNumber or 'unknown',
            })
        else
            response.resolve(nil)
        end
    end })
    Citizen.Await(response);
    return response.value;
end

---@param identifier integer
---@param price integer
---@return boolean
Framework.tryPaymentPlan = function(identifier, price)
    if identifier then
        return vRP.tryBankPayment { identifier, price };
    end
    return false;
end


---@param identifier integer
---@param price integer
---@return boolean
Framework.tryPayProductsOnline = function(identifier, price)
    if identifier then
        return vRP.tryBankPayment { identifier, price };
    end
    return false;
end

---@param identifier integer
---@param amount integer
---@return boolean
Framework.paySeller = function(identifier, amount)
    if identifier then
        local sellerSource = Framework.getIdentifierSource(identifier);
        if sellerSource then
            vRP.giveBankMoney({ identifier, amount });
        else
            exports[Config.Sql]:execute('UPDATE vrp_users SET bankMoney = bankMoney + @amount WHERE id = identifier', {
                identifier = identifier,
                amount = amount
            })
        end
    end
end

---@param item string
---@param callback function
Framework.createItem = function(item, callback)
    if Config.Inventory == 'vrp' then
        vRP.defInventoryItem({ Config.item, 'OctaStore Tablet', 'OctaStore Tablet for marketplace', function()
            local choices = {};
            choices['Use'] = function(player, choice)
                local user_id = vRP.getUserId({ player })
                if user_id then
                    callback(user_id);
                end
            end
            return choices;
        end, 0.01 })
    elseif Config.Inventory == 'axr_inventory' then
        exports.axr_inventory:createItem(item, 'OctaStore Tablet', 'OctaStore Tablet for marketplace', 0.01, 'all',
            function(user_id, player, item, itemData)
                callback(user_id);
            end)
    else
        print('ERRROR: Inventory type not found')
    end
end

---@param identifier integer
---@param item string
---@param amount integer?nil
---@return boolean
Framework.hasItem = function(identifier, item, amount)
    if Config.Inventory == 'vrp' then
        if amount ~= nil then
            return (vRP.getInventoryItemAmount({ identifier, item }) >= amount);
        else
            return (vRP.getInventoryItemAmount({ identifier, item }) > 0);
        end
    elseif Config.Inventory == 'axr_inventory' then
        if amount ~= nil then
            return (exports.axr_inventory:getPlayerItemAmount(identifier, item) >= amount);
        else
            return exports.axr_inventory:hasPlayerItem(identifier, item)
        end
    else
        print('ERRROR: Inventory type not found')
    end
    return false;
end


---@param identifier integer
---@return table?nil
Framework.getPlayerItems = function(identifier)
    if Config.Inventory == 'vrp' then
        local data = vRP.getUserDataTable({ identifier })
        if data then
            local inventory = data.inventory;
            local items = {};
            for k, v in pairs(inventory) do
                local amount = vRP.getInventoryItemAmount({ identifier, k })
                if amount > 0 and not Config.blacklistedItems[k] then
                    items[k] = {
                        amount = amount,
                        img = exports.axr_octastore:getItemImagePath(k),
                        name = vRP.getItemName({ k })
                    }
                end
            end
            return items;
        end
    elseif Config.Inventory == 'axr_inventory' then
        local inventory = exports.axr_inventory:getPlayerInventory(identifier);
        local items = {};
        if inventory then
            for k, v in pairs(inventory.backpack) do
                if v and not Config.blacklistedItems[v.item] then
                    items[v.item] = {
                        amount = v.amount,
                        img = exports.axr_octastore:getItemImagePath(v.item),
                        name = v.name
                    }
                end
            end
            for k, v in pairs(inventory.pocket) do
                if v and not Config.blacklistedItems[v.item] then
                    items[v.item] = {
                        amount = v.amount,
                        img = exports.axr_octastore:getItemImagePath(v.item),
                        name = v.name
                    }
                end
            end
            for k, v in pairs(inventory.fastSlots) do
                if v and not Config.blacklistedItems[v.item] then
                    items[v.item] = {
                        amount = v.amount,
                        img = exports.axr_octastore:getItemImagePath(v.istem),
                        name = v.name
                    }
                end
            end
        end
        return items;
    else
        print('ERRROR: Please edit your custom getPlayerItems function (server/framework/vrp.lua)')
    end
end


---@param identifier integer
---@param items table --{index: {name:'',item:'',amount:''}}
---@return boolean
Framework.hasSpaceForItems = function(identifier, items)
    if identifier then
        if Config.Inventory == 'axr_inventory' then
            local userWeight = exports.axr_inventory:getUserWeight(identifier);
            local userMaxWeight = exports.axr_inventory:getUserMaxWeight(identifier);
            local itemsWeight = 0;
            for index, itemData in pairs(items) do
                itemsWeight = itemsWeight + (exports.axr_inventory:getItemWeight(itemData.item) * itemData.amount)
            end

            return (userMaxWeight >= (userWeight + itemsWeight));
        elseif Config.Inventory == 'vrp' then
            local userWeight = vRP.getInventoryWeight({ identifier });
            local userMaxWeight = vRP.getInventoryMaxWeight({ identifier });
            local itemsWeight = 0;
            for index, itemData in pairs(items) do
                itemsWeight = itemsWeight + (vRP.getItemWeight({ itemData.item }) * itemData.amount)
            end

            return (userMaxWeight >= (userWeight + itemsWeight));
        else
            print('ERRROR: Please edit your custom hasSpaceForItems  function (server/framework/vrp.lua)')
        end
    end
end

---@param identifier integer
---@param item string
---@param amount integer
Framework.giveInventoryItem = function(identifier, item, amount)
    if identifier then
        if Config.Inventory == 'axr_inventory' then
            exports.axr_inventory:givePlayerItem(identifier, item, amount, true);
        elseif Config.Inventory == 'vrp' then
            vRP.giveInventoryItem({ identifier, item, amount, true });
        else
            print('ERRROR: Please edit your custom giveInventoryItem  function (server/framework/vrp.lua)')
        end
    end
end

---@param identifier integer
---@param item string
---@param amount integer
Framework.removeInventoryItem = function(identifier, item, amount)
    if identifier then
        if Config.Inventory == 'axr_inventory' then
            exports.axr_inventory:removePlayerItem(identifier, item, amount, true);
        elseif Config.Inventory == 'vrp' then
            vRP.tryGetInventoryItem({ identifier, item, amount, true });
        else
            print('ERRROR: Please edit your custom removeInventoryItem  function (server/framework/vrp.lua)')
        end
    end
end

---@param item string
---@return string
Framework.getItemName = function(item)
    if item then
        if Config.Inventory == 'axr_inventory' then
            return exports.axr_inventory:getItemName(item);
        elseif Config.Inventory == 'vrp' then
            return vRP.getItemName({ item })
        end
    end
    return 'unknown'
end


---@param identifier integer
---@param lockerItems table  --{index: {name:'',item:'',amount:''}}
Framework.giveLockerItems = function(identifier, lockerItems)
    local source = Framework.getIdentifierSource(identifier);
    if identifier and source then
        if Framework.hasSpaceForItems(identifier, lockerItems) then
            for index, itemData in pairs(lockerItems) do
                Framework.giveInventoryItem(identifier, itemData.item, itemData.amount);
            end
            Framework.notify(source, Lang.notify['receive_locker_product'].message,
                Lang.notify['receive_locker_product'].type)
        else
            Framework.notify(source, Lang.notify['no_inventory_weight'].message, Lang.notify['no_inventory_weight'].type)
        end
    end
end


---@param source integer
---@param notify string
---@param type string
Framework.notify = function(source, notify, type)
    if Config.notifySystem == 'vrp' then
        vRPclient.notify(source, { notify, type })
    else
        print('ERRROR: Please edit your custom notify system (server/framework/vrp.lua)')
    end
end


Framework.playerSpawn = function()
    AddEventHandler('vRP:playerSpawn', function(user_id, source, firstSpawn)
        if firstSpawn then
            if exports.axr_octastore:getPlayerPlan(user_id) > 0 then
                exports.axr_octastore:checkPlayerRemaningTimePlan(user_id);
            end
        end
    end)
end

-- Do not remove this line if you want the plans to expire monthly
Framework.playerSpawn();

```

## Client

```lua
if Config.Framework ~= 'vrp' then
    return
end

vRP = Proxy.getInterface("vRP")
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://axero-scripts.gitbook.io/axr-documentation/resources/axr_octastore/functions/vrp.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.