CHACHAIAN/PropFirmGuard
Watch
1
0
Fork
You've already forked PropFirmGuard
 0
Code Issues Pull requests Projects Releases 7 Packages Wiki Activity Actions
PropFirmGuard/PropFirmGuard.mq5

2623 lines
90 KiB
MQL5
Raw Permalink Blame History

//+------------------------------------------------------------------+
//| PropFirmGuard.mq5 |
//| Copyright 2026, MetaQuotes Ltd. |
//| https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, MetaQuotes Ltd."
#property link "https://www.mql5.com"
#property version "1.00"
//+------------------------------------------------------------------+
//| Standard Library |
//+------------------------------------------------------------------+
#include <Trade\Trade.mqh>
//+------------------------------------------------------------------+
//| Enumerations |
//+------------------------------------------------------------------+
//| Represents the general compliance condition of the account. |
//+------------------------------------------------------------------+
enum ENUM_COMPLIANCE_STATUS
{
COMPLIANCE_SAFE = 0, // Account is operating within configured limits
COMPLIANCE_WARNING, // Account is approaching a compliance limit
COMPLIANCE_CRITICAL, // Account is very close to a compliance limit
COMPLIANCE_BREACHED // A configured compliance limit has been breached
};
//+------------------------------------------------------------------+
//| Profit target status |
//+------------------------------------------------------------------+
//| Represents progress toward the configured account profit target. |
//+------------------------------------------------------------------+
enum ENUM_TARGET_STATUS
{
TARGET_IN_PROGRESS = 0, // Target is still being pursued
TARGET_NEARING, // At least 90% of the target has been reached
TARGET_REACHED // Required target balance has been achieved
};
//+------------------------------------------------------------------+
//| Overall guard status |
//+------------------------------------------------------------------+
enum ENUM_GUARD_STATUS
{
GUARD_SAFE = 0, // All monitored rules are within safe limits
GUARD_TARGET_REACHED, // Profit target has been achieved
GUARD_WARNING, // At least one rule is in warning state
GUARD_CRITICAL, // At least one rule is in critical state
GUARD_BREACHED // At least one drawdown rule has been breached
};
//+------------------------------------------------------------------+
//| News monitoring status |
//+------------------------------------------------------------------+
enum ENUM_NEWS_STATUS
{
NEWS_DISABLED = 0, // Economic news monitoring is disabled
NEWS_NO_EXPOSURE, // No supported open positions require news monitoring
NEWS_NO_EVENT, // No relevant event was found
NEWS_SAFE, // Relevant event exists but restriction is inactive
NEWS_RESTRICTED, // Current time is inside the restricted news window
NEWS_UNAVAILABLE // Calendar data could not be retrieved
};
//+------------------------------------------------------------------+
//| News position match status |
//+------------------------------------------------------------------+
//| Describes whether an open position is affected by the selected |
//| Economic Calendar event. |
//+------------------------------------------------------------------+
enum ENUM_NEWS_POSITION_STATUS
{
NEWS_POSITION_NOT_AFFECTED = 0, // Position does not use the event currency
NEWS_POSITION_AFFECTED, // Position is exposed to the event currency
NEWS_POSITION_UNSUPPORTED // Position is outside current Forex/XAUUSD scope
};
//+------------------------------------------------------------------+
//| News holding status |
//+------------------------------------------------------------------+
//| Describes the account's current holding-rule condition around |
//| the selected Economic Calendar event. |
//+------------------------------------------------------------------+
enum ENUM_NEWS_HOLDING_STATUS
{
NEWS_HOLDING_CLEAR = 0, // No active holding restriction
NEWS_HOLDING_ALLOWED, // Restricted window active but holding is permitted
NEWS_HOLDING_WARNING, // Event is approaching and affected positions exist
NEWS_HOLDING_PROTECTION // Restricted window active and protection is required
};
//+------------------------------------------------------------------+
//| Protection action |
//+------------------------------------------------------------------+
//| Defines what Prop Firm Guard should do when a monitored rule |
//| requires protective action. |
//+------------------------------------------------------------------+
enum ENUM_PROTECTION_ACTION
{
PROTECTION_WARN_ONLY = 0, // Report the condition without closing positions
PROTECTION_CLOSE_AFFECTED, // Close positions affected by the triggering rule
PROTECTION_CLOSE_ALL // Close every open account position
};
//+------------------------------------------------------------------+
//| Inputs |
//+------------------------------------------------------------------+
input group "General"
input int InpTimerSeconds = 1; // Dashboard update interval in seconds
input int InpDashboardX = 10; // Dashboard horizontal position
input int InpDashboardY = 105; // Dashboard vertical position
input bool InpEnableAlerts = true; // Enable terminal alerts
input bool InpEnablePushNotifications = false; // Enable mobile push notifications
input group "Prop Firm Rules"
input double InpInitialAccountBalance = 20000.0; // Initial prop-firm account balance
input double InpDailyDrawdownPercent = 5.0; // Maximum permitted daily drawdown
input double InpOverallDrawdownPercent = 10.0; // Maximum permitted overall drawdown
input double InpProfitTargetPercent = 8.0; // Required profit target
input group "Warning Levels"
input double InpWarningLevelPercent = 70.0; // Loss limit usage that triggers warning
input double InpCriticalLevelPercent = 90.0; // Loss limit usage that triggers critical state
input group "News Filter"
input bool InpEnableNewsFilter = true; // Enable economic news monitoring
input ENUM_CALENDAR_EVENT_IMPORTANCE InpNewsImportance = CALENDAR_IMPORTANCE_HIGH; // Minimum monitored importance
input int InpMinutesBeforeNews = 10; // Restricted minutes before news
input int InpMinutesAfterNews = 10; // Restricted minutes after news
input bool InpAllowNewsHolding = true; // Allow positions to remain open during news
input group "Protection Actions"
input ENUM_PROTECTION_ACTION InpDailyDrawdownAction = PROTECTION_WARN_ONLY; // Daily breach action
input ENUM_PROTECTION_ACTION InpOverallDrawdownAction = PROTECTION_WARN_ONLY; // Overall breach action
input ENUM_PROTECTION_ACTION InpNewsRestrictionAction = PROTECTION_WARN_ONLY; // News restriction action
//+------------------------------------------------------------------+
//| Account state structure |
//+------------------------------------------------------------------+
//| Holds the live account values required by the monitoring logic. |
//+------------------------------------------------------------------+
struct SAccountState
{
long login; // Trading account login number
double balance; // Current account balance
double equity; // Current account equity
double floatingPL; // Current floating profit or loss
ENUM_COMPLIANCE_STATUS status; // Current overall compliance status
};
//+------------------------------------------------------------------+
//| Account settings structure |
//+------------------------------------------------------------------+
//| Stores the main prop-firm rules associated with this account. |
//+------------------------------------------------------------------+
struct SAccountSettings
{
long accountLogin; // Trading account login
string accountServer; // Broker trading server
double initialBalance; // Initial prop-firm account balance
double dailyDrawdownPercent; // Maximum daily drawdown
double overallDrawdownPercent; // Maximum overall drawdown
double profitTargetPercent; // Required profit target
datetime updatedAt; // Last settings update time
};
//+------------------------------------------------------------------+
//| Daily session structure |
//+------------------------------------------------------------------+
//| Represents the persistent state associated with one trading day. |
//+------------------------------------------------------------------+
struct SDailySession
{
long accountLogin; // Trading account login
string accountServer; // Broker trading server
string tradingDate; // Trading date represented by this session
double startingBalance; // Confirmed daily starting balance
double startingEquity; // Equity captured when the baseline is confirmed
bool balanceConfirmed; // Whether the starting balance has been confirmed
double latestBalance; // Most recently recorded account balance
double latestEquity; // Most recently recorded account equity
double dailyLoss; // Persisted daily loss value
double maximumDailyLossReached; // Highest daily loss recorded during the session
double targetProgress; // Persisted profit-target progress
string sessionStatus; // Current persisted session status
datetime createdAt; // Time the session record was created
datetime updatedAt; // Time the session record was last updated
};
//+------------------------------------------------------------------+
//| Daily drawdown structure |
//+------------------------------------------------------------------+
//| Holds the calculated daily risk values for the active session. |
//+------------------------------------------------------------------+
struct SDailyDrawdownState
{
double startingBalance; // Confirmed daily starting balance
double currentEquity; // Current live account equity
double maximumDailyLoss; // Maximum money that may be lost today
double currentDailyLoss; // Current loss measured from starting balance
double drawdownPercent; // Current loss as percentage of starting balance
double limitUsagePercent; // Percentage of daily loss allowance already used
double remainingAllowance; // Money remaining before daily breach
ENUM_COMPLIANCE_STATUS status; // Current daily drawdown status
};
//+------------------------------------------------------------------+
//| Overall drawdown structure |
//+------------------------------------------------------------------+
//| Holds the live calculations for the static overall loss rule. |
//+------------------------------------------------------------------+
struct SOverallDrawdownState
{
double initialBalance; // Initial prop-firm account balance
double currentEquity; // Current live account equity
double maximumOverallLoss; // Maximum permitted overall loss
double overallFloor; // Minimum permitted account equity
double currentOverallLoss; // Current loss from initial balance
double limitUsagePercent; // Percentage of overall allowance used
double remainingAllowance; // Money remaining before breach
ENUM_COMPLIANCE_STATUS status; // Current overall drawdown status
};
//+------------------------------------------------------------------+
//| Profit target structure |
//+------------------------------------------------------------------+
//| Holds the live calculations used to track challenge progress. |
//+------------------------------------------------------------------+
struct SProfitTargetState
{
double initialBalance; // Initial prop-firm account balance
double currentBalance; // Current realized account balance
double targetAmount; // Profit required in account currency
double targetBalance; // Balance required to complete the target
double currentProfit; // Realized profit above initial balance
double progressPercent; // Percentage of target already completed
double remainingProfit; // Profit still required to reach target
ENUM_TARGET_STATUS status; // Current target progress state
};
//+------------------------------------------------------------------+
//| News monitoring structure |
//+------------------------------------------------------------------+
struct SNewsState
{
bool hasExposure; // Whether supported open positions exist
int monitoredCurrencies; // Number of unique monitored currencies
string currencyList; // Monitored currency list
bool eventFound; // Whether a relevant event was located
string eventCurrency; // Currency affected by selected event
ulong eventId; // Economic Calendar event identifier
string eventName; // Economic event name
ENUM_CALENDAR_EVENT_IMPORTANCE importance; // Event importance
datetime eventTime; // Event time in trade-server time
long secondsToEvent; // Signed distance to event
datetime restrictionStart; // Beginning of restricted news window
datetime restrictionEnd; // End of restricted news window
bool restrictedWindow; // Whether restriction is currently active
int affectedPositions; // Positions affected by selected event
int protectionPositions; // Affected positions requiring protection
ENUM_NEWS_STATUS status; // Current news-monitoring status
ENUM_NEWS_HOLDING_STATUS holdingStatus; // Current news-holding condition
};
//+------------------------------------------------------------------+
//| News position match structure |
//+------------------------------------------------------------------+
struct SNewsPositionMatch
{
ulong ticket; // Position ticket
string symbol; // Position symbol
string currency1; // First relevant currency
string currency2; // Second relevant currency
ENUM_NEWS_POSITION_STATUS status; // Event-currency classification
bool protectionRequired; // Whether protection is required
};
//+------------------------------------------------------------------+
//| Global variables |
//+------------------------------------------------------------------+
SAccountState g_accountState; // Latest monitored account state
SAccountSettings g_accountSettings; // Persisted prop-firm settings
SDailySession g_dailySession; // Current trading-day record
SDailyDrawdownState g_dailyDrawdown; // Current daily drawdown calculations
SOverallDrawdownState g_overallDrawdown; // Current overall drawdown calculations
SProfitTargetState g_profitTarget; // Current profit-target calculations
SNewsState g_newsState; // Current economic news state
SNewsPositionMatch g_newsPositionMatches[]; // Classification of open positions
string g_startBalanceEdit = "PFG_StartBalanceEdit"; // Starting balance input field
string g_confirmButton = "PFG_ConfirmBalance"; // Daily balance confirmation button
string g_databaseName = "prop_firm_compliance.sqlite"; // SQLite database file
int g_database = INVALID_HANDLE; // Active SQLite database handle
bool g_hasDailySession = false; // Whether a daily session is loaded
//+------------------------------------------------------------------+
//| Validate compliance inputs |
//+------------------------------------------------------------------+
bool ValidateComplianceInputs()
{
//--- Validate the initial account balance
if(InpInitialAccountBalance <= 0.0)
{
Print("Prop Firm Guard: Initial account balance must be greater than zero.");
return(false);
}
//--- Validate the daily drawdown percentage
if(InpDailyDrawdownPercent <= 0.0 ||
InpDailyDrawdownPercent > 100.0)
{
Print("Prop Firm Guard: Daily drawdown percentage must be between 0 and 100.");
return(false);
}
//--- Validate the overall drawdown percentage
if(InpOverallDrawdownPercent <= 0.0 ||
InpOverallDrawdownPercent > 100.0)
{
Print("Prop Firm Guard: Overall drawdown percentage must be between 0 and 100.");
return(false);
}
//--- Validate the profit target percentage
if(InpProfitTargetPercent <= 0.0 ||
InpProfitTargetPercent > 100.0)
{
Print("Prop Firm Guard: Profit target percentage must be between 0 and 100.");
return(false);
}
//--- Validate the warning threshold
if(InpWarningLevelPercent <= 0.0 ||
InpWarningLevelPercent >= InpCriticalLevelPercent)
{
Print("Prop Firm Guard: Warning level must be greater than 0 and below the critical level.");
return(false);
}
//--- Validate the critical threshold
if(InpCriticalLevelPercent <= InpWarningLevelPercent ||
InpCriticalLevelPercent >= 100.0)
{
Print("Prop Firm Guard: Critical level must be above the warning level and below 100.");
return(false);
}
//--- Validate the news restriction windows
if(InpMinutesBeforeNews < 0 ||
InpMinutesAfterNews < 0)
{
Print("Prop Firm Guard: News restriction minutes cannot be negative.");
return(false);
}
return(true);
}
//+------------------------------------------------------------------+
//| Update account state |
//+------------------------------------------------------------------+
void UpdateAccountState()
{
//--- Read the current account values
g_accountState.login = AccountInfoInteger(ACCOUNT_LOGIN);
g_accountState.balance = AccountInfoDouble(ACCOUNT_BALANCE);
g_accountState.equity = AccountInfoDouble(ACCOUNT_EQUITY);
//--- Derive the current floating profit or loss
g_accountState.floatingPL = g_accountState.equity - g_accountState.balance;
//--- Initialize compliance status before rule calculations are added
g_accountState.status = COMPLIANCE_SAFE;
}
//+------------------------------------------------------------------+
//| Calculate daily drawdown |
//+------------------------------------------------------------------+
void CalculateDailyDrawdown()
{
//--- Reset the state until the daily starting balance is confirmed
if(!g_dailySession.balanceConfirmed ||
g_dailySession.startingBalance <= 0.0)
{
g_dailyDrawdown.startingBalance = 0.0;
g_dailyDrawdown.currentEquity = g_accountState.equity;
g_dailyDrawdown.maximumDailyLoss = 0.0;
g_dailyDrawdown.currentDailyLoss = 0.0;
g_dailyDrawdown.drawdownPercent = 0.0;
g_dailyDrawdown.limitUsagePercent = 0.0;
g_dailyDrawdown.remainingAllowance = 0.0;
g_dailyDrawdown.status = COMPLIANCE_SAFE;
return;
}
//--- Read the active daily reference and current equity
g_dailyDrawdown.startingBalance = g_dailySession.startingBalance;
g_dailyDrawdown.currentEquity = g_accountState.equity;
//--- Calculate the permitted daily loss
g_dailyDrawdown.maximumDailyLoss =
g_dailyDrawdown.startingBalance *
g_accountSettings.dailyDrawdownPercent / 100.0;
//--- Calculate the current daily loss
g_dailyDrawdown.currentDailyLoss =
g_dailyDrawdown.startingBalance -
g_dailyDrawdown.currentEquity;
if(g_dailyDrawdown.currentDailyLoss < 0.0)
g_dailyDrawdown.currentDailyLoss = 0.0;
//--- Calculate the loss percentage
g_dailyDrawdown.drawdownPercent =
g_dailyDrawdown.currentDailyLoss /
g_dailyDrawdown.startingBalance * 100.0;
//--- Calculate daily limit usage
if(g_dailyDrawdown.maximumDailyLoss > 0.0)
{
g_dailyDrawdown.limitUsagePercent =
g_dailyDrawdown.currentDailyLoss /
g_dailyDrawdown.maximumDailyLoss * 100.0;
}
else
{
g_dailyDrawdown.limitUsagePercent = 0.0;
}
//--- Calculate the remaining allowance
g_dailyDrawdown.remainingAllowance =
g_dailyDrawdown.maximumDailyLoss -
g_dailyDrawdown.currentDailyLoss;
if(g_dailyDrawdown.remainingAllowance < 0.0)
g_dailyDrawdown.remainingAllowance = 0.0;
//--- Classify the current daily drawdown state
if(g_dailyDrawdown.limitUsagePercent >= 100.0)
g_dailyDrawdown.status = COMPLIANCE_BREACHED;
else
if(g_dailyDrawdown.limitUsagePercent >= InpCriticalLevelPercent)
g_dailyDrawdown.status = COMPLIANCE_CRITICAL;
else
if(g_dailyDrawdown.limitUsagePercent >= InpWarningLevelPercent)
g_dailyDrawdown.status = COMPLIANCE_WARNING;
else
g_dailyDrawdown.status = COMPLIANCE_SAFE;
}
//+------------------------------------------------------------------+
//| Calculate overall drawdown |
//+------------------------------------------------------------------+
void CalculateOverallDrawdown()
{
//--- Read the fixed challenge reference and current equity
g_overallDrawdown.initialBalance = g_accountSettings.initialBalance;
g_overallDrawdown.currentEquity = g_accountState.equity;
//--- Calculate the maximum permitted overall loss
g_overallDrawdown.maximumOverallLoss =
g_overallDrawdown.initialBalance *
g_accountSettings.overallDrawdownPercent / 100.0;
//--- Calculate the static overall equity floor
g_overallDrawdown.overallFloor =
g_overallDrawdown.initialBalance -
g_overallDrawdown.maximumOverallLoss;
//--- Calculate the current loss from the initial balance
g_overallDrawdown.currentOverallLoss =
g_overallDrawdown.initialBalance -
g_overallDrawdown.currentEquity;
if(g_overallDrawdown.currentOverallLoss < 0.0)
g_overallDrawdown.currentOverallLoss = 0.0;
//--- Calculate overall limit usage
if(g_overallDrawdown.maximumOverallLoss > 0.0)
{
g_overallDrawdown.limitUsagePercent =
g_overallDrawdown.currentOverallLoss /
g_overallDrawdown.maximumOverallLoss * 100.0;
}
else
{
g_overallDrawdown.limitUsagePercent = 0.0;
}
//--- Calculate the remaining overall allowance
g_overallDrawdown.remainingAllowance =
g_overallDrawdown.maximumOverallLoss -
g_overallDrawdown.currentOverallLoss;
if(g_overallDrawdown.remainingAllowance < 0.0)
g_overallDrawdown.remainingAllowance = 0.0;
//--- Classify the current overall drawdown state
if(g_overallDrawdown.limitUsagePercent >= 100.0)
g_overallDrawdown.status = COMPLIANCE_BREACHED;
else
if(g_overallDrawdown.limitUsagePercent >= InpCriticalLevelPercent)
g_overallDrawdown.status = COMPLIANCE_CRITICAL;
else
if(g_overallDrawdown.limitUsagePercent >= InpWarningLevelPercent)
g_overallDrawdown.status = COMPLIANCE_WARNING;
else
g_overallDrawdown.status = COMPLIANCE_SAFE;
}
//+------------------------------------------------------------------+
//| Calculate profit target |
//+------------------------------------------------------------------+
void CalculateProfitTarget()
{
//--- Read the fixed challenge reference and realized balance
g_profitTarget.initialBalance = g_accountSettings.initialBalance;
g_profitTarget.currentBalance = g_accountState.balance;
//--- Calculate the required profit and target balance
g_profitTarget.targetAmount =
g_profitTarget.initialBalance *
g_accountSettings.profitTargetPercent / 100.0;
g_profitTarget.targetBalance =
g_profitTarget.initialBalance +
g_profitTarget.targetAmount;
//--- Calculate realized profit above the initial balance
g_profitTarget.currentProfit =
g_profitTarget.currentBalance -
g_profitTarget.initialBalance;
if(g_profitTarget.currentProfit < 0.0)
g_profitTarget.currentProfit = 0.0;
//--- Calculate target progress
if(g_profitTarget.targetAmount > 0.0)
{
g_profitTarget.progressPercent =
g_profitTarget.currentProfit /
g_profitTarget.targetAmount * 100.0;
}
else
{
g_profitTarget.progressPercent = 0.0;
}
if(g_profitTarget.progressPercent > 100.0)
g_profitTarget.progressPercent = 100.0;
//--- Calculate the remaining required profit
g_profitTarget.remainingProfit =
g_profitTarget.targetAmount -
g_profitTarget.currentProfit;
if(g_profitTarget.remainingProfit < 0.0)
g_profitTarget.remainingProfit = 0.0;
//--- Classify the current target state
if(g_profitTarget.currentBalance >= g_profitTarget.targetBalance)
g_profitTarget.status = TARGET_REACHED;
else
if(g_profitTarget.progressPercent >= 90.0)
g_profitTarget.status = TARGET_NEARING;
else
g_profitTarget.status = TARGET_IN_PROGRESS;
}
//+------------------------------------------------------------------+
//| Initialize news state |
//+------------------------------------------------------------------+
void InitializeNewsState()
{
//--- Clear account-exposure information
g_newsState.hasExposure = false;
g_newsState.monitoredCurrencies = 0;
g_newsState.currencyList = "";
//--- Clear the previously selected calendar event
g_newsState.eventFound = false;
g_newsState.eventCurrency = "";
g_newsState.eventId = 0;
g_newsState.eventName = "";
g_newsState.importance = CALENDAR_IMPORTANCE_NONE;
g_newsState.eventTime = 0;
//--- Reset event timing and restriction-window state
g_newsState.secondsToEvent = 0;
g_newsState.restrictionStart = 0;
g_newsState.restrictionEnd = 0;
g_newsState.restrictedWindow = false;
//--- Set the initial monitoring condition
g_newsState.status =
InpEnableNewsFilter ? NEWS_NO_EXPOSURE : NEWS_DISABLED;
}
//+------------------------------------------------------------------+
//| Check whether currency already exists in array |
//+------------------------------------------------------------------+
bool CurrencyExists(const string &currencies[],
const string currency)
{
int count = ArraySize(currencies);
//--- Search the current currency set
for(int i = 0; i < count; i++)
{
if(currencies[i] == currency)
return(true);
}
return(false);
}
//+------------------------------------------------------------------+
//| Add unique currency to array |
//+------------------------------------------------------------------+
bool AddUniqueCurrency(string &currencies[],
const string currency)
{
//--- Ignore an empty currency value
if(currency == "")
return(true);
//--- Keep each monitored currency only once
if(CurrencyExists(currencies, currency))
return(true);
int currentSize = ArraySize(currencies);
//--- Extend the currency array
if(ArrayResize(currencies, currentSize + 1) != currentSize + 1)
{
Print("Prop Firm Guard: Could not expand monitored currency array.");
return(false);
}
currencies[currentSize] = currency;
return(true);
}
//+------------------------------------------------------------------+
//| Get symbol currencies relevant to news |
//+------------------------------------------------------------------+
bool GetSymbolNewsCurrencies(const string symbol,
string &currency1,
string &currency2)
{
string baseCurrency;
string profitCurrency;
long calculationMode = 0;
currency1 = "";
currency2 = "";
//--- Read the currencies defined by the broker for this symbol
ResetLastError();
if(!SymbolInfoString(symbol,
SYMBOL_CURRENCY_BASE,
baseCurrency))
{
Print("Prop Firm Guard: Could not read base currency for ",
symbol,
". Error: ",
GetLastError());
return(false);
}
ResetLastError();
if(!SymbolInfoString(symbol,
SYMBOL_CURRENCY_PROFIT,
profitCurrency))
{
Print("Prop Firm Guard: Could not read profit currency for ",
symbol,
". Error: ",
GetLastError());
return(false);
}
//--- Treat XAUUSD as USD calendar exposure
if(baseCurrency == "XAU" &&
profitCurrency == "USD")
{
currency1 = "USD";
return(true);
}
//--- Read the symbol's trading calculation model
ResetLastError();
if(!SymbolInfoInteger(symbol,
SYMBOL_TRADE_CALC_MODE,
calculationMode))
{
Print("Prop Firm Guard: Could not read calculation mode for ",
symbol,
". Error: ",
GetLastError());
return(false);
}
//--- Ignore instruments outside the supported Forex calculation modes
if(calculationMode != SYMBOL_CALC_MODE_FOREX &&
calculationMode != SYMBOL_CALC_MODE_FOREX_NO_LEVERAGE)
return(true);
currency1 = baseCurrency;
currency2 = profitCurrency;
return(true);
}
//+------------------------------------------------------------------+
//| Match open positions to selected news event |
//+------------------------------------------------------------------+
void MatchOpenPositionsToNews()
{
//--- Remove classifications from the previous monitoring cycle
ArrayResize(g_newsPositionMatches, 0);
//--- Position matching requires an actual selected calendar event
if(!g_newsState.eventFound ||
g_newsState.eventCurrency == "")
return;
int totalPositions = PositionsTotal();
//--- Classify every currently open account position
for(int i = 0; i < totalPositions; i++)
{
ResetLastError();
ulong ticket = PositionGetTicket(i);
if(ticket == 0)
{
Print("Prop Firm Guard: Could not retrieve position ticket at index ",
i,
". Error: ",
GetLastError());
continue;
}
string symbol;
if(!PositionGetString(POSITION_SYMBOL,
symbol))
{
Print("Prop Firm Guard: Could not retrieve symbol for position ",
ticket,
". Error: ",
GetLastError());
continue;
}
string currency1;
string currency2;
if(!GetSymbolNewsCurrencies(symbol,
currency1,
currency2))
continue;
SNewsPositionMatch match;
match.ticket = ticket;
match.symbol = symbol;
match.currency1 = currency1;
match.currency2 = currency2;
match.status = NEWS_POSITION_NOT_AFFECTED;
match.protectionRequired = false;
//--- Classify the position against the selected event currency
if(currency1 == "" &&
currency2 == "")
{
match.status = NEWS_POSITION_UNSUPPORTED;
}
else
if(currency1 == g_newsState.eventCurrency ||
currency2 == g_newsState.eventCurrency)
{
match.status = NEWS_POSITION_AFFECTED;
}
int currentSize = ArraySize(g_newsPositionMatches);
//--- Store the ticket-level classification
if(ArrayResize(g_newsPositionMatches,
currentSize + 1) != currentSize + 1)
{
Print("Prop Firm Guard: Could not expand news position match array.");
return;
}
g_newsPositionMatches[currentSize] = match;
}
}
//+------------------------------------------------------------------+
//| Evaluate news holding rules |
//+------------------------------------------------------------------+
void EvaluateNewsHoldingRules()
{
//--- Reset the account-level holding result
g_newsState.affectedPositions = 0;
g_newsState.protectionPositions = 0;
g_newsState.holdingStatus = NEWS_HOLDING_CLEAR;
int totalMatches = ArraySize(g_newsPositionMatches);
//--- Stop when no selected event or classified positions exist
if(!g_newsState.eventFound ||
totalMatches == 0)
return;
//--- Count positions affected by the selected event
for(int i = 0; i < totalMatches; i++)
{
g_newsPositionMatches[i].protectionRequired = false;
if(g_newsPositionMatches[i].status == NEWS_POSITION_AFFECTED)
g_newsState.affectedPositions++;
}
//--- No affected positions means no holding restriction applies
if(g_newsState.affectedPositions == 0)
return;
//--- Respect configurations that permit positions to remain open
if(InpAllowNewsHolding)
{
if(g_newsState.restrictedWindow)
g_newsState.holdingStatus = NEWS_HOLDING_ALLOWED;
else
g_newsState.holdingStatus = NEWS_HOLDING_WARNING;
return;
}
//--- Warn while affected positions approach the restricted window
if(!g_newsState.restrictedWindow)
{
g_newsState.holdingStatus = NEWS_HOLDING_WARNING;
return;
}
//--- Mark affected positions when holding is prohibited in the window
for(int i = 0; i < totalMatches; i++)
{
if(g_newsPositionMatches[i].status != NEWS_POSITION_AFFECTED)
continue;
g_newsPositionMatches[i].protectionRequired = true;
g_newsState.protectionPositions++;
}
g_newsState.holdingStatus = NEWS_HOLDING_PROTECTION;
}
//+------------------------------------------------------------------+
//| Update news position matches |
//+------------------------------------------------------------------+
void UpdateNewsPositionMatches()
{
//--- Classify all currently open positions against the selected event
MatchOpenPositionsToNews();
//--- Apply the configured holding rule to those classifications
EvaluateNewsHoldingRules();
}
//+------------------------------------------------------------------+
//| Add currencies exposed by position symbol |
//+------------------------------------------------------------------+
bool AddPositionCurrencies(const string symbol,
string &currencies[])
{
string currency1;
string currency2;
//--- Determine the supported news currencies for the position symbol
if(!GetSymbolNewsCurrencies(symbol,
currency1,
currency2))
return(false);
//--- Ignore instruments outside the supported monitoring scope
if(currency1 == "" &&
currency2 == "")
return(true);
//--- Add the exposed currencies without creating duplicates
if(!AddUniqueCurrency(currencies, currency1))
return(false);
if(!AddUniqueCurrency(currencies, currency2))
return(false);
return(true);
}
//+------------------------------------------------------------------+
//| Collect currencies from active positions |
//+------------------------------------------------------------------+
bool CollectExposureCurrencies(string &currencies[])
{
//--- Start each collection with an empty exposure set
ArrayResize(currencies, 0);
int totalPositions = PositionsTotal();
//--- No open positions means there is currently no news exposure
if(totalPositions == 0)
return(true);
//--- Inspect every currently open account position
for(int i = 0; i < totalPositions; i++)
{
ResetLastError();
string symbol = PositionGetSymbol(i);
if(symbol == "")
{
Print("Prop Firm Guard: Could not retrieve position symbol at index ",
i,
". Error: ",
GetLastError());
return(false);
}
if(!AddPositionCurrencies(symbol, currencies))
return(false);
}
return(true);
}
//+------------------------------------------------------------------+
//| Build monitored currency list |
//+------------------------------------------------------------------+
string BuildCurrencyList(const string &currencies[])
{
string result = "";
int count = ArraySize(currencies);
//--- Append each currency using a comma-separated format
for(int i = 0; i < count; i++)
{
if(i > 0)
result += ", ";
result += currencies[i];
}
return(result);
}
//+------------------------------------------------------------------+
//| Find next news event for currency |
//+------------------------------------------------------------------+
bool FindNextNewsForCurrency(const string currency,
const datetime timeFrom,
const datetime timeTo,
MqlCalendarValue &bestValue,
MqlCalendarEvent &bestEvent)
{
MqlCalendarValue values[];
ResetLastError();
//--- Request calendar values for the specified currency and time range
int valueCount = CalendarValueHistory(values,
timeFrom,
timeTo,
NULL,
currency);
if(valueCount < 0)
{
Print("Prop Firm Guard: Could not retrieve calendar values for ",
currency,
". Error: ",
GetLastError());
return(false);
}
bool eventFound = false;
datetime earliestTime = 0;
//--- Inspect the calendar values returned for this currency
for(int i = 0; i < valueCount; i++)
{
MqlCalendarEvent event;
ResetLastError();
if(!CalendarEventById(values[i].event_id,
event))
{
Print("Prop Firm Guard: Could not retrieve calendar event ",
values[i].event_id,
". Error: ",
GetLastError());
continue;
}
//--- Reject events below the configured minimum importance
if(event.importance < InpNewsImportance)
continue;
//--- Require a calendar event with an exact release time
if(event.time_mode != CALENDAR_TIMEMODE_DATETIME)
continue;
//--- Keep the earliest qualifying event in the search interval
if(!eventFound ||
values[i].time < earliestTime)
{
bestValue = values[i];
bestEvent = event;
earliestTime = values[i].time;
eventFound = true;
}
}
return(eventFound);
}
//+------------------------------------------------------------------+
//| Update news state |
//+------------------------------------------------------------------+
void UpdateNewsState()
{
//--- Clear the previous exposure and event state
InitializeNewsState();
//--- Stop immediately when economic-news monitoring is disabled
if(!InpEnableNewsFilter)
{
g_newsState.status = NEWS_DISABLED;
return;
}
string currencies[];
//--- Collect one unique currency set from all supported open positions
if(!CollectExposureCurrencies(currencies))
{
g_newsState.status = NEWS_UNAVAILABLE;
return;
}
int currencyCount = ArraySize(currencies);
//--- No supported exposure means there is nothing to search
if(currencyCount == 0)
{
g_newsState.hasExposure = false;
g_newsState.monitoredCurrencies = 0;
g_newsState.currencyList = "";
g_newsState.status = NEWS_NO_EXPOSURE;
return;
}
//--- Store the current account-exposure summary
g_newsState.hasExposure = true;
g_newsState.monitoredCurrencies = currencyCount;
g_newsState.currencyList = BuildCurrencyList(currencies);
//--- Use trade-server time for calendar and restriction calculations
datetime currentTime = TimeTradeServer();
datetime searchFrom =
currentTime -
InpMinutesAfterNews * 60;
datetime searchTo =
currentTime +
24 * 60 * 60;
bool foundAny = false;
ulong selectedEventId = 0;
string selectedEventName = "";
string selectedCurrency = "";
ENUM_CALENDAR_EVENT_IMPORTANCE selectedImportance =
CALENDAR_IMPORTANCE_NONE;
datetime selectedEventTime = 0;
//--- Search each exposed currency and retain the nearest event
for(int i = 0; i < currencyCount; i++)
{
MqlCalendarValue candidateValue;
MqlCalendarEvent candidateEvent;
if(!FindNextNewsForCurrency(currencies[i],
searchFrom,
searchTo,
candidateValue,
candidateEvent))
continue;
if(!foundAny ||
candidateValue.time < selectedEventTime)
{
selectedEventId = candidateEvent.id;
selectedEventName = candidateEvent.name;
selectedCurrency = currencies[i];
selectedImportance = candidateEvent.importance;
selectedEventTime = candidateValue.time;
foundAny = true;
}
}
//--- Report an exposed account with no qualifying event
if(!foundAny)
{
g_newsState.status = NEWS_NO_EVENT;
return;
}
//--- Store the nearest qualifying event across all exposed currencies
g_newsState.eventFound = true;
g_newsState.eventCurrency = selectedCurrency;
g_newsState.eventId = selectedEventId;
g_newsState.eventName = selectedEventName;
g_newsState.importance = selectedImportance;
g_newsState.eventTime = selectedEventTime;
//--- Calculate the signed distance from the current server time
g_newsState.secondsToEvent =
(long)(g_newsState.eventTime - currentTime);
//--- Build the configured restriction interval
g_newsState.restrictionStart =
g_newsState.eventTime -
InpMinutesBeforeNews * 60;
g_newsState.restrictionEnd =
g_newsState.eventTime +
InpMinutesAfterNews * 60;
//--- Determine whether the current time is inside that interval
g_newsState.restrictedWindow =
(currentTime >= g_newsState.restrictionStart &&
currentTime <= g_newsState.restrictionEnd);
if(g_newsState.restrictedWindow)
g_newsState.status = NEWS_RESTRICTED;
else
g_newsState.status = NEWS_SAFE;
}
//+------------------------------------------------------------------+
//| Format news countdown |
//+------------------------------------------------------------------+
string FormatNewsCountdown(const long secondsToEvent)
{
long absoluteSeconds = secondsToEvent;
//--- Convert the signed value into a duration for formatting
if(absoluteSeconds < 0)
absoluteSeconds = -absoluteSeconds;
int hours = (int)(absoluteSeconds / 3600);
int minutes = (int)((absoluteSeconds % 3600) / 60);
int seconds = (int)(absoluteSeconds % 60);
string formatted =
StringFormat("%02d:%02d:%02d",
hours,
minutes,
seconds);
//--- Prefix elapsed post-event time with a plus sign
if(secondsToEvent >= 0)
return(formatted);
return("+" + formatted);
}
//+------------------------------------------------------------------+
//| Get trading date |
//+------------------------------------------------------------------+
string GetTradingDate()
{
//--- Build the session date from trading-server time
datetime serverTime = TimeCurrent();
return(TimeToString(serverTime, TIME_DATE));
}
//+------------------------------------------------------------------+
//| Open database |
//+------------------------------------------------------------------+
bool OpenDatabase()
{
//--- Open or create the SQLite database
ResetLastError();
g_database = DatabaseOpen(g_databaseName,
DATABASE_OPEN_READWRITE |
DATABASE_OPEN_CREATE);
if(g_database == INVALID_HANDLE)
{
Print("Prop Firm Guard: Could not open database ",
g_databaseName,
". Error: ",
GetLastError());
return(false);
}
Print("Prop Firm Guard: Database opened successfully: ",
g_databaseName);
return(true);
}
//+------------------------------------------------------------------+
//| Close database |
//+------------------------------------------------------------------+
void CloseDatabase()
{
//--- Ignore the request when no database connection is active
if(g_database == INVALID_HANDLE)
return;
//--- Close the active SQLite connection
ResetLastError();
DatabaseClose(g_database);
int errorCode = GetLastError();
if(errorCode != 0)
{
Print("Prop Firm Guard: Database close reported error: ",
errorCode);
}
else
{
Print("Prop Firm Guard: Database closed successfully.");
}
//--- Clear the stored database handle
g_database = INVALID_HANDLE;
}
//+------------------------------------------------------------------+
//| Check whether database column exists |
//+------------------------------------------------------------------+
bool DatabaseColumnExists(const string tableName,
const string columnName)
{
//--- Inspect the current table schema
string sql = "PRAGMA table_info(" + tableName + ");";
ResetLastError();
int request = DatabasePrepare(g_database,
sql);
if(request == INVALID_HANDLE)
{
Print("Prop Firm Guard: Could not inspect table ",
tableName,
". Error: ",
GetLastError());
return(false);
}
bool columnFound = false;
//--- Search the returned schema rows for the requested column
while(true)
{
ResetLastError();
if(!DatabaseRead(request))
{
int errorCode = GetLastError();
if(errorCode != ERR_DATABASE_NO_MORE_DATA)
{
Print("Prop Firm Guard: Could not read schema for ",
tableName,
". Error: ",
errorCode);
}
break;
}
string currentColumn;
//--- PRAGMA table_info returns the column name at index 1
if(!DatabaseColumnText(request,
1,
currentColumn))
{
Print("Prop Firm Guard: Could not read database column name. Error: ",
GetLastError());
break;
}
if(currentColumn == columnName)
{
columnFound = true;
break;
}
}
//--- Release the schema request
FinalizeDatabaseRequest(request);
return(columnFound);
}
//+------------------------------------------------------------------+
//| Ensure database column exists |
//+------------------------------------------------------------------+
bool EnsureDatabaseColumn(const string tableName,
const string columnName,
const string columnDefinition)
{
//--- Leave an existing column unchanged
if(DatabaseColumnExists(tableName,
columnName))
return(true);
//--- Add the missing column
string sql =
"ALTER TABLE " +
tableName +
" ADD COLUMN " +
columnName +
" " +
columnDefinition +
";";
ResetLastError();
if(!DatabaseExecute(g_database,
sql))
{
Print("Prop Firm Guard: Could not add column ",
columnName,
" to ",
tableName,
". Error: ",
GetLastError());
return(false);
}
Print("Prop Firm Guard: Added database column ",
tableName,
".",
columnName,
".");
return(true);
}
//+------------------------------------------------------------------+
//| Ensure runtime daily-session columns exist |
//+------------------------------------------------------------------+
bool EnsureDailySessionRuntimeColumns()
{
//--- Add runtime persistence columns when missing
if(!EnsureDatabaseColumn("daily_sessions",
"latest_balance",
"REAL NOT NULL DEFAULT 0"))
return(false);
if(!EnsureDatabaseColumn("daily_sessions",
"latest_equity",
"REAL NOT NULL DEFAULT 0"))
return(false);
if(!EnsureDatabaseColumn("daily_sessions",
"daily_loss",
"REAL NOT NULL DEFAULT 0"))
return(false);
if(!EnsureDatabaseColumn("daily_sessions",
"maximum_daily_loss_reached",
"REAL NOT NULL DEFAULT 0"))
return(false);
if(!EnsureDatabaseColumn("daily_sessions",
"target_progress",
"REAL NOT NULL DEFAULT 0"))
return(false);
if(!EnsureDatabaseColumn("daily_sessions",
"session_status",
"TEXT NOT NULL DEFAULT 'AWAITING_CONFIRMATION'"))
return(false);
return(true);
}
//+------------------------------------------------------------------+
//| Ensure database tables exist |
//+------------------------------------------------------------------+
bool EnsureDatabaseTables()
{
//--- Define account-level settings storage
string settingsTable =
"CREATE TABLE IF NOT EXISTS settings ("
"account_login INTEGER NOT NULL,"
"account_server TEXT NOT NULL,"
"initial_balance REAL NOT NULL,"
"daily_drawdown_percent REAL NOT NULL,"
"overall_drawdown_percent REAL NOT NULL,"
"profit_target_percent REAL NOT NULL,"
"updated_at INTEGER NOT NULL,"
"PRIMARY KEY(account_login, account_server)"
");";
//--- Define persistent trading-day storage
string dailySessionsTable =
"CREATE TABLE IF NOT EXISTS daily_sessions ("
"account_login INTEGER NOT NULL,"
"account_server TEXT NOT NULL,"
"trading_date TEXT NOT NULL,"
"starting_balance REAL NOT NULL,"
"starting_equity REAL NOT NULL,"
"balance_confirmed INTEGER NOT NULL,"
"latest_balance REAL NOT NULL DEFAULT 0,"
"latest_equity REAL NOT NULL DEFAULT 0,"
"daily_loss REAL NOT NULL DEFAULT 0,"
"maximum_daily_loss_reached REAL NOT NULL DEFAULT 0,"
"target_progress REAL NOT NULL DEFAULT 0,"
"session_status TEXT NOT NULL DEFAULT 'AWAITING_CONFIRMATION',"
"created_at INTEGER NOT NULL,"
"updated_at INTEGER NOT NULL,"
"PRIMARY KEY(account_login, account_server, trading_date)"
");";
//--- Ensure the account settings table exists
ResetLastError();
if(!DatabaseExecute(g_database,
settingsTable))
{
Print("Prop Firm Guard: Could not create settings table. Error: ",
GetLastError());
return(false);
}
//--- Ensure the daily-session table exists
ResetLastError();
if(!DatabaseExecute(g_database,
dailySessionsTable))
{
Print("Prop Firm Guard: Could not create daily_sessions table. Error: ",
GetLastError());
return(false);
}
//--- Extend an existing daily-session table when required
if(!EnsureDailySessionRuntimeColumns())
return(false);
return(true);
}
//+------------------------------------------------------------------+
//| Check for new trading day |
//+------------------------------------------------------------------+
void CheckForNewTradingDay()
{
//--- Read the current server-based trading date
string currentDate = GetTradingDate();
//--- Keep the active session when it already belongs to today
if(g_hasDailySession &&
g_dailySession.tradingDate == currentDate)
return;
Print("Prop Firm Guard: New trading day detected: ",
currentDate);
//--- Restore or create the session for the new trading date
if(!InitializeDailySession())
{
Print("Prop Firm Guard: Could not initialize the new daily session.");
return;
}
//--- Rebuild the confirmation controls for the newly loaded session
DeleteDailySessionControls();
if(!CreateDailySessionControls())
{
Print("Prop Firm Guard: Could not create daily session controls.");
}
}
//+------------------------------------------------------------------+
//| Finalize database request |
//+------------------------------------------------------------------+
void FinalizeDatabaseRequest(const int request)
{
//--- Ignore invalid database requests
if(request == INVALID_HANDLE)
return;
//--- Release the prepared database request
ResetLastError();
DatabaseFinalize(request);
int errorCode = GetLastError();
if(errorCode != 0)
{
Print("Prop Firm Guard: Could not finalize database request. Error: ",
errorCode);
}
}
//+------------------------------------------------------------------+
//| Execute prepared database statement |
//+------------------------------------------------------------------+
bool ExecuteDatabaseRequest(const int request,
const string operation)
{
//--- Execute the prepared database statement
ResetLastError();
bool result = DatabaseRead(request);
int errorCode = GetLastError();
//--- Accept normal completion when no result row is returned
bool success =
(result || errorCode == ERR_DATABASE_NO_MORE_DATA);
if(!success)
{
Print("Prop Firm Guard: Database error while ",
operation,
". Error: ",
errorCode);
}
//--- Release the request after execution
FinalizeDatabaseRequest(request);
return(success);
}
//+------------------------------------------------------------------+
//| Save account settings |
//+------------------------------------------------------------------+
bool SaveAccountSettings()
{
//--- Prepare the account-settings write statement
string sql =
"INSERT OR REPLACE INTO settings ("
"account_login,"
"account_server,"
"initial_balance,"
"daily_drawdown_percent,"
"overall_drawdown_percent,"
"profit_target_percent,"
"updated_at"
") VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7);";
int request = DatabasePrepare(g_database, sql);
if(request == INVALID_HANDLE)
{
Print("Prop Firm Guard: Could not prepare settings save request. Error: ",
GetLastError());
return(false);
}
//--- Bind the current account settings to the prepared statement
if(!DatabaseBind(request, 0, g_accountSettings.accountLogin) ||
!DatabaseBind(request, 1, g_accountSettings.accountServer) ||
!DatabaseBind(request, 2, g_accountSettings.initialBalance) ||
!DatabaseBind(request, 3, g_accountSettings.dailyDrawdownPercent) ||
!DatabaseBind(request, 4, g_accountSettings.overallDrawdownPercent) ||
!DatabaseBind(request, 5, g_accountSettings.profitTargetPercent) ||
!DatabaseBind(request, 6, g_accountSettings.updatedAt))
{
Print("Prop Firm Guard: Could not bind settings values. Error: ",
GetLastError());
FinalizeDatabaseRequest(request);
return(false);
}
//--- Execute and finalize the prepared write request
if(!ExecuteDatabaseRequest(request, "saving account settings"))
return(false);
return(true);
}
//+------------------------------------------------------------------+
//| Load account settings |
//+------------------------------------------------------------------+
bool LoadAccountSettings()
{
//--- Build the current account/server lookup
string accountServer = AccountInfoString(ACCOUNT_SERVER);
string sql =
"SELECT "
"account_login,"
"account_server,"
"initial_balance,"
"daily_drawdown_percent,"
"overall_drawdown_percent,"
"profit_target_percent,"
"updated_at "
"FROM settings "
"WHERE account_login = ?1 AND account_server = ?2;";
int request = DatabasePrepare(g_database, sql);
if(request == INVALID_HANDLE)
{
Print("Prop Firm Guard: Could not prepare settings load request. Error: ",
GetLastError());
return(false);
}
//--- Bind the current account identity
if(!DatabaseBind(request, 0, g_accountState.login) ||
!DatabaseBind(request, 1, accountServer))
{
Print("Prop Firm Guard: Could not bind settings search values. Error: ",
GetLastError());
FinalizeDatabaseRequest(request);
return(false);
}
//--- Read the matching settings record
ResetLastError();
if(!DatabaseRead(request))
{
int errorCode = GetLastError();
FinalizeDatabaseRequest(request);
//--- No row means this account/server pair has not been saved yet
if(errorCode == ERR_DATABASE_NO_MORE_DATA)
return(false);
Print("Prop Firm Guard: Could not read account settings. Error: ",
errorCode);
return(false);
}
//--- Read and validate the stored column values
long accountLogin;
string storedServer;
double initialBalance;
double dailyDrawdown;
double overallDrawdown;
double profitTarget;
long updatedAt;
if(!DatabaseColumnLong(request, 0, accountLogin) ||
!DatabaseColumnText(request, 1, storedServer) ||
!DatabaseColumnDouble(request, 2, initialBalance) ||
!DatabaseColumnDouble(request, 3, dailyDrawdown) ||
!DatabaseColumnDouble(request, 4, overallDrawdown) ||
!DatabaseColumnDouble(request, 5, profitTarget) ||
!DatabaseColumnLong(request, 6, updatedAt))
{
Print("Prop Firm Guard: Could not read stored settings columns. Error: ",
GetLastError());
FinalizeDatabaseRequest(request);
return(false);
}
//--- Restore the stored values into the account settings structure
g_accountSettings.accountLogin = accountLogin;
g_accountSettings.accountServer = storedServer;
g_accountSettings.initialBalance = initialBalance;
g_accountSettings.dailyDrawdownPercent = dailyDrawdown;
g_accountSettings.overallDrawdownPercent = overallDrawdown;
g_accountSettings.profitTargetPercent = profitTarget;
g_accountSettings.updatedAt = (datetime)updatedAt;
//--- Release the completed read request
FinalizeDatabaseRequest(request);
return(true);
}
//+------------------------------------------------------------------+
//| Initialize daily session |
//+------------------------------------------------------------------+
bool InitializeDailySession()
{
//--- Identify the current trading day
string tradingDate = GetTradingDate();
//--- Restore today's session when it already exists
if(DailySessionExists(tradingDate))
{
if(!LoadDailySession())
return(false);
g_hasDailySession = true;
Print("Prop Firm Guard: Daily session restored for ",
tradingDate,
".");
return(true);
}
//--- Create a new unconfirmed session for the current trading day
g_dailySession.accountLogin = g_accountState.login;
g_dailySession.accountServer = AccountInfoString(ACCOUNT_SERVER);
g_dailySession.tradingDate = tradingDate;
g_dailySession.startingBalance = 0.0;
g_dailySession.startingEquity = 0.0;
g_dailySession.balanceConfirmed = false;
g_dailySession.latestBalance = g_accountState.balance;
g_dailySession.latestEquity = g_accountState.equity;
g_dailySession.dailyLoss = 0.0;
g_dailySession.maximumDailyLossReached = 0.0;
g_dailySession.targetProgress = 0.0;
g_dailySession.sessionStatus = "AWAITING_CONFIRMATION";
g_dailySession.createdAt = TimeCurrent();
g_dailySession.updatedAt = TimeCurrent();
//--- Persist the new daily-session record
if(!SaveDailySession())
return(false);
g_hasDailySession = true;
Print("Prop Firm Guard: New daily session created for ",
tradingDate,
".");
return(true);
}
//+------------------------------------------------------------------+
//| Initialize account settings |
//+------------------------------------------------------------------+
bool InitializeAccountSettings()
{
//--- Check whether this account/server pair already has stored settings
bool settingsFound = LoadAccountSettings();
//--- Associate the settings with the current trading account
g_accountSettings.accountLogin = g_accountState.login;
g_accountSettings.accountServer = AccountInfoString(ACCOUNT_SERVER);
//--- Synchronize persistence with the current Inputs values
g_accountSettings.initialBalance = InpInitialAccountBalance;
g_accountSettings.dailyDrawdownPercent = InpDailyDrawdownPercent;
g_accountSettings.overallDrawdownPercent = InpOverallDrawdownPercent;
g_accountSettings.profitTargetPercent = InpProfitTargetPercent;
g_accountSettings.updatedAt = TimeCurrent();
//--- Save the synchronized configuration
if(!SaveAccountSettings())
return(false);
//--- Report whether the record was created or synchronized
if(settingsFound)
Print("Prop Firm Guard: Account settings restored and synchronized.");
else
Print("Prop Firm Guard: New account settings saved.");
return(true);
}
//+------------------------------------------------------------------+
//| Save daily session |
//+------------------------------------------------------------------+
bool SaveDailySession()
{
//--- Prepare the complete daily-session record
string sql =
"INSERT OR REPLACE INTO daily_sessions ("
"account_login,"
"account_server,"
"trading_date,"
"starting_balance,"
"starting_equity,"
"balance_confirmed,"
"latest_balance,"
"latest_equity,"
"daily_loss,"
"maximum_daily_loss_reached,"
"target_progress,"
"session_status,"
"created_at,"
"updated_at"
") VALUES ("
"?1,?2,?3,?4,?5,?6,?7,?8,?9,?10,?11,?12,?13,?14"
");";
ResetLastError();
int request = DatabasePrepare(g_database,
sql,
g_dailySession.accountLogin,
g_dailySession.accountServer,
g_dailySession.tradingDate,
g_dailySession.startingBalance,
g_dailySession.startingEquity,
g_dailySession.balanceConfirmed ? 1 : 0,
g_dailySession.latestBalance,
g_dailySession.latestEquity,
g_dailySession.dailyLoss,
g_dailySession.maximumDailyLossReached,
g_dailySession.targetProgress,
g_dailySession.sessionStatus,
(long)g_dailySession.createdAt,
(long)g_dailySession.updatedAt);
if(request == INVALID_HANDLE)
{
Print("Prop Firm Guard: Could not prepare daily session save request. Error: ",
GetLastError());
return(false);
}
//--- Execute and finalize the prepared write request
return(ExecuteDatabaseRequest(request,
"saving daily session"));
}
//+------------------------------------------------------------------+
//| Load daily session |
//+------------------------------------------------------------------+
bool LoadDailySession()
{
//--- Select the session belonging to the current account and date
string sql =
"SELECT "
"account_login,"
"account_server,"
"trading_date,"
"starting_balance,"
"starting_equity,"
"balance_confirmed,"
"latest_balance,"
"latest_equity,"
"daily_loss,"
"maximum_daily_loss_reached,"
"target_progress,"
"session_status,"
"created_at,"
"updated_at "
"FROM daily_sessions "
"WHERE account_login=?1 "
"AND account_server=?2 "
"AND trading_date=?3;";
string tradingDate = GetTradingDate();
string accountServer = AccountInfoString(ACCOUNT_SERVER);
ResetLastError();
int request = DatabasePrepare(g_database,
sql,
g_accountState.login,
accountServer,
tradingDate);
if(request == INVALID_HANDLE)
{
Print("Prop Firm Guard: Could not prepare daily session load request. Error: ",
GetLastError());
return(false);
}
//--- Read the matching record
ResetLastError();
if(!DatabaseRead(request))
{
int errorCode = GetLastError();
if(errorCode != ERR_DATABASE_NO_MORE_DATA)
{
Print("Prop Firm Guard: Could not load daily session. Error: ",
errorCode);
}
FinalizeDatabaseRequest(request);
return(false);
}
//--- Read all stored values before updating the in-memory session
long accountLogin;
string loadedServer;
string loadedDate;
double startingBalance;
double startingEquity;
int balanceConfirmed;
double latestBalance;
double latestEquity;
double dailyLoss;
double maximumDailyLossReached;
double targetProgress;
string sessionStatus;
long createdAt;
long updatedAt;
bool loaded =
DatabaseColumnLong(request, 0, accountLogin) &&
DatabaseColumnText(request, 1, loadedServer) &&
DatabaseColumnText(request, 2, loadedDate) &&
DatabaseColumnDouble(request, 3, startingBalance) &&
DatabaseColumnDouble(request, 4, startingEquity) &&
DatabaseColumnInteger(request, 5, balanceConfirmed) &&
DatabaseColumnDouble(request, 6, latestBalance) &&
DatabaseColumnDouble(request, 7, latestEquity) &&
DatabaseColumnDouble(request, 8, dailyLoss) &&
DatabaseColumnDouble(request, 9, maximumDailyLossReached) &&
DatabaseColumnDouble(request, 10, targetProgress) &&
DatabaseColumnText(request, 11, sessionStatus) &&
DatabaseColumnLong(request, 12, createdAt) &&
DatabaseColumnLong(request, 13, updatedAt);
if(!loaded)
{
Print("Prop Firm Guard: Could not read daily session columns. Error: ",
GetLastError());
FinalizeDatabaseRequest(request);
return(false);
}
//--- Restore the complete daily-session state
g_dailySession.accountLogin = accountLogin;
g_dailySession.accountServer = loadedServer;
g_dailySession.tradingDate = loadedDate;
g_dailySession.startingBalance = startingBalance;
g_dailySession.startingEquity = startingEquity;
g_dailySession.balanceConfirmed = (balanceConfirmed != 0);
g_dailySession.latestBalance = latestBalance;
g_dailySession.latestEquity = latestEquity;
g_dailySession.dailyLoss = dailyLoss;
g_dailySession.maximumDailyLossReached = maximumDailyLossReached;
g_dailySession.targetProgress = targetProgress;
g_dailySession.sessionStatus = sessionStatus;
g_dailySession.createdAt = (datetime)createdAt;
g_dailySession.updatedAt = (datetime)updatedAt;
//--- Release the completed read request
FinalizeDatabaseRequest(request);
return(true);
}
//+------------------------------------------------------------------+
//| Check daily session existence |
//+------------------------------------------------------------------+
bool DailySessionExists(const string tradingDate)
{
//--- Build the session identity for the requested trading date
string accountServer = AccountInfoString(ACCOUNT_SERVER);
string sql =
"SELECT 1 "
"FROM daily_sessions "
"WHERE account_login = ?1 "
"AND account_server = ?2 "
"AND trading_date = ?3 "
"LIMIT 1;";
int request = DatabasePrepare(g_database, sql);
if(request == INVALID_HANDLE)
{
Print("Prop Firm Guard: Could not prepare session existence request. Error: ",
GetLastError());
return(false);
}
//--- Bind the current account, server, and requested date
if(!DatabaseBind(request, 0, g_accountState.login) ||
!DatabaseBind(request, 1, accountServer) ||
!DatabaseBind(request, 2, tradingDate))
{
Print("Prop Firm Guard: Could not bind session existence values. Error: ",
GetLastError());
FinalizeDatabaseRequest(request);
return(false);
}
//--- Check whether one matching row exists
ResetLastError();
bool exists = DatabaseRead(request);
int errorCode = GetLastError();
FinalizeDatabaseRequest(request);
if(!exists && errorCode != ERR_DATABASE_NO_MORE_DATA)
{
Print("Prop Firm Guard: Could not check daily session existence. Error: ",
errorCode);
}
return(exists);
}
//+------------------------------------------------------------------+
//| Create starting balance edit |
//+------------------------------------------------------------------+
bool CreateStartingBalanceEdit(const int x,
const int y,
const string suggestedBalance)
{
//--- Create the editable starting-balance field
if(!ObjectCreate(0,
g_startBalanceEdit,
OBJ_EDIT,
0,
0,
0))
{
Print("Prop Firm Guard: Could not create starting balance field. Error: ",
GetLastError());
return(false);
}
//--- Configure the field position and appearance
if(!ObjectSetInteger(0,
g_startBalanceEdit,
OBJPROP_CORNER,
CORNER_LEFT_UPPER) ||
!ObjectSetInteger(0,
g_startBalanceEdit,
OBJPROP_XDISTANCE,
x) ||
!ObjectSetInteger(0,
g_startBalanceEdit,
OBJPROP_YDISTANCE,
y) ||
!ObjectSetInteger(0,
g_startBalanceEdit,
OBJPROP_XSIZE,
120) ||
!ObjectSetInteger(0,
g_startBalanceEdit,
OBJPROP_YSIZE,
20) ||
!ObjectSetInteger(0,
g_startBalanceEdit,
OBJPROP_FONTSIZE,
9) ||
!ObjectSetInteger(0,
g_startBalanceEdit,
OBJPROP_COLOR,
clrBlack) ||
!ObjectSetInteger(0,
g_startBalanceEdit,
OBJPROP_BGCOLOR,
clrWhite) ||
!ObjectSetInteger(0,
g_startBalanceEdit,
OBJPROP_BORDER_COLOR,
clrSilver) ||
!ObjectSetInteger(0,
g_startBalanceEdit,
OBJPROP_ALIGN,
ALIGN_RIGHT) ||
!ObjectSetInteger(0,
g_startBalanceEdit,
OBJPROP_HIDDEN,
true))
{
Print("Prop Firm Guard: Could not configure starting balance field. Error: ",
GetLastError());
return(false);
}
//--- Apply the suggested balance and text properties
if(!ObjectSetString(0,
g_startBalanceEdit,
OBJPROP_FONT,
"Tahoma") ||
!ObjectSetString(0,
g_startBalanceEdit,
OBJPROP_TEXT,
suggestedBalance))
{
Print("Prop Firm Guard: Could not initialize starting balance field. Error: ",
GetLastError());
return(false);
}
return(true);
}
//+------------------------------------------------------------------+
//| Create confirm balance button |
//+------------------------------------------------------------------+
bool CreateConfirmBalanceButton(const int x,
const int y)
{
//--- Create the daily-balance confirmation button
if(!ObjectCreate(0,
g_confirmButton,
OBJ_BUTTON,
0,
0,
0))
{
Print("Prop Firm Guard: Could not create confirmation button. Error: ",
GetLastError());
return(false);
}
//--- Configure the button position and appearance
if(!ObjectSetInteger(0,
g_confirmButton,
OBJPROP_CORNER,
CORNER_LEFT_UPPER) ||
!ObjectSetInteger(0,
g_confirmButton,
OBJPROP_XDISTANCE,
x) ||
!ObjectSetInteger(0,
g_confirmButton,
OBJPROP_YDISTANCE,
y) ||
!ObjectSetInteger(0,
g_confirmButton,
OBJPROP_XSIZE,
100) ||
!ObjectSetInteger(0,
g_confirmButton,
OBJPROP_YSIZE,
20) ||
!ObjectSetInteger(0,
g_confirmButton,
OBJPROP_FONTSIZE,
9) ||
!ObjectSetInteger(0,
g_confirmButton,
OBJPROP_COLOR,
clrBlack) ||
!ObjectSetInteger(0,
g_confirmButton,
OBJPROP_BGCOLOR,
clrWhite) ||
!ObjectSetInteger(0,
g_confirmButton,
OBJPROP_BORDER_COLOR,
clrSilver) ||
!ObjectSetInteger(0,
g_confirmButton,
OBJPROP_HIDDEN,
true))
{
Print("Prop Firm Guard: Could not configure confirmation button. Error: ",
GetLastError());
return(false);
}
//--- Apply the button text and font
if(!ObjectSetString(0,
g_confirmButton,
OBJPROP_FONT,
"Tahoma") ||
!ObjectSetString(0,
g_confirmButton,
OBJPROP_TEXT,
"Confirm"))
{
Print("Prop Firm Guard: Could not initialize confirmation button. Error: ",
GetLastError());
return(false);
}
return(true);
}
//+------------------------------------------------------------------+
//| Create daily session controls |
//+------------------------------------------------------------------+
bool CreateDailySessionControls()
{
//--- Skip the controls when today's balance is already confirmed
if(g_dailySession.balanceConfirmed)
return(true);
int controlX = InpDashboardX + 18;
int controlY = InpDashboardY + 120;
//--- Suggest the current balance without confirming it
string suggestedBalance =
DoubleToString(g_accountState.balance, 2);
//--- Create the editable starting-balance field
if(!CreateStartingBalanceEdit(controlX,
controlY,
suggestedBalance))
return(false);
//--- Create the confirmation button beside the edit field
if(!CreateConfirmBalanceButton(controlX + 130,
controlY))
return(false);
return(true);
}
//+------------------------------------------------------------------+
//| Delete daily session controls |
//+------------------------------------------------------------------+
void DeleteDailySessionControls()
{
//--- Remove the starting-balance field when present
if(ObjectFind(0, g_startBalanceEdit) >= 0)
{
if(!ObjectDelete(0, g_startBalanceEdit))
{
Print("Prop Firm Guard: Could not delete starting balance field. Error: ",
GetLastError());
}
}
//--- Remove the confirmation button when present
if(ObjectFind(0, g_confirmButton) >= 0)
{
if(!ObjectDelete(0, g_confirmButton))
{
Print("Prop Firm Guard: Could not delete confirmation button. Error: ",
GetLastError());
}
}
ChartRedraw();
}
//+------------------------------------------------------------------+
//| Confirm daily starting balance |
//+------------------------------------------------------------------+
bool ConfirmDailyStartingBalance()
{
//--- Do not overwrite an already confirmed daily baseline
if(g_dailySession.balanceConfirmed)
{
Print("Prop Firm Guard: Today's starting balance is already confirmed.");
return(true);
}
string balanceText;
ResetLastError();
//--- Read the value entered in the starting-balance field
if(!ObjectGetString(0,
g_startBalanceEdit,
OBJPROP_TEXT,
0,
balanceText))
{
Print("Prop Firm Guard: Could not read starting balance field. Error: ",
GetLastError());
return(false);
}
double startingBalance = StringToDouble(balanceText);
//--- Reject an invalid daily starting balance
if(startingBalance <= 0.0)
{
Alert("Prop Firm Guard: Enter a valid starting balance greater than zero.");
return(false);
}
//--- Store the confirmed daily reference
g_dailySession.startingBalance = startingBalance;
g_dailySession.startingEquity = g_accountState.equity;
g_dailySession.balanceConfirmed = true;
g_dailySession.updatedAt = TimeCurrent();
//--- Persist the confirmed session immediately
if(!SaveDailySession())
{
Print("Prop Firm Guard: Could not save confirmed daily session.");
//--- Do not report a confirmed state that SQLite failed to preserve
g_dailySession.balanceConfirmed = false;
return(false);
}
Print("Prop Firm Guard: Daily starting balance confirmed at ",
DoubleToString(g_dailySession.startingBalance, 2),
" for ",
g_dailySession.tradingDate,
".");
//--- Remove controls after the confirmed value has been stored
DeleteDailySessionControls();
return(true);
}
//+------------------------------------------------------------------+
//| Convert compliance status to text |
//+------------------------------------------------------------------+
string ComplianceStatusToString(const ENUM_COMPLIANCE_STATUS status)
{
switch(status)
{
case COMPLIANCE_WARNING:
return("WARNING");
case COMPLIANCE_CRITICAL:
return("CRITICAL");
case COMPLIANCE_BREACHED:
return("BREACHED");
case COMPLIANCE_SAFE:
default:
return("SAFE");
}
}
//+------------------------------------------------------------------+
//| Convert target status to text |
//+------------------------------------------------------------------+
string TargetStatusToString(const ENUM_TARGET_STATUS status)
{
switch(status)
{
case TARGET_NEARING:
return("NEARING TARGET");
case TARGET_REACHED:
return("TARGET REACHED");
case TARGET_IN_PROGRESS:
default:
return("IN PROGRESS");
}
}
//+------------------------------------------------------------------+
//| Get overall guard status |
//+------------------------------------------------------------------+
ENUM_GUARD_STATUS GetOverallGuardStatus()
{
//--- Give the highest priority to any drawdown breach
if(g_dailyDrawdown.status == COMPLIANCE_BREACHED ||
g_overallDrawdown.status == COMPLIANCE_BREACHED)
return(GUARD_BREACHED);
//--- Check for a critical drawdown condition
if(g_dailyDrawdown.status == COMPLIANCE_CRITICAL ||
g_overallDrawdown.status == COMPLIANCE_CRITICAL)
return(GUARD_CRITICAL);
//--- Check for a warning condition
if(g_dailyDrawdown.status == COMPLIANCE_WARNING ||
g_overallDrawdown.status == COMPLIANCE_WARNING)
return(GUARD_WARNING);
//--- Report target completion only when no risk condition has priority
if(g_profitTarget.status == TARGET_REACHED)
return(GUARD_TARGET_REACHED);
return(GUARD_SAFE);
}
//+------------------------------------------------------------------+
//| Convert guard status to text |
//+------------------------------------------------------------------+
string GuardStatusToString(const ENUM_GUARD_STATUS status)
{
switch(status)
{
case GUARD_BREACHED:
return("BREACHED");
case GUARD_CRITICAL:
return("CRITICAL");
case GUARD_WARNING:
return("WARNING");
case GUARD_TARGET_REACHED:
return("TARGET REACHED");
case GUARD_SAFE:
default:
return("SAFE");
}
}
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
//--- Validate the timer interval
if(InpTimerSeconds < 1)
{
Print("Prop Firm Guard: Timer interval must be at least 1 second.");
return(INIT_PARAMETERS_INCORRECT);
}
//--- Validate the configured compliance inputs
if(!ValidateComplianceInputs())
return(INIT_PARAMETERS_INCORRECT);
//--- Read the current account state
UpdateAccountState();
//--- Open the SQLite database
if(!OpenDatabase())
{
Print("Prop Firm Guard: Database initialization failed.");
return(INIT_FAILED);
}
//--- Ensure the required database tables exist
if(!EnsureDatabaseTables())
{
Print("Prop Firm Guard: Could not initialize database tables.");
CloseDatabase();
return(INIT_FAILED);
}
//--- Restore account-specific settings
if(!InitializeAccountSettings())
{
Print("Prop Firm Guard: Could not initialize account settings.");
CloseDatabase();
return(INIT_FAILED);
}
//--- Restore or create the current daily session
if(!InitializeDailySession())
{
Print("Prop Firm Guard: Could not initialize daily session.");
CloseDatabase();
return(INIT_FAILED);
}
//--- Calculate the initial financial compliance state
CalculateDailyDrawdown();
CalculateOverallDrawdown();
CalculateProfitTarget();
//--- Calculate the initial economic-news state
UpdateNewsState();
//--- Classify positions and evaluate the initial holding state
UpdateNewsPositionMatches();
//--- Start periodic monitoring
if(!EventSetTimer(InpTimerSeconds))
{
Print("Prop Firm Guard: Failed to start the timer. Error: ",
GetLastError());
CloseDatabase();
return(INIT_FAILED);
}
Print("Prop Firm Guard initialized successfully.");
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
//--- Stop periodic events
EventKillTimer();
//--- Remove daily-session controls
DeleteDailySessionControls();
//--- Close the SQLite connection
CloseDatabase();
Print("Prop Firm Guard removed. Deinitialization reason: ", reason);
}
//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick()
{
}
//+------------------------------------------------------------------+
//| Timer function |
//+------------------------------------------------------------------+
void OnTimer()
{
//--- Refresh the current account state
UpdateAccountState();
//--- Maintain the current trading-day session
CheckForNewTradingDay();
//--- Recalculate the financial compliance state
CalculateDailyDrawdown();
CalculateOverallDrawdown();
CalculateProfitTarget();
//--- Refresh the account-level economic-news state
UpdateNewsState();
//--- Refresh position matching and news-holding evaluation
UpdateNewsPositionMatches();
}
//+------------------------------------------------------------------+
//| Chart event function |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
const long &lparam,
const double &dparam,
const string &sparam)
{
//--- Process chart-object clicks only
if(id != CHARTEVENT_OBJECT_CLICK)
return;
//--- Confirm the entered balance when the confirmation button is clicked
if(sparam == g_confirmButton)
{
if(!ConfirmDailyStartingBalance())
Print("Prop Firm Guard: Starting balance confirmation failed.");
}
}
//+------------------------------------------------------------------+
Reference in a new issue View git blame Copy permalink