727 lines
24 KiB
MQL5
727 lines
24 KiB
MQL5
|
//+------------------------------------------------------------------+
|
||
|
|
//| TradeExecutor.mqh v1.0 |
|
||
|
|
//| Centralized Trade Execution Engine |
|
||
|
|
//| Optimized with retry logic and error handling |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
#ifndef TRADE_EXECUTOR_MQH
|
||
|
|
#define TRADE_EXECUTOR_MQH
|
||
|
|
|
||
|
|
#include "DataTypes.mqh"
|
||
|
|
#include "SymbolManager.mqh"
|
||
|
|
#include <Trade/Trade.mqh>
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Trade execution result structure |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
struct ExecutionResult
|
||
|
|
{
|
||
|
|
bool success;
|
||
|
|
ulong ticket;
|
||
|
|
double executed_price;
|
||
|
|
double executed_volume;
|
||
|
|
double slippage;
|
||
|
|
int error_code;
|
||
|
|
string error_message;
|
||
|
|
int retries;
|
||
|
|
datetime execution_time;
|
||
|
|
int execution_ms;
|
||
|
|
};
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Trade Executor Class |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
class CTradeExecutor
|
||
|
|
{
|
||
|
|
private:
|
||
|
|
//--- Configuration
|
||
|
|
int m_magic_number;
|
||
|
|
int m_max_slippage;
|
||
|
|
int m_max_retries;
|
||
|
|
int m_retry_delay_ms;
|
||
|
|
bool m_async_mode;
|
||
|
|
|
||
|
|
//--- Trade object
|
||
|
|
CTrade m_trade;
|
||
|
|
|
||
|
|
//--- Symbol manager reference
|
||
|
|
CSymbolManager *m_symbol_manager;
|
||
|
|
|
||
|
|
//--- Statistics
|
||
|
|
int m_trades_executed;
|
||
|
|
int m_trades_failed;
|
||
|
|
double m_total_slippage;
|
||
|
|
int m_total_retries;
|
||
|
|
|
||
|
|
//--- Error handling
|
||
|
|
int m_last_error;
|
||
|
|
string m_last_error_message;
|
||
|
|
|
||
|
|
//--- Helper methods
|
||
|
|
bool PrepareTradeRequest(MqlTradeRequest &request, const TradeRequest &trade_req);
|
||
|
|
bool ValidateTradeRequest(const MqlTradeRequest &request);
|
||
|
|
ExecutionResult ExecuteWithRetry(MqlTradeRequest &request);
|
||
|
|
void HandleTradeError(int error_code, MqlTradeRequest &request);
|
||
|
|
double CalculateSlippage(double requested_price, double executed_price, string symbol);
|
||
|
|
void LogExecution(const ExecutionResult &result, const MqlTradeRequest &request);
|
||
|
|
bool WaitForExecution(ulong order_ticket, int timeout_ms = 5000);
|
||
|
|
|
||
|
|
public:
|
||
|
|
CTradeExecutor();
|
||
|
|
~CTradeExecutor();
|
||
|
|
|
||
|
|
//--- Initialization
|
||
|
|
bool Initialize(int magic_number, int max_slippage = 10);
|
||
|
|
void SetSymbolManager(CSymbolManager *manager) { m_symbol_manager = manager; }
|
||
|
|
|
||
|
|
//--- Configuration
|
||
|
|
void SetMaxRetries(int retries) { m_max_retries = retries; }
|
||
|
|
void SetRetryDelay(int delay_ms) { m_retry_delay_ms = delay_ms; }
|
||
|
|
void SetAsyncMode(bool async) { m_async_mode = async; }
|
||
|
|
|
||
|
|
//--- Trade execution
|
||
|
|
ExecutionResult OpenPosition(const TradeRequest &request);
|
||
|
|
ExecutionResult ClosePosition(ulong ticket, double volume = 0, string comment = "");
|
||
|
|
ExecutionResult ClosePositionBySymbol(string symbol, ENUM_POSITION_TYPE type = -1);
|
||
|
|
ExecutionResult ModifyPosition(ulong ticket, double sl, double tp);
|
||
|
|
|
||
|
|
//--- Batch operations
|
||
|
|
int CloseAllPositions(int magic = -1);
|
||
|
|
int CloseAllBySymbol(string symbol);
|
||
|
|
int CloseAllProfitable();
|
||
|
|
int CloseAllLosing();
|
||
|
|
|
||
|
|
//--- Pending orders
|
||
|
|
ExecutionResult PlacePendingOrder(const TradeRequest &request);
|
||
|
|
ExecutionResult DeletePendingOrder(ulong ticket);
|
||
|
|
ExecutionResult ModifyPendingOrder(ulong ticket, double price, double sl, double tp);
|
||
|
|
|
||
|
|
//--- Utility functions
|
||
|
|
bool IsTradeAllowed();
|
||
|
|
double GetMaxVolume(string symbol);
|
||
|
|
double GetMinVolume(string symbol);
|
||
|
|
bool CheckMarginForTrade(string symbol, ENUM_ORDER_TYPE type, double volume);
|
||
|
|
|
||
|
|
//--- Statistics
|
||
|
|
int GetTradesExecuted() { return m_trades_executed; }
|
||
|
|
int GetTradesFailed() { return m_trades_failed; }
|
||
|
|
double GetAverageSlippage() { return (m_trades_executed > 0) ? m_total_slippage / m_trades_executed : 0; }
|
||
|
|
double GetSuccessRate() { return (m_trades_executed + m_trades_failed > 0) ?
|
||
|
|
(double)m_trades_executed / (m_trades_executed + m_trades_failed) * 100 : 0; }
|
||
|
|
|
||
|
|
//--- Error handling
|
||
|
|
int GetLastError() { return m_last_error; }
|
||
|
|
string GetLastErrorMessage() { return m_last_error_message; }
|
||
|
|
};
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Constructor |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
CTradeExecutor::CTradeExecutor()
|
||
|
|
{
|
||
|
|
m_magic_number = 0;
|
||
|
|
m_max_slippage = 10;
|
||
|
|
m_max_retries = 3;
|
||
|
|
m_retry_delay_ms = 500;
|
||
|
|
m_async_mode = false;
|
||
|
|
|
||
|
|
m_trades_executed = 0;
|
||
|
|
m_trades_failed = 0;
|
||
|
|
m_total_slippage = 0;
|
||
|
|
m_total_retries = 0;
|
||
|
|
|
||
|
|
m_last_error = 0;
|
||
|
|
m_last_error_message = "";
|
||
|
|
|
||
|
|
m_symbol_manager = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Destructor |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
CTradeExecutor::~CTradeExecutor()
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Initialize executor |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool CTradeExecutor::Initialize(int magic_number, int max_slippage)
|
||
|
|
{
|
||
|
|
m_magic_number = magic_number;
|
||
|
|
m_max_slippage = max_slippage;
|
||
|
|
|
||
|
|
//--- Configure trade object
|
||
|
|
m_trade.SetExpertMagicNumber(magic_number);
|
||
|
|
m_trade.SetDeviationInPoints(max_slippage);
|
||
|
|
m_trade.SetTypeFilling(ORDER_FILLING_RETURN);
|
||
|
|
m_trade.SetAsyncMode(m_async_mode);
|
||
|
|
|
||
|
|
//--- Get symbol manager instance
|
||
|
|
if(m_symbol_manager == NULL)
|
||
|
|
m_symbol_manager = CSymbolManager::GetInstance();
|
||
|
|
|
||
|
|
Print("TradeExecutor initialized: Magic=", magic_number,
|
||
|
|
", MaxSlippage=", max_slippage, " points");
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Open new position with full error handling |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
ExecutionResult CTradeExecutor::OpenPosition(const TradeRequest &request)
|
||
|
|
{
|
||
|
|
ExecutionResult result;
|
||
|
|
ZeroMemory(result);
|
||
|
|
|
||
|
|
datetime start_time = GetTickCount();
|
||
|
|
|
||
|
|
//--- Check if trading allowed
|
||
|
|
if(!IsTradeAllowed())
|
||
|
|
{
|
||
|
|
result.success = false;
|
||
|
|
result.error_code = ERR_TRADE_NOT_ALLOWED;
|
||
|
|
result.error_message = "Trading not allowed";
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
//--- Prepare MQL trade request
|
||
|
|
MqlTradeRequest mql_request;
|
||
|
|
if(!PrepareTradeRequest(mql_request, request))
|
||
|
|
{
|
||
|
|
result.success = false;
|
||
|
|
result.error_code = m_last_error;
|
||
|
|
result.error_message = m_last_error_message;
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
//--- Validate request
|
||
|
|
if(!ValidateTradeRequest(mql_request))
|
||
|
|
{
|
||
|
|
result.success = false;
|
||
|
|
result.error_code = m_last_error;
|
||
|
|
result.error_message = m_last_error_message;
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
//--- Execute with retry logic
|
||
|
|
result = ExecuteWithRetry(mql_request);
|
||
|
|
|
||
|
|
//--- Calculate execution time
|
||
|
|
result.execution_ms = (int)(GetTickCount() - start_time);
|
||
|
|
|
||
|
|
//--- Update statistics
|
||
|
|
if(result.success)
|
||
|
|
{
|
||
|
|
m_trades_executed++;
|
||
|
|
m_total_slippage += result.slippage;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_trades_failed++;
|
||
|
|
}
|
||
|
|
|
||
|
|
m_total_retries += result.retries;
|
||
|
|
|
||
|
|
//--- Log execution
|
||
|
|
LogExecution(result, mql_request);
|
||
|
|
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Prepare trade request |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool CTradeExecutor::PrepareTradeRequest(MqlTradeRequest &request, const TradeRequest &trade_req)
|
||
|
|
{
|
||
|
|
ZeroMemory(request);
|
||
|
|
|
||
|
|
//--- Get symbol info
|
||
|
|
if(m_symbol_manager == NULL)
|
||
|
|
{
|
||
|
|
m_last_error = ERR_INVALID_POINTER;
|
||
|
|
m_last_error_message = "Symbol manager not initialized";
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
SymbolCacheEntry symbol_info;
|
||
|
|
if(!m_symbol_manager.GetSymbolInfo(trade_req.symbol, symbol_info))
|
||
|
|
{
|
||
|
|
m_last_error = ERR_UNKNOWN_SYMBOL;
|
||
|
|
m_last_error_message = "Invalid symbol: " + trade_req.symbol;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
//--- Basic parameters
|
||
|
|
request.action = TRADE_ACTION_DEAL;
|
||
|
|
request.symbol = trade_req.symbol;
|
||
|
|
request.volume = m_symbol_manager.NormalizeLots(trade_req.symbol, trade_req.volume);
|
||
|
|
request.type = trade_req.type;
|
||
|
|
request.type_filling = ORDER_FILLING_RETURN;
|
||
|
|
request.magic = m_magic_number;
|
||
|
|
request.comment = trade_req.comment;
|
||
|
|
request.deviation = m_max_slippage;
|
||
|
|
|
||
|
|
//--- Get current price
|
||
|
|
if(trade_req.type == ORDER_TYPE_BUY)
|
||
|
|
{
|
||
|
|
request.price = m_symbol_manager.GetCurrentAsk(trade_req.symbol);
|
||
|
|
|
||
|
|
if(trade_req.sl_distance > 0)
|
||
|
|
request.sl = m_symbol_manager.NormalizePrice(trade_req.symbol,
|
||
|
|
request.price - trade_req.sl_distance);
|
||
|
|
if(trade_req.tp_distance > 0)
|
||
|
|
request.tp = m_symbol_manager.NormalizePrice(trade_req.symbol,
|
||
|
|
request.price + trade_req.tp_distance);
|
||
|
|
}
|
||
|
|
else if(trade_req.type == ORDER_TYPE_SELL)
|
||
|
|
{
|
||
|
|
request.price = m_symbol_manager.GetCurrentBid(trade_req.symbol);
|
||
|
|
|
||
|
|
if(trade_req.sl_distance > 0)
|
||
|
|
request.sl = m_symbol_manager.NormalizePrice(trade_req.symbol,
|
||
|
|
request.price + trade_req.sl_distance);
|
||
|
|
if(trade_req.tp_distance > 0)
|
||
|
|
request.tp = m_symbol_manager.NormalizePrice(trade_req.symbol,
|
||
|
|
request.price - trade_req.tp_distance);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_last_error = ERR_INVALID_ORDER_TYPE;
|
||
|
|
m_last_error_message = "Invalid order type";
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Validate trade request |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool CTradeExecutor::ValidateTradeRequest(const MqlTradeRequest &request)
|
||
|
|
{
|
||
|
|
//--- Check volume
|
||
|
|
double min_lot = m_symbol_manager.GetMinLot(request.symbol);
|
||
|
|
double max_lot = m_symbol_manager.GetMaxLot(request.symbol);
|
||
|
|
|
||
|
|
if(request.volume < min_lot || request.volume > max_lot)
|
||
|
|
{
|
||
|
|
m_last_error = ERR_INVALID_VOLUME;
|
||
|
|
m_last_error_message = StringFormat("Invalid volume: %.2f (min: %.2f, max: %.2f)",
|
||
|
|
request.volume, min_lot, max_lot);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
//--- Check stop levels
|
||
|
|
if(!m_symbol_manager.ValidateStopLevels(request.symbol, request.price, request.sl, request.tp))
|
||
|
|
{
|
||
|
|
m_last_error = ERR_INVALID_STOPS;
|
||
|
|
m_last_error_message = "Invalid stop levels";
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
//--- Check margin
|
||
|
|
if(!CheckMarginForTrade(request.symbol, request.type, request.volume))
|
||
|
|
{
|
||
|
|
m_last_error = ERR_NOT_ENOUGH_MONEY;
|
||
|
|
m_last_error_message = "Insufficient margin";
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Execute trade with retry logic |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
ExecutionResult CTradeExecutor::ExecuteWithRetry(MqlTradeRequest &request)
|
||
|
|
{
|
||
|
|
ExecutionResult result;
|
||
|
|
ZeroMemory(result);
|
||
|
|
|
||
|
|
MqlTradeResult trade_result;
|
||
|
|
|
||
|
|
for(int retry = 0; retry <= m_max_retries; retry++)
|
||
|
|
{
|
||
|
|
result.retries = retry;
|
||
|
|
|
||
|
|
//--- Refresh price before each attempt
|
||
|
|
if(retry > 0)
|
||
|
|
{
|
||
|
|
if(request.type == ORDER_TYPE_BUY)
|
||
|
|
request.price = m_symbol_manager.GetCurrentAsk(request.symbol);
|
||
|
|
else
|
||
|
|
request.price = m_symbol_manager.GetCurrentBid(request.symbol);
|
||
|
|
|
||
|
|
Sleep(m_retry_delay_ms);
|
||
|
|
}
|
||
|
|
|
||
|
|
//--- Send order
|
||
|
|
ResetLastError();
|
||
|
|
|
||
|
|
if(OrderSend(request, trade_result))
|
||
|
|
{
|
||
|
|
result.success = true;
|
||
|
|
result.ticket = trade_result.order;
|
||
|
|
result.executed_price = trade_result.price;
|
||
|
|
result.executed_volume = trade_result.volume;
|
||
|
|
result.execution_time = TimeCurrent();
|
||
|
|
|
||
|
|
//--- Calculate slippage
|
||
|
|
result.slippage = CalculateSlippage(request.price, result.executed_price, request.symbol);
|
||
|
|
|
||
|
|
//--- Wait for position to appear (for async mode)
|
||
|
|
if(m_async_mode)
|
||
|
|
{
|
||
|
|
if(!WaitForExecution(result.ticket))
|
||
|
|
{
|
||
|
|
result.success = false;
|
||
|
|
result.error_code = ERR_TRADE_TIMEOUT;
|
||
|
|
result.error_message = "Trade execution timeout";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
int error = GetLastError();
|
||
|
|
result.error_code = error;
|
||
|
|
result.error_message = trade_result.comment;
|
||
|
|
|
||
|
|
//--- Handle specific errors
|
||
|
|
HandleTradeError(error, request);
|
||
|
|
|
||
|
|
//--- Check if should retry
|
||
|
|
bool should_retry = false;
|
||
|
|
|
||
|
|
switch(error)
|
||
|
|
{
|
||
|
|
case ERR_REQUOTE:
|
||
|
|
case ERR_PRICE_CHANGED:
|
||
|
|
case ERR_OFF_QUOTES:
|
||
|
|
case ERR_BROKER_BUSY:
|
||
|
|
case ERR_TRADE_CONTEXT_BUSY:
|
||
|
|
should_retry = true;
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
should_retry = false;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
if(!should_retry || retry == m_max_retries)
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Handle trade error |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void CTradeExecutor::HandleTradeError(int error_code, MqlTradeRequest &request)
|
||
|
|
{
|
||
|
|
m_last_error = error_code;
|
||
|
|
|
||
|
|
switch(error_code)
|
||
|
|
{
|
||
|
|
case ERR_REQUOTE:
|
||
|
|
m_last_error_message = "Requote - prices changed";
|
||
|
|
break;
|
||
|
|
|
||
|
|
case ERR_INVALID_STOPS:
|
||
|
|
m_last_error_message = StringFormat("Invalid stops - SL: %.5f, TP: %.5f",
|
||
|
|
request.sl, request.tp);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case ERR_INVALID_VOLUME:
|
||
|
|
m_last_error_message = StringFormat("Invalid volume: %.2f lots", request.volume);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case ERR_NOT_ENOUGH_MONEY:
|
||
|
|
m_last_error_message = "Insufficient margin for trade";
|
||
|
|
break;
|
||
|
|
|
||
|
|
case ERR_TRADE_NOT_ALLOWED:
|
||
|
|
m_last_error_message = "Trading not allowed - check AutoTrading";
|
||
|
|
break;
|
||
|
|
|
||
|
|
case ERR_MARKET_CLOSED:
|
||
|
|
m_last_error_message = "Market is closed";
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
m_last_error_message = StringFormat("Trade error %d", error_code);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Calculate slippage in points |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
double CTradeExecutor::CalculateSlippage(double requested_price, double executed_price, string symbol)
|
||
|
|
{
|
||
|
|
double point = m_symbol_manager.GetPoint(symbol);
|
||
|
|
if(point == 0) return 0;
|
||
|
|
|
||
|
|
return MathAbs(executed_price - requested_price) / point;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Log execution result |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
void CTradeExecutor::LogExecution(const ExecutionResult &result, const MqlTradeRequest &request)
|
||
|
|
{
|
||
|
|
if(result.success)
|
||
|
|
{
|
||
|
|
Print(StringFormat("TradeExecutor: %s #%d opened - %s %.2f @ %.5f (slippage: %.1f points, %d ms)",
|
||
|
|
(request.type == ORDER_TYPE_BUY) ? "BUY" : "SELL",
|
||
|
|
result.ticket,
|
||
|
|
request.symbol,
|
||
|
|
result.executed_volume,
|
||
|
|
result.executed_price,
|
||
|
|
result.slippage,
|
||
|
|
result.execution_ms));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Print(StringFormat("TradeExecutor: Failed to open %s %s %.2f - Error %d: %s (retries: %d)",
|
||
|
|
(request.type == ORDER_TYPE_BUY) ? "BUY" : "SELL",
|
||
|
|
request.symbol,
|
||
|
|
request.volume,
|
||
|
|
result.error_code,
|
||
|
|
result.error_message,
|
||
|
|
result.retries));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Close position |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
ExecutionResult CTradeExecutor::ClosePosition(ulong ticket, double volume, string comment)
|
||
|
|
{
|
||
|
|
ExecutionResult result;
|
||
|
|
ZeroMemory(result);
|
||
|
|
|
||
|
|
datetime start_time = GetTickCount();
|
||
|
|
|
||
|
|
//--- Select position
|
||
|
|
if(!PositionSelectByTicket(ticket))
|
||
|
|
{
|
||
|
|
result.success = false;
|
||
|
|
result.error_code = ERR_TRADE_POSITION_NOT_FOUND;
|
||
|
|
result.error_message = "Position not found";
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
//--- Get position info
|
||
|
|
string symbol = PositionGetString(POSITION_SYMBOL);
|
||
|
|
double position_volume = PositionGetDouble(POSITION_VOLUME);
|
||
|
|
ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
|
||
|
|
|
||
|
|
//--- Determine volume to close
|
||
|
|
if(volume == 0 || volume >= position_volume)
|
||
|
|
volume = position_volume;
|
||
|
|
else
|
||
|
|
volume = m_symbol_manager.NormalizeLots(symbol, volume);
|
||
|
|
|
||
|
|
//--- Prepare request
|
||
|
|
MqlTradeRequest request;
|
||
|
|
ZeroMemory(request);
|
||
|
|
|
||
|
|
request.action = TRADE_ACTION_DEAL;
|
||
|
|
request.symbol = symbol;
|
||
|
|
request.volume = volume;
|
||
|
|
request.type = (type == POSITION_TYPE_BUY) ? ORDER_TYPE_SELL : ORDER_TYPE_BUY;
|
||
|
|
request.position = ticket;
|
||
|
|
request.deviation = m_max_slippage;
|
||
|
|
request.magic = m_magic_number;
|
||
|
|
request.comment = comment;
|
||
|
|
|
||
|
|
//--- Get current price
|
||
|
|
request.price = (type == POSITION_TYPE_BUY) ?
|
||
|
|
m_symbol_manager.GetCurrentBid(symbol) :
|
||
|
|
m_symbol_manager.GetCurrentAsk(symbol);
|
||
|
|
|
||
|
|
//--- Execute
|
||
|
|
result = ExecuteWithRetry(request);
|
||
|
|
|
||
|
|
//--- Update execution time
|
||
|
|
result.execution_ms = (int)(GetTickCount() - start_time);
|
||
|
|
|
||
|
|
//--- Update statistics
|
||
|
|
if(result.success)
|
||
|
|
{
|
||
|
|
m_trades_executed++;
|
||
|
|
m_total_slippage += result.slippage;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
m_trades_failed++;
|
||
|
|
}
|
||
|
|
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Modify position stops |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
ExecutionResult CTradeExecutor::ModifyPosition(ulong ticket, double sl, double tp)
|
||
|
|
{
|
||
|
|
ExecutionResult result;
|
||
|
|
ZeroMemory(result);
|
||
|
|
|
||
|
|
//--- Select position
|
||
|
|
if(!PositionSelectByTicket(ticket))
|
||
|
|
{
|
||
|
|
result.success = false;
|
||
|
|
result.error_code = ERR_TRADE_POSITION_NOT_FOUND;
|
||
|
|
result.error_message = "Position not found";
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
//--- Get position info
|
||
|
|
string symbol = PositionGetString(POSITION_SYMBOL);
|
||
|
|
double current_sl = PositionGetDouble(POSITION_SL);
|
||
|
|
double current_tp = PositionGetDouble(POSITION_TP);
|
||
|
|
|
||
|
|
//--- Check if modification needed
|
||
|
|
sl = m_symbol_manager.NormalizePrice(symbol, sl);
|
||
|
|
tp = m_symbol_manager.NormalizePrice(symbol, tp);
|
||
|
|
|
||
|
|
if(sl == current_sl && tp == current_tp)
|
||
|
|
{
|
||
|
|
result.success = true;
|
||
|
|
result.ticket = ticket;
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
//--- Validate stops
|
||
|
|
double current_price = m_symbol_manager.GetCurrentPrice(symbol,
|
||
|
|
(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE));
|
||
|
|
|
||
|
|
if(!m_symbol_manager.ValidateStopLevels(symbol, current_price, sl, tp))
|
||
|
|
{
|
||
|
|
result.success = false;
|
||
|
|
result.error_code = ERR_INVALID_STOPS;
|
||
|
|
result.error_message = "Invalid stop levels";
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
//--- Modify position
|
||
|
|
if(m_trade.PositionModify(ticket, sl, tp))
|
||
|
|
{
|
||
|
|
result.success = true;
|
||
|
|
result.ticket = ticket;
|
||
|
|
result.execution_time = TimeCurrent();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
result.success = false;
|
||
|
|
result.error_code = GetLastError();
|
||
|
|
result.error_message = m_trade.ResultComment();
|
||
|
|
}
|
||
|
|
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Check if trading is allowed |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool CTradeExecutor::IsTradeAllowed()
|
||
|
|
{
|
||
|
|
//--- Check terminal
|
||
|
|
if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
|
||
|
|
return false;
|
||
|
|
|
||
|
|
//--- Check EA
|
||
|
|
if(!MQLInfoInteger(MQL_TRADE_ALLOWED))
|
||
|
|
return false;
|
||
|
|
|
||
|
|
//--- Check account
|
||
|
|
if(!AccountInfoInteger(ACCOUNT_TRADE_ALLOWED))
|
||
|
|
return false;
|
||
|
|
|
||
|
|
if(!AccountInfoInteger(ACCOUNT_TRADE_EXPERT))
|
||
|
|
return false;
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Check margin for trade |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool CTradeExecutor::CheckMarginForTrade(string symbol, ENUM_ORDER_TYPE type, double volume)
|
||
|
|
{
|
||
|
|
double price = (type == ORDER_TYPE_BUY) ?
|
||
|
|
m_symbol_manager.GetCurrentAsk(symbol) :
|
||
|
|
m_symbol_manager.GetCurrentBid(symbol);
|
||
|
|
|
||
|
|
double margin = 0;
|
||
|
|
|
||
|
|
if(!OrderCalcMargin(type, symbol, volume, price, margin))
|
||
|
|
return false;
|
||
|
|
|
||
|
|
double free_margin = AccountInfoDouble(ACCOUNT_MARGIN_FREE);
|
||
|
|
|
||
|
|
return (margin > 0 && free_margin > margin);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Wait for order execution (async mode) |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
bool CTradeExecutor::WaitForExecution(ulong order_ticket, int timeout_ms)
|
||
|
|
{
|
||
|
|
datetime start_time = GetTickCount();
|
||
|
|
|
||
|
|
while(GetTickCount() - start_time < timeout_ms)
|
||
|
|
{
|
||
|
|
//--- Check if position exists
|
||
|
|
if(PositionSelectByTicket(order_ticket))
|
||
|
|
return true;
|
||
|
|
|
||
|
|
//--- Check if order still pending
|
||
|
|
if(OrderSelect(order_ticket))
|
||
|
|
{
|
||
|
|
Sleep(10);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
//--- Order doesn't exist - might be rejected
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
//| Close all positions |
|
||
|
|
//+------------------------------------------------------------------+
|
||
|
|
int CTradeExecutor::CloseAllPositions(int magic)
|
||
|
|
{
|
||
|
|
int closed = 0;
|
||
|
|
|
||
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--)
|
||
|
|
{
|
||
|
|
ulong ticket = PositionGetTicket(i);
|
||
|
|
if(ticket == 0) continue;
|
||
|
|
|
||
|
|
if(PositionSelectByTicket(ticket))
|
||
|
|
{
|
||
|
|
//--- Check magic number
|
||
|
|
if(magic >= 0 && PositionGetInteger(POSITION_MAGIC) != magic)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
ExecutionResult result = ClosePosition(ticket, 0, "Close All");
|
||
|
|
if(result.success) closed++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return closed;
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif // TRADE_EXECUTOR_MQH
|