VPM (Все сообщения пользователя)

QuickDataManager = {}
QuickDataManager.__index = QuickDataManager

-- Конструктор класса
function QuickDataManager:new(firmid, client_code)
    local obj = setmetatable({}, self)
    obj.firmid = firmid
    obj.client_code = client_code
    obj.data = {}  -- Для хранения кэшированных данных
    obj.loaded = {}  -- Для отслеживания загруженных параметров
    return obj
end

-- Функция для ленивой загрузки данных с учетом firmid и client_code
function QuickDataManager:_loadData(param, optional_params)
    -- Формируем уникальный ключ для кэширования (с учетом параметров)
    local cache_key = param .. "_" .. (optional_params or "")
    
    if self.loaded[cache_key] then
        return self.data[cache_key]  -- Возвращаем из кэша
    end

    -- Если данных нет в кэше, загружаем их
    local data
    if param == "money" then
        -- Вызов getMoneyEx для получения информации по деньгам
        data = getMoneyEx(self.firmid, self.client_code, optional_params.tag or "", optional_params.currcode or "", optional_params.limit_kind or 0)
    elseif param == "depo" then
        -- Вызов getDepoEx для получения позиций по инструментам
        data = getDepoEx(self.firmid, self.client_code, optional_params.sec_code or "", optional_params.trdaccid or "", optional_params.limit_kind or 0)
    elseif param == "portfolio" then
        -- Вызов getPortfolioInfoEx для получения информации по клиентскому портфелю
        data = getPortfolioInfoEx(self.firmid, self.client_code, optional_params.limit_kind or 0, optional_params.board_tag or "", optional_params.currency or "")
    elseif param == "buy_sell" then
        -- Вызов getBuySellInfoEx для получения параметров по заявкам
        data = getBuySellInfoEx(self.firmid, self.client_code, optional_params.class_code or "", optional_params.sec_code or "", optional_params.price or 0)
    elseif param == "futures_limit" then
        -- Вызов getFuturesLimit для получения фьючерсных лимитов
        data = getFuturesLimit(self.firmid, optional_params.trdaccid or "", optional_params.limit_type or 0, optional_params.currcode or "")
    elseif param == "futures_holding" then
        -- Вызов getFuturesHolding для получения позиций по фьючерсным счетам
        data = getFuturesHolding(self.firmid, optional_params.trdaccid or "", optional_params.sec_code or "", optional_params.type or 0)
    end
    
    -- Кэшируем загруженные данные
    self.data[cache_key] = data
    self.loaded[cache_key] = true

    return data or {}
end

-- Доступ к данным с ленивой загрузкой
function QuickDataManager:__index(key)
    if key == "money" then
        return self:_loadData("money", {tag = "default", currcode = "USD", limit_kind = 0})
    elseif key == "depo" then
        return self:_loadData("depo", {sec_code = "SBER", trdaccid = "1234", limit_kind = 0})
    elseif key == "portfolio" then
        return self:_loadData("portfolio", {limit_kind = 0, board_tag = "TQBR", currency = "RUB"})
    elseif key == "buy_sell" then
        return self:_loadData("buy_sell", {class_code = "TQBR", sec_code = "SBER", price = 1000})
    elseif key == "futures_limit" then
        return self:_loadData("futures_limit", {trdaccid = "TQBR", limit_type = 0, currcode = "USD"})
    elseif key == "futures_holding" then
        return self:_loadData("futures_holding", {trdaccid = "1234", sec_code = "SBER", type = 0})
    else
        -- Загружать другие параметры по необходимости
        return self:_loadData(key)
    end
end

-- Пример использования
local manager = QuickDataManager:new("Firm1", "Client1")

-- Ленивое обращение к данным
local money = manager.money  -- Получение информации по деньгам
local depo = manager.depo    -- Получение позиций по инструментам
local portfolio = manager.portfolio  -- Получение информации по портфелю
local buy_sell = manager.buy_sell  -- Получение информации по заявкам на покупку/продажу

-- Примеры использования универсальной системы:

-- Глобальный экземпляр
MDP = MarketData_Pro.Manager:new()

-- 1. УНИВЕРСАЛЬНЫЙ ТЕХНИЧЕСКИЙ АНАЛИЗ ДЛЯ ЛЮБЫХ ДАННЫХ

-- Анализ цены последней сделки
local price_analysis = MDP:getOrCreate{
    market = "TQBR",
    ticker = "SBER", 
    interval = INTERVAL_H1,
    param = "last"
}
print("Цена SMA20:", price_analysis:sma(20))
print("Цена RSI14:", price_analysis:rsi(14))

-- Анализ стакана (биды)
local bid_analysis = MDP:getOrCreate{
    market = "TQBR",
    ticker = "SBER",
    interval = INTERVAL_M5, 
    param = "bid"
}
print("Биды EMA10:", bid_analysis:ema(10))
print("Биды STDDEV20:", bid_analysis:getIndicator("STDDEV", 20))

-- Анализ объема
local volume_analysis = MDP:getOrCreate{
    market = "TQBR", 
    ticker = "SBER",
    interval = INTERVAL_M15,
    param = "volume"
}
print("Объем SMA30:", volume_analysis:sma(30))

-- 2. КАСТОМНЫЕ ИНДИКАТОРЫ ДЛЯ ЛЮБЫХ ПАРАМЕТРОВ

-- Регистрация индикатора для спреда
MDP:registerIndicator("SPREAD_EMA", function(buffer, period)
    if buffer.size < period then return nil end
    local sum = 0
    for i = 1, period do
        sum = sum + buffer:last(i).value
    end
    return round(sum / period, 4)
end, "EMA for Spread", {"numeric"})

-- Анализ спреда bid/offer
local spread_data = MDP:getOrCreate{
    market = "TQBR",
    ticker = "SBER", 
    description = "Bid-Offer Spread"
}
-- Здесь можно обновлять буфер вручную с вычисленным спредом
spread_data:updateBuffer("value", 0.15) -- пример спреда

print("Спред EMA10:", spread_data:getIndicator("SPREAD_EMA", 10))

-- 3. УНИВЕРСАЛЬНЫЙ АНАЛИЗ РАЗНЫХ ТИПОВ ДАННЫХ

local analyses = {
    {param = "last", desc = "Price Analysis"},
    {param = "bid", desc = "Bid Analysis"}, 
    {param = "volume", desc = "Volume Analysis"},
    {param = "value", desc = "Value Analysis"}
}

for _, analysis in ipairs(analyses) do
    local data = MDP:getOrCreate{
        market = "TQBR",
        ticker = "GAZP",
        interval = INTERVAL_D1,
        param = analysis.param
    }
    
    local sma = dat a:sma(20)
    local rsi = dat a:rsi(14)
    
    print(string.format("%s - SMA20: %.2f, RSI14: %.1f", 
        analysis.desc, sma or 0, rsi or 0))
end

-- 4. COMPLEX MULTI-PARAMETER ANALYSIS

-- Анализ нескольких параметров одновременно
local multi_analysis = function()
    local price = MDP:getOrCreate{
        market = "TQBR", ticker = "SBER", interval = INTERVAL_H1, param = "last"
    }
    local volume = MDP:getOrCreate{
        market = "TQBR", ticker = "SBER", interval = INTERVAL_H1, param = "volume" 
    }
    local bids = MDP:getOrCreate{
        market = "TQBR", ticker = "SBER", interval = INTERVAL_M5, param = "bid"
    }
    
    local price_trend = price:ema(10) > price:ema(20)
    local volume_spike = volume:sma(5) > volume:sma(20) * 1.5
    local bid_strength = bids:ema(5) > bids:ema(10)
    
    return price_trend and volume_spike and bid_strength
end

-- 5. DYNAMIC INDICATOR CREATION

-- Создание индикатора на лету
local dynamic_indicator = function()
    MDP:registerIndicator("VOLUME_PRICE_RATIO", function(buffer, priceBuffer, period)
        if not priceBuffer or buffer.size < period then return nil end
        
        local volume_avg = 0
        local price_avg = 0
        
        for i = 1, period do
            local vol_item = buffer:last(i)
            local price_item = priceBuffer:last(i)
            if vol_item and price_item then
                volume_avg = volume_avg + vol_item.value
                price_avg = price_avg + price_item.value
            end
        end
        
        volume_avg = volume_avg / period
        price_avg = price_avg / period
        
        return volume_avg / math.max(price_avg, 0.001)
    end, "Volume-Price Ratio", {"volume"})
end

function Trading:allocate_money_for_trading()
    local total_active_capital = self:get_active_capital()  -- Общее количество активных средств
    local total_tickers = self:get_number_of_tickers()      -- Количество активных тикеров
    
    local capital_per_ticker = total_active_capital / total_tickers
    
    -- Для каждого тикера выделяем средства
    for i = 1, total_tickers do
        self:allocate_ticker_capital(i, capital_per_ticker)
    end
end

function Trading:allocate_ticker_capital(ticker_id, amount)
    -- Логика выделения средств для конкретного тикера
    log_info(string.format("Для тикера %d выделено %.2f средств на торговлю.", ticker_id, amount))
    -- Дополнительная логика управления средствами для конкретного тикера...
end

function Trading:allocate_money_based_on_risk()
    local total_active_capital = self:get_active_capital()
    local ticker_risks = self:get_ticker_risks()  -- Структура риска для каждого тикера
    
    -- Распределяем капитал пропорционально рискам
    for i, risk in ipairs(ticker_risks) do
        local capital_for_ticker = self:calculate_risk_adjusted_capital(total_active_capital, risk)
        self:allocate_ticker_capital(i, capital_for_ticker)
    end
end

function Trading:calculate_risk_adjusted_capital(total_capital, risk)
    -- Логика расчета капитала с учетом рисков
    return total_capital * (1 - risk)
end

function Trading:reallocate_capital_based_on_market_conditions()
    local total_active_capital = self:get_active_capital()
    local market_conditions = self:get_market_conditions() -- Получаем текущие рыночные условия
    
    for i, condition in ipairs(market_conditions) do
        if condition == "high_volatility" then
            self:reduce_capital_for_ticker(i)
        elseif condition == "stable_market" then
            self:increase_capital_for_ticker(i)
        end
    end
end

function Trading:reduce_capital_for_ticker(ticker_id)
    -- Логика уменьшения капитала для данного тикера
    log_info(string.format("Уменьшаем капитал для тикера %d из-за высокой волатильности.", ticker_id))
end

function Trading:increase_capital_for_ticker(ticker_id)
    -- Логика увеличения капитала для данного тикера
    log_info(string.format("Увеличиваем капитал для тикера %d из-за стабильного рынка.", ticker_id))
end

function OrderManager:check_timeouts()
    local now = os.time()
    for trans_id, ctx in pairs(self.pool) do
        if ctx.status == "SENT" and now - ctx.timestamp > self.timeout_sec then
            ctx.status = "TIMEOUT"
            log(string.format("[%s] x Таймаут ордера, отправляем отмену", ctx.sec))
            self:cancel(ctx)
        end
    end
end

function OrderManager:cancel(ctx)
    if not ctx.order_num then return end
    local txn = {
        ACCOUNT     = ACCOUNT,
        CLIENT_CODE = CLIENT_CODE,
        CLASSCODE   = ctx.class,
        SECCODE     = ctx.sec,
        ACTION      = "KILL_ORDER",
        ORDER_KEY   = ctx.order_num,
        TRANS_ID    = tostring(math.random(1000000,9999999))
    }
    sendTransaction(txn)
    ctx.status = "CANCELLED"
end

local ctx = {
    sec = "SBER",
    class = "TQBR",
    base_price = nil,
    drop_trigger = 0.002,
    qty = 1
}

local function strategy_tick()
    local price = tonumber(getParamEx(ctx.class, ctx.sec, "LAST").param_value)
    if not price or price <= 0 then return end

    if not ctx.base_price then
        ctx.base_price = price
        return
    end

    local change = (price - ctx.base_price)/ctx.base_price
    if change <= -ctx.drop_trigger then
        OrderManager:send({
            class = ctx.class,
            sec = ctx.sec,
            operation = "B",
            price = price,
            qty = ctx.qty
        })
    elseif change >= ctx.drop_trigger then
        OrderManager:send({
            class = ctx.class,
            sec = ctx.sec,
            operation = "S",
            price = price,
            qty = ctx.qty
        })
    end
end

OrderManager = {
    pool = {},       -- все активные ордера по TRANS_ID
    timeout_sec = 10 -- время ожидания исполнения
}

-- контекст ордера
local order_ctx = {
    trans_id   = "12345", -- уникальный локальный ID
    class      = "TQBR",
    sec        = "SBER",
    operation  = "B",     -- B / S
    price      = 123.45,
    qty        = 1,
    status     = "NEW",   -- NEW / SENT / PARTIALLY_FILLED / FILLED / CANCELLED / REJECTED / TIMEOUT
    order_num  = nil,     -- номер заявки на сервере QUIK
    trades     = {},      -- массив исполненных частей
    timestamp  = os.time()
}

function OrderManager:send(order)
    local trans_id = tostring(math.random(1000000,9999999))
    order.trans_id = trans_id
    order.status = "NEW"
    order.timestamp = os.time()
    self.pool[trans_id] = order

    local txn = {
        ACCOUNT     = ACCOUNT,
        CLIENT_CODE = CLIENT_CODE,
        CLASSCODE   = order.class,
        SECCODE     = order.sec,
        ACTION      = "NEW_ORDER",
        OPERATION   = order.operation,
        PRICE       = tostring(order.price),
        QUANTITY    = tostring(order.qty),
        TYPE        = "L",
        TRANS_ID    = trans_id
    }

    local result = sendTransaction(txn)
    if result ~= "" then
        log(string.format("[%s] x Ошибка отправки: %s", order.sec, result))
        order.status = "REJECTED"
        return false
    else
        order.status = "SENT"
        log(string.format("[%s] v Ордер отправлен (TRANS_ID=%s)", order.sec, trans_id))
        return true
    end
end

function OnTransReply(tr)
    local ctx = OrderManager.pool[tr.trans_id]
    if not ctx then return end

    if tr.status == 3 then
        ctx.order_num = tr.order_num
        log(string.format("[%s] v Ордер принят биржей (order_num=%s)", ctx.sec, ctx.order_num))
    elseif tr.status >= 4 then
        ctx.status = "REJECTED"
        log(string.format("[%s] x Ордер отклонен: %s", ctx.sec, tr.result_msg))
        OrderManager.pool[tr.trans_id] = nil
    end
end

function OnOrder(ord)
    for _, ctx in pairs(OrderManager.pool) do
        if ctx.order_num and ctx.order_num == ord.order_num then
            ctx.balance = ord.balance
            if ctx.balance == 0 then
                ctx.status = "FILLED"
                log(string.format("[%s] v Ордер полностью исполнен", ctx.sec))
            elseif ord.balance < ctx.qty then
                ctx.status = "PARTIALLY_FILLED"
                log(string.format("[%s] v Частичное исполнение: %d/%d", ctx.sec, ctx.qty-ord.balance, ctx.qty))
            end
        end
    end
end

function OnTrade(trade)
    for _, ctx in pairs(OrderManager.pool) do
        if ctx.order_num and ctx.order_num == trade.order_num then
            table.insert(ctx.trades, {
                trade_num = trade.trade_num,
                qty       = trade.qty,
                price     = trade.price,
                dir       = trade.flags % 2 == 0 and "B" or "S"
            })
        end
    end
end