405 lines
13 KiB
MQL5
405 lines
13 KiB
MQL5
 | //+------------------------------------------------------------------+
| ||
//| TradeExecutor_Impl.mqh |
| |||
//| Implementation of CTradeExecutor methods |
| |||
//+------------------------------------------------------------------+
| |||
#property strict
| |||
| |||
#include "TradeExecutor.mqh" // include header for class definition
| |||
| |||
// NOTE: This file contains implementations of CTradeExecutor methods
| |||
// Only method implementations should be in this file - no class definitions.
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Check if trading is allowed |
| |||
//+------------------------------------------------------------------+
| |||
bool CTradeExecutor::IsTradingAllowed()
| |||
{
| |||
if(!m_isInitialized)
| |||
{
| |||
m_lastError = "Trade executor not initialized";
| |||
return false;
| |||
}
| |||
if(!m_isTradingAllowed)
| |||
{
| |||
m_lastError = "Trading is disabled by configuration";
| |||
return false;
| |||
}
| |||
if(m_circuitBroken)
| |||
{
| |||
if(TimeCurrent() - m_circuitBreakTime < m_circuitBreakPeriod)
| |||
{
| |||
m_lastError = "Circuit breaker active";
| |||
return false;
| |||
}
| |||
else
| |||
{
| |||
m_circuitBroken = false;
| |||
m_consecutiveErrors = 0;
| |||
}
| |||
}
| |||
| |||
// Rate limit check
| |||
datetime currentTime = TimeCurrent();
| |||
if(TimeMinute(currentTime) != TimeMinute(m_currentMinute))
| |||
{
| |||
m_currentMinute = currentTime - (currentTime % 60);
| |||
m_ordersThisMinute = 0;
| |||
}
| |||
| |||
if(m_ordersThisMinute >= m_maxOrdersPerMinute)
| |||
{
| |||
m_lastError = "Rate limit exceeded";
| |||
return false;
| |||
}
| |||
| |||
return true;
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Constructor |
| |||
//+------------------------------------------------------------------+
| |||
CTradeExecutor::CTradeExecutor() :
| |||
m_totalTrades(0),
| |||
m_successfulTrades(0),
| |||
m_failedTrades(0),
| |||
m_totalSlippage(0.0),
| |||
m_avgExecutionTime(0.0),
| |||
m_isInitialized(false),
| |||
m_isTradingAllowed(false),
| |||
m_riskManager(NULL),
| |||
m_retryDelay(1000), // 1 second default retry delay
| |||
m_maxSlippage(10), // 10 points default slippage
| |||
m_useCircuitBreaker(true),
| |||
m_checkMarketConditions(true)
| |||
{
| |||
// Initialize trade object with default settings
| |||
m_trade.SetDeviationInPoints(m_maxSlippage);
| |||
m_trade.SetExpertMagicNumber(0);
| |||
m_trade.SetMarginMode();
| |||
m_trade.SetTypeFilling(ORDER_FILLING_FOK);
| |||
| |||
// Initialize arrays
| |||
m_tradeHistory = new CArrayObj();
| |||
m_pendingOrders = new CArrayObj();
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Destructor |
| |||
//+------------------------------------------------------------------+
| |||
CTradeExecutor::~CTradeExecutor()
| |||
{
| |||
// Clean up trade history
| |||
if(CheckPointer(m_tradeHistory) == POINTER_DYNAMIC)
| |||
delete m_tradeHistory;
| |||
| |||
// Clean up pending orders
| |||
if(CheckPointer(m_pendingOrders) == POINTER_DYNAMIC)
| |||
delete m_pendingOrders;
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Reset circuit breaker |
| |||
//+------------------------------------------------------------------+
| |||
void CTradeExecutor::ResetCircuitBreaker()
| |||
{
| |||
m_circuitBreakTime = 0;
| |||
m_consecutiveErrors = 0;
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Clean up old trade records |
| |||
//+------------------------------------------------------------------+
| |||
void CTradeExecutor::CleanupOldRecords()
| |||
{
| |||
datetime cutoff = TimeCurrent() - 7 * 24 * 60 * 60; // 1 week
| |||
| |||
for(int i = m_tradeHistory.Total() - 1; i >= 0; i--)
| |||
{
| |||
CTradeRecord* record = m_tradeHistory.At(i);
| |||
if(record != NULL && record.time < cutoff)
| |||
{
| |||
m_tradeHistory.Delete(i);
| |||
}
| |||
}
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Update circuit breaker state |
| |||
//+------------------------------------------------------------------+
| |||
void CTradeExecutor::UpdateCircuitBreaker(bool errorOccurred)
| |||
{
| |||
if(errorOccurred)
| |||
{
| |||
m_consecutiveErrors++;
| |||
| |||
// If we've hit the maximum consecutive errors, activate circuit breaker
| |||
if(m_consecutiveErrors >= m_maxConsecutiveErrors)
| |||
{
| |||
m_circuitBreakTime = TimeCurrent() + 300; // 5 minutes cooldown
| |||
m_isTradingAllowed = false;
| |||
Print("Circuit breaker activated! Trading paused for 5 minutes.");
| |||
}
| |||
}
| |||
else
| |||
{
| |||
// Reset error counter on successful operation
| |||
m_consecutiveErrors = 0;
| |||
}
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize |
| |||
//+------------------------------------------------------------------+
| |||
bool CTradeExecutor::Initialize(CRiskManager *riskManager)
| |||
{
| |||
if(m_isInitialized)
| |||
return true;
| |||
m_trade.SetExpertMagicNumber(0);
| |||
m_trade.SetDeviationInPoints(m_maxSlippage);
| |||
m_trade.SetAsyncMode(true);
| |||
m_riskManager = riskManager;
| |||
if(!m_security.Initialize())
| |||
{
| |||
m_lastError = "Failed to initialize security enhancements: "+m_security.GetLastError();
| |||
return false;
| |||
}
| |||
ResetCircuitBreaker();
| |||
m_totalTrades = m_successfulTrades = m_failedTrades = 0;
| |||
m_totalSlippage = m_avgExecutionTime = 0.0;
| |||
m_trade.SetDeviationInPoints(InpMaxSlippage);
| |||
CleanupOldRecords();
| |||
m_isInitialized = true;
| |||
m_isTradingAllowed = true;
| |||
Print("TradeExecutor: Initialized successfully");
| |||
return true;
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Deinitialize |
| |||
//+------------------------------------------------------------------+
| |||
void CTradeExecutor::Deinitialize(void)
| |||
{
| |||
if(!m_isInitialized)
| |||
return;
| |||
m_tradeHistory.Clear();
| |||
m_activeTrades.Clear();
| |||
m_hasPendingOrder = false;
| |||
ZeroMemory(m_pendingOrder);
| |||
m_circuitBroken = false;
| |||
m_consecutiveErrors = 0;
| |||
m_circuitBreakTime = 0;
| |||
s_ordersThisMinute = 0;
| |||
s_currentMinute = 0;
| |||
m_totalTrades = m_successfulTrades = m_failedTrades = 0;
| |||
m_totalSlippage = m_avgExecutionTime = 0.0;
| |||
m_lastError = "";
| |||
m_isInitialized = false;
| |||
m_isTradingAllowed = false;
| |||
Print("TradeExecutor: Deinitialized");
| |||
}
| |||
| |||
//+------------------------------------------------------------------+
| |||
//| Open a new market position with comprehensive security checks |
| |||
//+------------------------------------------------------------------+
| |||
bool CTradeExecutor::OpenPosition(string symbol, ENUM_ORDER_TYPE type, double volume,
| |||
double price, double sl, double tp, string comment,
| |||
int magic, datetime expiration, double maxSlippage)
| |||
{
| |||
// Check if trading is allowed
| |||
if(!m_isInitialized || !m_isTradingAllowed)
| |||
{
| |||
m_lastError = "Trading is not allowed. Check initialization.";
| |||
Print("TradeExecutor Error: ", m_lastError);
| |||
return false;
| |||
}
| |||
| |||
// Check circuit breaker
| |||
if(m_circuitBroken)
| |||
{
| |||
if(TimeCurrent() >= m_circuitBreakTime + m_circuitBreakTime)
| |||
{
| |||
Print("Circuit breaker cooldown period ended. Resuming normal operations.");
| |||
ResetCircuitBreaker();
| |||
}
| |||
else
| |||
{
| |||
int remaining = (int)(m_circuitBreakTime + m_circuitBreakTime - TimeCurrent());
| |||
m_lastError = "Circuit breaker active. Trading suspended for " + IntegerToString(remaining) + " seconds";
| |||
Print("TradeExecutor Error: ", m_lastError);
| |||
return false;
| |||
}
| |||
}
| |||
| |||
// Check rate limiting
| |||
if(!CheckRateLimit())
| |||
{
| |||
m_lastError = "Rate limit exceeded";
| |||
return false;
| |||
}
| |||
| |||
// Check market conditions if enabled
| |||
if(m_checkMarketConditions && !CheckMarketConditions(symbol))
| |||
{
| |||
m_lastError = "Market conditions check failed for " + symbol;
| |||
Print("TradeExecutor Error: ", m_lastError);
| |||
return false;
| |||
}
| |||
| |||
// Prepare order request with additional security parameters
| |||
SOrderRequest request = {};
| |||
request.symbol = symbol;
| |||
request.type = type;
| |||
request.volume = volume;
| |||
request.price = price;
| |||
request.sl = sl;
| |||
request.tp = tp;
| |||
request.comment = comment;
| |||
request.magic = (magic > 0) ? magic : m_trade.RequestMagic();
| |||
request.expiration = expiration;
| |||
request.attempts = 0;
| |||
request.reqId = IntegerToString(GetTickCount()) + "_" + IntegerToString(OrdersTotal());
| |||
request.maxSlippage = (maxSlippage > 0) ? maxSlippage : InpMaxSlippage;
| |||
request.requireVerification = InpVerifyOrderFills;
| |||
| |||
// Log the trade attempt
| |||
if(InpLogAllTrades)
| |||
{
| |||
string orderType = (type == ORDER_TYPE_BUY) ? "BUY" : "SELL";
| |||
PrintFormat("TradeExecutor: Attempting %s %s %.2f lots @ %s (SL: %s, TP: %s)",
| |||
orderType, symbol, volume, DoubleToString(price, _Digits),
| |||
DoubleToString(sl, _Digits), DoubleToString(tp, _Digits));
| |||
}
| |||
| |||
// Execute the order with retry logic
| |||
bool result = false;
| |||
MqlTradeRequest tradeRequest = {};
| |||
MqlTradeResult tradeResult = {};
| |||
| |||
// Prepare trade request
| |||
tradeRequest.action = TRADE_ACTION_DEAL;
| |||
tradeRequest.symbol = symbol;
| |||
tradeRequest.volume = volume;
| |||
tradeRequest.type = type;
| |||
tradeRequest.price = price;
| |||
tradeRequest.sl = sl;
| |||
tradeRequest.tp = tp;
| |||
tradeRequest.deviation = (ushort)request.maxSlippage;
| |||
tradeRequest.magic = request.magic;
| |||
tradeRequest.comment = comment;
| |||
tradeRequest.type_filling = ORDER_FILLING_FOK;
| |||
| |||
// Validate the request using the unified validator
| |||
if(!ValidateOrder(symbol, type, volume, price, sl, tp, request.magic, request.maxSlippage, comment))
| |||
{
| |||
m_lastError = "Trade request validation failed: " + m_lastError;
| |||
Print("TradeExecutor Error: ", m_lastError);
| |||
UpdateCircuitBreaker(true);
| |||
return false;
| |||
}
| |||
| |||
// Execute the trade with retry logic
| |||
ulong startTime = GetTickCount();
| |||
for(int attempt = 0; attempt <= InpMaxRetries; attempt++)
| |||
{
| |||
// Check for user break
| |||
if(IsStopped())
| |||
{
| |||
m_lastError = "Operation canceled by user";
| |||
Print("TradeExecutor: ", m_lastError);
| |||
return false;
| |||
}
| |||
| |||
// Add delay between retries (except first attempt)
| |||
if(attempt > 0)
| |||
{
| |||
int delay = MathMin(InpRetryDelay * (int)MathPow(2, attempt-1), 5000); // Exponential backoff, max 5s
| |||
PrintFormat("TradeExecutor: Retry attempt %d of %d after %d ms",
| |||
attempt, InpMaxRetries, delay);
| |||
Sleep(delay);
| |||
}
| |||
| |||
// Execute the trade
| |||
ZeroMemory(tradeResult);
| |||
bool success = OrderSend(tradeRequest, tradeResult);
| |||
| |||
// Log the execution
| |||
ulong duration = GetTickCount() - startTime;
| |||
LogTradeExecution(tradeRequest, tradeResult, duration);
| |||
| |||
// Check the result
| |||
if(success && tradeResult.retcode == TRADE_RETCODE_DONE)
| |||
{
| |||
// Verify the order fill if required
| |||
if(!request.requireVerification || VerifyOrderFill(tradeRequest, tradeResult))
| |||
{
| |||
// Create trade record
| |||
CTradeRecord *record = new CTradeRecord();
| |||
record.Set(tradeResult.order, symbol, type, volume, tradeResult.price,
| |||
sl, tp, tradeResult.deviation, comment);
| |||
AddToHistory(record);
| |||
| |||
// Update metrics
| |||
m_successfulTrades++;
| |||
m_totalSlippage += tradeResult.deviation;
| |||
m_avgExecutionTime = (m_avgExecutionTime * (m_successfulTrades - 1) + duration) / m_successfulTrades;
| |||
| |||
if(InpLogAllTrades)
| |||
{
| |||
PrintFormat("TradeExecutor: Order #%d executed successfully in %d ms. Slippage: %.1f pips",
| |||
tradeResult.order, duration, tradeResult.deviation);
| |||
}
| |||
| |||
result = true;
| |||
break;
| |||
}
| |||
else
| |||
{
| |||
// Verification failed
| |||
m_lastError = "Order fill verification failed";
| |||
Print("TradeExecutor Error: ", m_lastError);
| |||
UpdateCircuitBreaker(true);
| |||
return false;
| |||
}
| |||
}
| |||
else
| |||
{
| |||
// Log the error
| |||
string errorDesc = GetRetcodeDescription(tradeResult.retcode);
| |||
m_lastError = StringFormat("OrderSend failed: %s (code: %d)", errorDesc, tradeResult.retcode);
| |||
Print("TradeExecutor Error: ", m_lastError);
| |||
| |||
// Update error tracking
| |||
m_failedTrades++;
| |||
m_consecutiveErrors++;
| |||
| |||
// Check if we should continue retrying
| |||
if(attempt >= InpMaxRetries - 1)
| |||
{
| |||
UpdateCircuitBreaker(true);
| |||
return false;
| |||
}
| |||
}
| |||
}
| |||
| |||
// Update metrics
| |||
m_totalTrades++;
| |||
| |||
// Update last order time for rate limiting
| |||
m_lastOrderTime = TimeCurrent();
| |||
| |||
// Check if we need to trigger circuit breaker
| |||
if(!result)
| |||
{
| |||
UpdateCircuitBreaker(true);
| |||
}
| |||
| |||
return result;
| |||
}
| |||
| |||
// Static member definitions --------------------------------------------------
| |||
int CTradeExecutor::s_ordersThisMinute = 0;
| |||
datetime CTradeExecutor::s_currentMinute = 0;
| |||
| |||
//---------------------------------------------------------------------------
| |||
// END MOVED IMPLEMENTATIONS
| |||
//---------------------------------------------------------------------------
|