metatrader.hpp

Go to the documentation of this file.

 
 
#pragma once
 
#include <pybind11/chrono.h>
#include <pybind11/numpy.h>
#include <pybind11/pybind11.h>
 
#include <cstdint>
#include <functional>
#include <optional>
#include <string>
#include <tuple>
#include <vector>
 
#include "bbstrader/objects.hpp"
 
namespace py = pybind11;
 
namespace MT5 {
 
using str = const std::string;
 
using VersionInfo = std::tuple<int32_t, int32_t, std::string>;
 
using LastErrorResult = std::tuple<int32_t, std::string>;
 
using DealsData = std::optional<std::vector<TradeDeal>>;
 
using SymbolsData = std::optional<std::vector<SymbolInfo>>;
 
using BookData = std::optional<std::vector<BookInfo>>;
 
using OrdersData = std::optional<std::vector<TradeOrder>>;
 
using PositionsData = std::optional<std::vector<TradePosition>>;
 
using RateInfoType = std::optional<py::array_t<RateInfo>>;
 
using TickInfoType = std::optional<py::array_t<TickInfo>>;
 
using DateTime = std::chrono::system_clock::time_point;
 
// Function Type Definitions (Callbacks/Handlers)
 
using InitializeAuto = std::function<bool()>;
 
using InitializeWithPath = std::function<bool(str&)>;
 
using InitializeFull = std::function<bool(str&, uint64_t, str&, str&, uint32_t, bool)>;
 
using Login = std::function<bool(uint64_t, str&, str&, uint32_t)>;
 
using Shutdown = std::function<void()>;
 
using GetVersion = std::function<std::optional<VersionInfo>()>;
 
using GetLastError = std::function<std::optional<LastErrorResult>()>;
 
using GetTerminalInfo = std::function<std::optional<TerminalInfo>()>;
 
using GetAccountInfo = std::function<std::optional<AccountInfo>()>;
 
using GetSymbolInfo = std::function<std::optional<SymbolInfo>(str&)>;
 
using GetTickInfo = std::function<std::optional<TickInfo>(str&)>;
 
using GetTotalSymbols = std::function<std::optional<int32_t>()>;
 
using GetSymbolsAll = std::function<SymbolsData()>;
 
using SelectSymbol = std::function<bool(str&, bool)>;
 
using GetSymbolsByGroup = std::function<SymbolsData(str&)>;
 
using SubscribeBook = std::function<bool(str&)>;
 
using UnsubscribeBook = std::function<bool(str&)>;
 
using GetBookInfo = std::function<BookData(str&)>;
 
// Rates & Ticks Handlers
 
using GetRatesByDate = std::function<RateInfoType(str&, int32_t, int64_t, int32_t)>;
 
using GetRatesByPos = std::function<RateInfoType(str&, int32_t, int32_t, int32_t)>;
 
using GetRatesByRange = std::function<RateInfoType(str&, int32_t, int64_t, int64_t)>;
 
using GetTicksByDate = std::function<TickInfoType(str&, int64_t, int32_t, int32_t)>;
 
using GetTicksByRange = std::function<TickInfoType(str&, int64_t, int64_t, int32_t)>;
 
 
using GetOrdersAll = std::function<OrdersData()>;
 
using GetOrdersBySymbol = std::function<OrdersData(str&)>;
 
using GetOrdersByGroup = std::function<OrdersData(str&)>;
 
using GetOrderByTicket = std::function<std::optional<TradeOrder>(uint64_t)>;
 
using GetTotalOrders = std::function<std::optional<int32_t>()>;
 
 
using GetPositionsAll = std::function<PositionsData()>;
 
using GetPositionsBySymbol = std::function<PositionsData(str&)>;
 
using GetPositionsByGroup = std::function<PositionsData(str&)>;
 
using GetPositionByTicket = std::function<std::optional<TradePosition>(uint64_t)>;
 
using GetTotalPositions = std::function<std::optional<int32_t>()>;
 
 
// Trading Handlers
 
using CalculateMargin = std::function<std::optional<double>(int32_t, str&, double, double)>;
 
using CalculateProfit = std::function<std::optional<double>(int32_t, str&, double, double, double)>;
 
using CheckOrder = std::function<std::optional<OrderCheckResult>(const TradeRequest&)>;
 
using SendOrder = std::function<std::optional<OrderSentResult>(const TradeRequest&)>;
 
// History Handlers
 
 
using GetHistoryOrdersByRange = std::function<OrdersData(int64_t, int64_t)>;
 
using GetHistoryOrdersByGroup = std::function<OrdersData(int64_t, int64_t, str&)>;
 
using GetHistoryOrderByTicket = std::function<std::optional<TradeOrder>(uint64_t)>;
 
using GetHistoryOrdersByPosId = std::function<OrdersData(uint64_t)>;
 
using GetHistoryOrdersTotal = std::function<std::optional<int32_t>(int64_t, int64_t)>;
 
using GetHistoryDealsByRange = std::function<DealsData(int64_t, int64_t)>;
 
using GetHistoryDealsByGroup = std::function<DealsData(int64_t, int64_t, str&)>;
 
using GetHistoryDealsByTicket = std::function<DealsData(uint64_t)>;
 
using GetHistoryDealsByPosId = std::function<DealsData(uint64_t)>;
 
using GetHistoryDealsTotal = std::function<std::optional<int32_t>(int64_t, int64_t)>;
 
class MetaTraderClient {
   public:
    struct Handlers {
        // System
        InitializeAuto     init_auto;          
        InitializeWithPath init_path;          
        InitializeFull     init_full;          
        Login              login;              
        Shutdown           shutdown;           
        GetVersion         get_version;        
        GetLastError       get_last_error;     
        GetTerminalInfo    get_terminal_info;  
        GetAccountInfo     get_account_info;   
 
        // Symbols
        GetTotalSymbols   get_total_symbols;     
        GetSymbolsAll     get_symbols_all;       
        GetSymbolInfo     get_symbol_info;       
        SelectSymbol      select_symbol;         
        GetSymbolsByGroup get_symbols_by_group;  
 
        // Market Depth
        SubscribeBook   subscribe_book;    
        UnsubscribeBook unsubscribe_book;  
        GetBookInfo     get_book_info;     
 
        // Rates & Ticks
        GetRatesByDate  get_rates_by_date;   
        GetRatesByPos   get_rates_by_pos;    
        GetRatesByRange get_rates_by_range;  
        GetTicksByDate  get_ticks_by_date;   
        GetTicksByRange get_ticks_by_range;  
        GetTickInfo     get_tick_info;       
 
        // Active Orders
        GetOrdersAll      get_orders_all;        
        GetOrdersBySymbol get_orders_by_symbol;  
        GetOrdersByGroup  get_orders_by_group;   
        GetOrderByTicket  get_order_by_ticket;   
        GetTotalOrders    get_total_orders;      
 
        // Active Positions
        GetPositionsAll      get_positions_all;     
        GetPositionsBySymbol get_positions_symbol;  
        GetPositionsByGroup  get_positions_group;   
        GetPositionByTicket  get_position_ticket;   
        GetTotalPositions    get_total_positions;   
 
        // Trading
        CheckOrder      check_order;  
        SendOrder       send_order;   
        CalculateMargin calc_margin;  
        CalculateProfit calc_profit;  
 
        // History Orders
        GetHistoryOrdersByRange get_hist_orders_range;  
        GetHistoryOrdersByGroup get_hist_orders_group;  
        GetHistoryOrderByTicket get_hist_order_ticket;  
        GetHistoryOrdersByPosId get_hist_orders_pos;  
        GetHistoryOrdersTotal   get_hist_orders_total;  
 
        // History Deals
        GetHistoryDealsByRange  get_hist_deals_range;   
        GetHistoryDealsByGroup  get_hist_deals_group;   
        GetHistoryDealsByTicket get_hist_deals_ticket;  
        GetHistoryDealsByPosId  get_hist_deals_pos;    
        GetHistoryDealsTotal    get_hist_deals_total;  
    };
 
    MetaTraderClient()                                   = delete;
    MetaTraderClient(const MetaTraderClient&)            = delete;
    MetaTraderClient& operator=(const MetaTraderClient&) = delete;
 
    virtual ~MetaTraderClient() = default;
 
    explicit MetaTraderClient(Handlers handlers) : this_handlers(std::move(handlers)) {}
 
    // System Methods
 
    [[nodiscard]] virtual auto initialize() -> bool {
        return this_handlers.init_auto ? this_handlers.init_auto() : false;
    }
 
    [[nodiscard]] virtual auto initialize(str& path) -> bool {
        return this_handlers.init_path ? this_handlers.init_path(path) : false;
    }
 
    [[nodiscard]] virtual auto initialize(
        str& path, uint64_t account, str& pw, str& srv, uint32_t timeout, bool portable
    ) -> bool {
        return this_handlers.init_full
                   ? this_handlers.init_full(path, account, pw, srv, timeout, portable)
                   : false;
    }
 
    [[nodiscard]] virtual auto login(uint64_t account, str& pw, str& srv, uint32_t timeout) -> bool {
        return this_handlers.login ? this_handlers.login(account, pw, srv, timeout) : false;
    }
 
    virtual auto shutdown() noexcept -> void {
        if (this_handlers.shutdown)
            this_handlers.shutdown();
    }
 
    [[nodiscard]] virtual auto version() -> std::optional<VersionInfo> {
        return this_handlers.get_version ? this_handlers.get_version() : std::nullopt;
    }
 
    [[nodiscard]] virtual auto last_error() -> std::optional<LastErrorResult> {
        return this_handlers.get_last_error ? this_handlers.get_last_error()
                                            : std::make_tuple(-1, std::string("fail"));
    }
 
    [[nodiscard]] virtual auto terminal_info() -> std::optional<TerminalInfo> {
        return this_handlers.get_terminal_info ? this_handlers.get_terminal_info() : std::nullopt;
    }
 
    [[nodiscard]] virtual auto account_info() -> std::optional<AccountInfo> {
        return this_handlers.get_account_info ? this_handlers.get_account_info() : std::nullopt;
    }
 
    // Symbol Methods
 
    [[nodiscard]] virtual auto symbols_total() -> std::optional<int32_t> {
        return this_handlers.get_total_symbols ? this_handlers.get_total_symbols() : std::nullopt;
    }
 
    [[nodiscard]] virtual auto symbols_get() -> SymbolsData {
        return this_handlers.get_symbols_all ? this_handlers.get_symbols_all() : std::nullopt;
    }
 
    [[nodiscard]] virtual auto symbols_get(str& group) -> SymbolsData {
        return this_handlers.get_symbols_by_group ? this_handlers.get_symbols_by_group(group)
                                                  : std::nullopt;
    }
 
    [[nodiscard]] virtual auto symbol_info(str& symbol) -> std::optional<SymbolInfo> {
        return this_handlers.get_symbol_info ? this_handlers.get_symbol_info(symbol) : std::nullopt;
    }
 
    [[nodiscard]] virtual auto symbol_select(str& symbol, bool enable) -> bool {
        return this_handlers.select_symbol ? this_handlers.select_symbol(symbol, enable) : false;
    }
 
    [[nodiscard]] virtual auto symbol_info_tick(str& symbol) -> std::optional<TickInfo> {
        return this_handlers.get_tick_info ? this_handlers.get_tick_info(symbol) : std::nullopt;
    }
 
    // Market Depth Methods
 
    [[nodiscard]] virtual auto market_book_add(str& symbol) -> bool {
        return this_handlers.subscribe_book ? this_handlers.subscribe_book(symbol) : false;
    }
 
    [[nodiscard]] virtual auto market_book_release(str& symbol) -> bool {
        return this_handlers.unsubscribe_book ? this_handlers.unsubscribe_book(symbol) : false;
    }
 
    [[nodiscard]] virtual auto market_book_get(str& symbol) -> BookData {
        return this_handlers.get_book_info ? this_handlers.get_book_info(symbol) : std::nullopt;
    }
 
    // Market Data (Copy Rates/Ticks) Methods
 
    [[nodiscard]] virtual auto copy_rates_from(str& s, int32_t t, DateTime from, int32_t count) -> RateInfoType {
        auto from_ts = static_cast<int64_t>(std::chrono::system_clock::to_time_t(from));
        return copy_rates_from(s, t, from_ts, count);
    }
 
    [[nodiscard]] virtual auto copy_rates_from(str& s, int32_t t, int64_t from, int32_t count) -> RateInfoType {
        return this_handlers.get_rates_by_date ? this_handlers.get_rates_by_date(s, t, from, count)
                                               : py::array_t<RateInfo>();
    }
 
    [[nodiscard]] virtual auto copy_rates_from_pos(str& s, int32_t t, int32_t start, int32_t count)
        -> RateInfoType {
        return this_handlers.get_rates_by_pos ? this_handlers.get_rates_by_pos(s, t, start, count)
                                              : py::array_t<RateInfo>();
    }
 
    [[nodiscard]] virtual auto copy_rates_range(str& s, int32_t t, DateTime from, DateTime to) -> RateInfoType {
        auto from_ts = static_cast<int64_t>(std::chrono::system_clock::to_time_t(from));
        auto to_ts   = static_cast<int64_t>(std::chrono::system_clock::to_time_t(to));
        return copy_rates_range(s, t, from_ts, to_ts);
    }
 
    [[nodiscard]] virtual auto copy_rates_range(str& s, int32_t t, int64_t from, int64_t to) -> RateInfoType {
        return this_handlers.get_rates_by_range ? this_handlers.get_rates_by_range(s, t, from, to)
                                                : py::array_t<RateInfo>();
    }
 
    [[nodiscard]] virtual auto copy_ticks_from(str& s, DateTime from, int32_t count, int32_t flags)
        -> TickInfoType {
        auto from_ts = static_cast<int64_t>(std::chrono::system_clock::to_time_t(from));
        return copy_ticks_from(s, from_ts, count, flags);
    }
 
    [[nodiscard]] virtual auto copy_ticks_from(str& s, int64_t from, int32_t count, int32_t flags)
        -> TickInfoType {
        return this_handlers.get_ticks_by_date
                   ? this_handlers.get_ticks_by_date(s, from, count, flags)
                   : py::array_t<TickInfo>();
    }
 
    [[nodiscard]] virtual auto copy_ticks_range(str& s, DateTime from, DateTime to, int32_t flags)
        -> TickInfoType {
        auto from_ts = static_cast<int64_t>(std::chrono::system_clock::to_time_t(from));
        auto to_ts   = static_cast<int64_t>(std::chrono::system_clock::to_time_t(to));
        return copy_ticks_range(s, from_ts, to_ts, flags);
    }
 
    [[nodiscard]] virtual auto copy_ticks_range(str& s, int64_t from, int64_t to, int32_t flags) -> TickInfoType {
        return this_handlers.get_ticks_by_range
                   ? this_handlers.get_ticks_by_range(s, from, to, flags)
                   : py::array_t<TickInfo>();
    }
 
    // Active Order Methods
 
    [[nodiscard]] virtual auto orders_get() -> OrdersData {
        return this_handlers.get_orders_all ? this_handlers.get_orders_all() : std::nullopt;
    }
 
    [[nodiscard]] virtual auto orders_get(str& symbol) -> OrdersData {
        return this_handlers.get_orders_by_symbol ? this_handlers.get_orders_by_symbol(symbol)
                                                  : std::nullopt;
    }
 
    [[nodiscard]] virtual auto orders_get_by_group(str& group) -> OrdersData {
        return this_handlers.get_orders_by_group ? this_handlers.get_orders_by_group(group)
                                                 : std::nullopt;
    }
 
    [[nodiscard]] virtual auto order_get_by_ticket(uint64_t ticket) -> std::optional<TradeOrder> {
        return this_handlers.get_order_by_ticket ? this_handlers.get_order_by_ticket(ticket)
                                                 : std::nullopt;
    }
 
    [[nodiscard]] virtual auto orders_total() -> std::optional<int32_t> {
        return this_handlers.get_total_orders ? this_handlers.get_total_orders() : std::nullopt;
    }
 
    // Active Position Methods
 
    [[nodiscard]] virtual auto positions_get() -> PositionsData {
        return this_handlers.get_positions_all ? this_handlers.get_positions_all() : std::nullopt;
    }
 
    [[nodiscard]] virtual auto positions_get(str& symbol) -> PositionsData {
        return this_handlers.get_positions_symbol ? this_handlers.get_positions_symbol(symbol)
                                                  : std::nullopt;
    }
 
    [[nodiscard]] virtual auto positions_get_by_group(str& group) -> PositionsData {
        return this_handlers.get_positions_group ? this_handlers.get_positions_group(group)
                                                 : std::nullopt;
    }
 
    [[nodiscard]] virtual auto position_get_by_ticket(uint64_t ticket) -> std::optional<TradePosition> {
        return this_handlers.get_position_ticket ? this_handlers.get_position_ticket(ticket)
                                                 : std::nullopt;
    }
 
    [[nodiscard]] virtual auto positions_total() -> std::optional<int32_t> {
        return this_handlers.get_total_positions ? this_handlers.get_total_positions() : std::nullopt;
    }
 
    // Trading Methods
 
    [[nodiscard]] virtual auto order_check(const py::dict& dict) -> std::optional<OrderCheckResult> {
        return order_check(dict.cast<TradeRequest>());
    }
 
    [[nodiscard]] virtual auto order_check(const TradeRequest& req) -> std::optional<OrderCheckResult> {
        return this_handlers.check_order ? this_handlers.check_order(req) : std::nullopt;
    }
 
    [[nodiscard]] virtual auto order_send(const py::dict& dict) -> std::optional<OrderSentResult> {
        return order_send(dict.cast<TradeRequest>());
    }
 
    [[nodiscard]] virtual auto order_send(const TradeRequest& req) -> std::optional<OrderSentResult> {
        return this_handlers.send_order ? this_handlers.send_order(req) : std::nullopt;
    }
 
    [[nodiscard]] virtual auto order_calc_margin(int32_t action, str& sym, double vol, double prc)
        -> std::optional<double> {
        return this_handlers.calc_margin ? this_handlers.calc_margin(action, sym, vol, prc)
                                         : std::nullopt;
    }
 
    [[nodiscard]] virtual auto order_calc_profit(int32_t action, str& sym, double vol, double open, double close)
        -> std::optional<double> {
        return this_handlers.calc_profit ? this_handlers.calc_profit(action, sym, vol, open, close)
                                         : std::nullopt;
    }
 
    // History Order Methods
 
    [[nodiscard]] virtual auto history_orders_get(int64_t from, int64_t to, str& group) -> OrdersData {
        return this_handlers.get_hist_orders_group
                   ? this_handlers.get_hist_orders_group(from, to, group)
                   : std::nullopt;
    }
 
    [[nodiscard]] virtual auto history_orders_get(DateTime from, DateTime to, str& group) -> OrdersData {
        auto from_ts = static_cast<int64_t>(std::chrono::system_clock::to_time_t(from));
        auto to_ts   = static_cast<int64_t>(std::chrono::system_clock::to_time_t(to));
        return history_orders_get(from_ts, to_ts, group);
    }
 
    [[nodiscard]] virtual auto history_orders_get(int64_t from, int64_t to) -> OrdersData {
        return this_handlers.get_hist_orders_range ? this_handlers.get_hist_orders_range(from, to)
                                                   : std::nullopt;
    }
 
    [[nodiscard]] virtual auto history_orders_get(DateTime from, DateTime to) -> OrdersData {
        auto from_ts = static_cast<int64_t>(std::chrono::system_clock::to_time_t(from));
        auto to_ts   = static_cast<int64_t>(std::chrono::system_clock::to_time_t(to));
        return history_orders_get(from_ts, to_ts);
    }
 
    [[nodiscard]] virtual auto history_orders_get(uint64_t ticket) -> std::optional<TradeOrder> {
        return this_handlers.get_hist_order_ticket ? this_handlers.get_hist_order_ticket(ticket)
                                                   : std::nullopt;
    }
 
    [[nodiscard]] virtual auto history_orders_get_by_pos(uint64_t pos_id) -> OrdersData {
        return this_handlers.get_hist_orders_pos ? this_handlers.get_hist_orders_pos(pos_id)
                                                 : std::nullopt;
    }
 
    [[nodiscard]] virtual auto history_orders_total(int64_t from, int64_t to) -> std::optional<int32_t> {
        return this_handlers.get_hist_orders_total ? this_handlers.get_hist_orders_total(from, to)
                                                   : std::nullopt;
    }
 
    [[nodiscard]] virtual auto history_orders_total(DateTime from, DateTime to) -> std::optional<int32_t> {
        auto from_ts = static_cast<int64_t>(std::chrono::system_clock::to_time_t(from));
        auto to_ts   = static_cast<int64_t>(std::chrono::system_clock::to_time_t(to));
        return history_orders_total(from_ts, to_ts);
    }
 
    // History Deal Methods
 
    [[nodiscard]] virtual auto history_deals_get(int64_t from, int64_t to, str& group) -> DealsData {
        return this_handlers.get_hist_deals_group
                   ? this_handlers.get_hist_deals_group(from, to, group)
                   : std::nullopt;
    }
 
    [[nodiscard]] virtual auto history_deals_get(int64_t from, int64_t to) -> DealsData {
        return this_handlers.get_hist_deals_range ? this_handlers.get_hist_deals_range(from, to)
                                                  : std::nullopt;
    }
 
    [[nodiscard]] virtual auto history_deals_get(DateTime from, DateTime to, str& group) -> DealsData {
        auto from_ts = static_cast<int64_t>(std::chrono::system_clock::to_time_t(from));
        auto to_ts   = static_cast<int64_t>(std::chrono::system_clock::to_time_t(to));
        return history_deals_get(from_ts, to_ts, group);
    }
 
    [[nodiscard]] virtual auto history_deals_get(DateTime from, DateTime to) -> DealsData {
        auto from_ts = static_cast<int64_t>(std::chrono::system_clock::to_time_t(from));
        auto to_ts   = static_cast<int64_t>(std::chrono::system_clock::to_time_t(to));
        return history_deals_get(from_ts, to_ts);
    }
 
    [[nodiscard]] virtual auto history_deals_get(uint64_t ticket) -> DealsData {
        return this_handlers.get_hist_deals_ticket ? this_handlers.get_hist_deals_ticket(ticket)
                                                   : std::nullopt;
    }
 
    [[nodiscard]] virtual auto history_deals_get_by_pos(uint64_t pos_id) -> DealsData {
        return this_handlers.get_hist_deals_pos ? this_handlers.get_hist_deals_pos(pos_id)
                                                : std::nullopt;
    }
 
    [[nodiscard]] virtual auto history_deals_total(int64_t from, int64_t to) -> std::optional<int32_t> {
        return this_handlers.get_hist_deals_total ? this_handlers.get_hist_deals_total(from, to)
                                                  : std::nullopt;
    }
 
    [[nodiscard]] virtual auto history_deals_total(DateTime from, DateTime to) -> std::optional<int32_t> {
        auto from_ts = static_cast<int64_t>(std::chrono::system_clock::to_time_t(from));
        auto to_ts   = static_cast<int64_t>(std::chrono::system_clock::to_time_t(to));
        return history_deals_total(from_ts, to_ts);
    }
 
   private:
    Handlers this_handlers;  
};
 
}  // namespace MT5