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

4393 lines
No EOL
149 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. |
//| Additional states will be used as more rules are implemented. |
//+------------------------------------------------------------------+
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 |
//+------------------------------------------------------------------+
//| Combines the monitored rules into one account-level condition. |
//+------------------------------------------------------------------+
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 |
//+------------------------------------------------------------------+
//| Represents the current condition of the economic news filter. |
//+------------------------------------------------------------------+
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 = 0.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
//+------------------------------------------------------------------+
//| Structures |
//+------------------------------------------------------------------+
//| Holds the live account values required by the monitoring logic. |
//| Keeping them together will make later calculations easier. |
//+------------------------------------------------------------------+
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 one monitored trading day. Starting values remain |
//| unconfirmed until the user explicitly confirms them in Phase 3. |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Daily session structure |
//+------------------------------------------------------------------+
struct SDailySession
{
long accountLogin;
string accountServer;
string tradingDate;
double startingBalance;
double startingEquity;
bool balanceConfirmed;
double latestBalance;
double latestEquity;
double dailyLoss;
double maximumDailyLossReached;
double targetProgress;
string sessionStatus;
datetime createdAt;
datetime updatedAt;
};
//+------------------------------------------------------------------+
//| 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 |
//+------------------------------------------------------------------+
//| Holds account exposure, the next relevant economic event, and |
//| the current news-holding condition. |
//+------------------------------------------------------------------+
struct SNewsState
{
bool hasExposure; // Whether supported open positions exist
int monitoredCurrencies; // Number of unique currencies being monitored
string currencyList; // Comma-separated monitored currencies
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; // Seconds until event, negative after release
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; // Positions exposed to Phase 12 protection
ENUM_NEWS_STATUS status; // Current news subsystem status
ENUM_NEWS_HOLDING_STATUS holdingStatus; // Current news-holding rule state
};
//+------------------------------------------------------------------+
//| News position match structure |
//+------------------------------------------------------------------+
//| Stores the classification and holding-rule state of one open |
//| position for the currently selected Economic Calendar event. |
//+------------------------------------------------------------------+
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 Phase 12 may act on this position
};
//+------------------------------------------------------------------+
//| Alert state |
//+------------------------------------------------------------------+
//| Remembers which conditions have already generated notifications. |
//+------------------------------------------------------------------+
struct SAlertState
{
ENUM_COMPLIANCE_STATUS dailyDrawdownStatus;
ENUM_COMPLIANCE_STATUS overallDrawdownStatus;
ENUM_TARGET_STATUS profitTargetStatus;
ulong newsEventId;
bool newsApproachAlerted;
bool newsRestrictedAlerted;
string dashboardMessage;
};
//+------------------------------------------------------------------+
//| 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
SAlertState g_alertState;
CTrade g_trade; // Synchronous trade execution helper
string g_objectPrefix = "PFG_"; // Prefix used by dashboard objects
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; // Current-day session availability
ulong g_lastMatchedEventId = 0; // Last event printed to the Journal
ENUM_NEWS_HOLDING_STATUS g_lastNewsHoldingStatus = NEWS_HOLDING_CLEAR; // Last notified holding condition
bool g_dailyBreachWarned = false; // Prevent repeated daily breach warnings
bool g_overallBreachWarned = false; // Prevent repeated overall breach warnings
ulong g_lastNewsWarnedEventId = 0; // Prevent repeated warning for same news event
datetime g_lastRuntimeDatabaseUpdate = 0;
//+------------------------------------------------------------------+
//| Validate compliance inputs |
//+------------------------------------------------------------------+
bool ValidateComplianceInputs()
{
// Financial calculations require a valid initial challenge balance.
if(InpInitialAccountBalance <= 0.0)
{
Print("Prop Firm Guard: Initial account balance must be greater than zero.");
return(false);
}
if(InpDailyDrawdownPercent <= 0.0 ||
InpDailyDrawdownPercent > 100.0)
{
Print("Prop Firm Guard: Daily drawdown percentage must be between 0 and 100.");
return(false);
}
if(InpOverallDrawdownPercent <= 0.0 ||
InpOverallDrawdownPercent > 100.0)
{
Print("Prop Firm Guard: Overall drawdown percentage must be between 0 and 100.");
return(false);
}
if(InpProfitTargetPercent <= 0.0 ||
InpProfitTargetPercent > 100.0)
{
Print("Prop Firm Guard: Profit target percentage must be between 0 and 100.");
return(false);
}
if(InpWarningLevelPercent <= 0.0 ||
InpWarningLevelPercent >= InpCriticalLevelPercent)
{
Print("Prop Firm Guard: Warning level must be greater than 0 and below the critical level.");
return(false);
}
if(InpCriticalLevelPercent <= InpWarningLevelPercent ||
InpCriticalLevelPercent >= 100.0)
{
Print("Prop Firm Guard: Critical level must be above the warning level and below 100.");
return(false);
}
// News restriction windows cannot use negative durations.
if(InpMinutesBeforeNews < 0 ||
InpMinutesAfterNews < 0)
{
Print("Prop Firm Guard: News restriction minutes cannot be negative.");
return(false);
}
return(true);
}
//+------------------------------------------------------------------+
//| Set chart integer property |
//+------------------------------------------------------------------+
bool SetChartIntegerProperty(const ENUM_CHART_PROPERTY_INTEGER property,
const long value)
{
ResetLastError();
if(!ChartSetInteger(0,
property,
value))
{
Print("Prop Firm Guard: Could not set chart property ",
EnumToString(property),
". Error: ",
GetLastError());
return(false);
}
return(true);
}
//+------------------------------------------------------------------+
//| Configure Prop Firm Guard chart appearance |
//+------------------------------------------------------------------+
bool ConfigureChartAppearance()
{
// Use a light neutral background that keeps the dashboard readable.
if(!SetChartIntegerProperty(CHART_COLOR_BACKGROUND,
clrWhiteSmoke))
return(false);
// Keep axes, scales and chart text clearly visible.
if(!SetChartIntegerProperty(CHART_COLOR_FOREGROUND,
clrBlack))
return(false);
// The dashboard is cleaner without the default chart grid.
if(!SetChartIntegerProperty(CHART_SHOW_GRID,
false))
return(false);
// Display the market as Japanese candlesticks.
if(!SetChartIntegerProperty(CHART_MODE,
CHART_CANDLES))
return(false);
// Bullish candles and bars use green consistently.
if(!SetChartIntegerProperty(CHART_COLOR_CANDLE_BULL,
clrGreen))
return(false);
if(!SetChartIntegerProperty(CHART_COLOR_CHART_UP,
clrGreen))
return(false);
// Bearish candles and bars use red consistently.
if(!SetChartIntegerProperty(CHART_COLOR_CANDLE_BEAR,
clrRed))
return(false);
if(!SetChartIntegerProperty(CHART_COLOR_CHART_DOWN,
clrRed))
return(false);
// Keep the line-chart representation neutral and readable.
if(!SetChartIntegerProperty(CHART_COLOR_CHART_LINE,
clrBlack))
return(false);
// Use the same directional convention for live price lines.
if(!SetChartIntegerProperty(CHART_COLOR_BID,
clrGreen))
return(false);
if(!SetChartIntegerProperty(CHART_COLOR_ASK,
clrRed))
return(false);
// Keep the last traded price visually neutral.
if(!SetChartIntegerProperty(CHART_COLOR_LAST,
clrBlack))
return(false);
// Stop Loss, Take Profit and related stop levels use red because
// they represent important protection boundaries.
if(!SetChartIntegerProperty(CHART_COLOR_STOP_LEVEL,
clrRed))
return(false);
// Show open-position, pending-order, SL and TP levels.
if(!SetChartIntegerProperty(CHART_SHOW_TRADE_LEVELS,
true))
return(false);
// Allow trade levels to remain interactively draggable.
if(!SetChartIntegerProperty(CHART_DRAG_TRADE_LEVELS,
true))
return(false);
// Keep MetaTrader's One Click Trading panel visible.
if(!SetChartIntegerProperty(CHART_SHOW_ONE_CLICK,
true))
return(false);
ChartRedraw(0);
return(true);
}
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
if(InpTimerSeconds < 1)
{
Print("Prop Firm Guard: Timer interval must be at least 1 second.");
return(INIT_PARAMETERS_INCORRECT);
}
if(!ValidateComplianceInputs())
return(INIT_PARAMETERS_INCORRECT);
// Apply the visual chart theme before creating dashboard objects.
if(!ConfigureChartAppearance())
{
Print("Prop Firm Guard: Could not configure chart appearance.");
return(INIT_FAILED);
}
g_trade.SetAsyncMode(false);
UpdateAccountState();
if(!OpenDatabase())
{
Print("Prop Firm Guard: Database initialization failed.");
return(INIT_FAILED);
}
if(!EnsureDatabaseTables())
{
Print("Prop Firm Guard: Could not initialize database tables.");
CloseDatabase();
return(INIT_FAILED);
}
if(!InitializeAccountSettings())
{
Print("Prop Firm Guard: Could not initialize account settings.");
CloseDatabase();
return(INIT_FAILED);
}
if(!InitializeDailySession())
{
Print("Prop Firm Guard: Could not initialize daily session.");
CloseDatabase();
return(INIT_FAILED);
}
CalculateDailyDrawdown();
CalculateOverallDrawdown();
CalculateProfitTarget();
UpdateNewsState();
UpdateNewsPositionMatches();
// Store the current monitoring state so alerts begin from subsequent
// state transitions rather than from historical conditions.
InitializeAlertState();
if(!CreateDashboard())
{
Print("Prop Firm Guard: Failed to create the dashboard.");
CloseDatabase();
return(INIT_FAILED);
}
if(!EventSetTimer(InpTimerSeconds))
{
Print("Prop Firm Guard: Failed to start the timer. Error: ",
GetLastError());
DeleteDashboard();
CloseDatabase();
return(INIT_FAILED);
}
Print("Prop Firm Guard initialized successfully.");
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
// Stop timer events before shutting down other EA resources.
EventKillTimer();
// Remove only chart objects created by Prop Firm Guard.
DeleteDashboard();
// Close the SQLite connection after all database work is complete.
CloseDatabase();
Print("Prop Firm Guard removed. Deinitialization reason: ", reason);
}
//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick()
{
// Phase 1 does not require tick-by-tick processing.
// Account monitoring currently runs once per second through OnTimer().
}
//+------------------------------------------------------------------+
//| Timer function |
//+------------------------------------------------------------------+
void OnTimer()
{
// Refresh live account information.
UpdateAccountState();
// Detect a new daily monitoring session when necessary.
CheckForNewTradingDay();
// Recalculate all financial compliance conditions.
CalculateDailyDrawdown();
CalculateOverallDrawdown();
CalculateProfitTarget();
// Update economic news exposure and affected positions.
UpdateNewsState();
UpdateNewsPositionMatches();
// Notify only when monitored conditions change.
ManageAlerts();
// Execute configured protection behavior.
ManageProtectionActions();
// Protection actions may change account values or positions.
UpdateAccountState();
CalculateDailyDrawdown();
CalculateOverallDrawdown();
CalculateProfitTarget();
// Persist the latest structured daily-session snapshot.
UpdateRuntimeDatabase();
// Refresh the dashboard with the resulting state.
UpdateDashboard();
}
//+------------------------------------------------------------------+
//| Chart event function |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
const long &lparam,
const double &dparam,
const string &sparam)
{
// We are interested only in clicks on chart objects.
if(id != CHARTEVENT_OBJECT_CLICK)
return;
// Confirm the entered starting balance when the user presses
// the confirmation button.
if(sparam == g_confirmButton)
{
if(!ConfirmDailyStartingBalance())
Print("Prop Firm Guard: Starting balance confirmation failed.");
}
}
//+------------------------------------------------------------------+
//| Update account state |
//+------------------------------------------------------------------+
void UpdateAccountState()
{
// Read the account identifier so future persisted data can be tied
// to the correct trading account.
g_accountState.login = AccountInfoInteger(ACCOUNT_LOGIN);
// Balance represents realized funds currently available on the account.
g_accountState.balance = AccountInfoDouble(ACCOUNT_BALANCE);
// Equity includes the effect of all currently open positions.
g_accountState.equity = AccountInfoDouble(ACCOUNT_EQUITY);
// The difference between equity and balance represents the current
// floating profit or loss of open positions.
g_accountState.floatingPL = g_accountState.equity - g_accountState.balance;
// No compliance rules exist yet, so the initial state remains safe.
g_accountState.status = COMPLIANCE_SAFE;
}
//+------------------------------------------------------------------+
//| Calculate daily drawdown |
//+------------------------------------------------------------------+
void CalculateDailyDrawdown()
{
// Reset the live state when today's starting balance has not yet
// been confirmed by the trader.
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;
}
// Use the confirmed starting balance as the fixed daily reference.
g_dailyDrawdown.startingBalance = g_dailySession.startingBalance;
// Current equity reflects the effect of currently open positions.
g_dailyDrawdown.currentEquity = g_accountState.equity;
// Convert the configured daily percentage limit into account currency.
g_dailyDrawdown.maximumDailyLoss =
g_dailyDrawdown.startingBalance *
g_accountSettings.dailyDrawdownPercent / 100.0;
// A loss exists only when equity falls below the daily starting balance.
g_dailyDrawdown.currentDailyLoss =
g_dailyDrawdown.startingBalance -
g_dailyDrawdown.currentEquity;
if(g_dailyDrawdown.currentDailyLoss < 0.0)
g_dailyDrawdown.currentDailyLoss = 0.0;
// Express the current loss as a percentage of the starting balance.
g_dailyDrawdown.drawdownPercent =
g_dailyDrawdown.currentDailyLoss /
g_dailyDrawdown.startingBalance * 100.0;
// Measure how much of the permitted daily loss has already been used.
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 amount still available before the daily limit is breached.
g_dailyDrawdown.remainingAllowance =
g_dailyDrawdown.maximumDailyLoss -
g_dailyDrawdown.currentDailyLoss;
if(g_dailyDrawdown.remainingAllowance < 0.0)
g_dailyDrawdown.remainingAllowance = 0.0;
// Assign the most severe state first so a breach can never be
// incorrectly classified as merely critical or warning.
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()
{
// Use the initial challenge balance as the permanent reference.
g_overallDrawdown.initialBalance = g_accountSettings.initialBalance;
// Equity is used because open positions can move the account toward
// a breach before their profit or loss becomes realized.
g_overallDrawdown.currentEquity = g_accountState.equity;
// Convert the configured percentage into the maximum monetary loss.
g_overallDrawdown.maximumOverallLoss =
g_overallDrawdown.initialBalance *
g_accountSettings.overallDrawdownPercent / 100.0;
// The static equity floor never moves as the account gains profit.
g_overallDrawdown.overallFloor =
g_overallDrawdown.initialBalance -
g_overallDrawdown.maximumOverallLoss;
// Measure the current loss relative to the initial challenge balance.
g_overallDrawdown.currentOverallLoss =
g_overallDrawdown.initialBalance -
g_overallDrawdown.currentEquity;
// Equity above the initial balance means no overall drawdown is in use.
if(g_overallDrawdown.currentOverallLoss < 0.0)
g_overallDrawdown.currentOverallLoss = 0.0;
// Calculate how much of the permitted overall loss has been consumed.
if(g_overallDrawdown.maximumOverallLoss > 0.0)
{
g_overallDrawdown.limitUsagePercent =
g_overallDrawdown.currentOverallLoss /
g_overallDrawdown.maximumOverallLoss * 100.0;
}
else
{
g_overallDrawdown.limitUsagePercent = 0.0;
}
// Remaining allowance is the distance between current equity and
// the static overall drawdown floor.
g_overallDrawdown.remainingAllowance =
g_overallDrawdown.maximumOverallLoss -
g_overallDrawdown.currentOverallLoss;
if(g_overallDrawdown.remainingAllowance < 0.0)
g_overallDrawdown.remainingAllowance = 0.0;
// Evaluate the current severity using the common warning thresholds.
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()
{
// Use the original challenge balance as the fixed target reference.
g_profitTarget.initialBalance = g_accountSettings.initialBalance;
// Profit-target completion is based on realized account balance.
g_profitTarget.currentBalance = g_accountState.balance;
// Convert the configured target percentage into account currency.
g_profitTarget.targetAmount =
g_profitTarget.initialBalance *
g_accountSettings.profitTargetPercent / 100.0;
// Add the required profit to the initial balance.
g_profitTarget.targetBalance =
g_profitTarget.initialBalance +
g_profitTarget.targetAmount;
// Measure realized profit above the original account balance.
g_profitTarget.currentProfit =
g_profitTarget.currentBalance -
g_profitTarget.initialBalance;
// A balance below the initial value represents no target progress.
if(g_profitTarget.currentProfit < 0.0)
g_profitTarget.currentProfit = 0.0;
// Calculate the percentage of the target already completed.
if(g_profitTarget.targetAmount > 0.0)
{
g_profitTarget.progressPercent =
g_profitTarget.currentProfit /
g_profitTarget.targetAmount * 100.0;
}
else
{
g_profitTarget.progressPercent = 0.0;
}
// Target progress does not need to display more than 100%.
if(g_profitTarget.progressPercent > 100.0)
g_profitTarget.progressPercent = 100.0;
// Calculate how much additional realized profit is still required.
g_profitTarget.remainingProfit =
g_profitTarget.targetAmount -
g_profitTarget.currentProfit;
if(g_profitTarget.remainingProfit < 0.0)
g_profitTarget.remainingProfit = 0.0;
// Determine 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()
{
g_newsState.hasExposure = false;
g_newsState.monitoredCurrencies = 0;
g_newsState.currencyList = "";
g_newsState.eventFound = false;
g_newsState.eventCurrency = "";
g_newsState.eventId = 0;
g_newsState.eventName = "";
g_newsState.importance = CALENDAR_IMPORTANCE_NONE;
g_newsState.eventTime = 0;
g_newsState.secondsToEvent = 0;
g_newsState.restrictionStart = 0;
g_newsState.restrictionEnd = 0;
g_newsState.restrictedWindow = false;
g_newsState.affectedPositions = 0;
g_newsState.protectionPositions = 0;
g_newsState.status = InpEnableNewsFilter ? NEWS_NO_EXPOSURE : NEWS_DISABLED;
g_newsState.holdingStatus = NEWS_HOLDING_CLEAR;
}
//+------------------------------------------------------------------+
//| Initialize alert state |
//+------------------------------------------------------------------+
void InitializeAlertState()
{
g_alertState.dailyDrawdownStatus = g_dailyDrawdown.status;
g_alertState.overallDrawdownStatus = g_overallDrawdown.status;
g_alertState.profitTargetStatus = g_profitTarget.status;
g_alertState.newsEventId = 0;
g_alertState.newsApproachAlerted = false;
g_alertState.newsRestrictedAlerted = false;
g_alertState.dashboardMessage = "";
}
//+------------------------------------------------------------------+
//| Check whether currency already exists in array |
//+------------------------------------------------------------------+
bool CurrencyExists(const string &currencies[],
const string currency)
{
int count = ArraySize(currencies);
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)
{
// Empty currencies do not represent useful Economic Calendar exposure.
if(currency == "")
return(true);
// Do not duplicate currencies already collected from another position.
if(CurrencyExists(currencies, currency))
return(true);
int currentSize = ArraySize(currencies);
// Extend the dynamic array by one element.
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);
}
// XAUUSD receives special treatment. Gold itself has no corresponding
// currency-calendar stream, so USD news represents its macro exposure.
if(baseCurrency == "XAU" &&
profitCurrency == "USD")
{
currency1 = "USD";
return(true);
}
// Confirm that the symbol uses one of MetaTrader's Forex calculation
// models before treating its currencies as Forex news exposure.
ResetLastError();
if(!SymbolInfoInteger(symbol,
SYMBOL_TRADE_CALC_MODE,
calculationMode))
{
Print("Prop Firm Guard: Could not read calculation mode for ",
symbol,
". Error: ",
GetLastError());
return(false);
}
if(calculationMode != SYMBOL_CALC_MODE_FOREX &&
calculationMode != SYMBOL_CALC_MODE_FOREX_NO_LEVERAGE)
return(true);
currency1 = baseCurrency;
currency2 = profitCurrency;
return(true);
}
//+------------------------------------------------------------------+
//| Add currencies exposed by position symbol |
//+------------------------------------------------------------------+
bool AddPositionCurrencies(const string symbol,
string &currencies[])
{
string currency1;
string currency2;
if(!GetSymbolNewsCurrencies(symbol,
currency1,
currency2))
return(false);
// An empty result means this instrument is intentionally unsupported.
if(currency1 == "" &&
currency2 == "")
return(true);
if(!AddUniqueCurrency(currencies, currency1))
return(false);
if(!AddUniqueCurrency(currencies, currency2))
return(false);
return(true);
}
//+------------------------------------------------------------------+
//| Collect currencies from active positions |
//+------------------------------------------------------------------+
bool CollectExposureCurrencies(string &currencies[])
{
ArrayResize(currencies, 0);
int totalPositions = PositionsTotal();
// No open positions means there is currently no news exposure.
if(totalPositions == 0)
return(true);
for(int i = 0; i < totalPositions; i++)
{
ResetLastError();
// PositionGetSymbol() returns the symbol at the requested position
// index and selects that position for subsequent position access.
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);
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 only 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;
for(int i = 0; i < valueCount; i++)
{
MqlCalendarEvent event;
ResetLastError();
// Retrieve the descriptive information associated with this value.
if(!CalendarEventById(values[i].event_id,
event))
{
Print("Prop Firm Guard: Could not retrieve calendar event ",
values[i].event_id,
". Error: ",
GetLastError());
continue;
}
// Ignore events below the minimum importance selected by the user.
if(event.importance < InpNewsImportance)
continue;
// Ignore events that do not have a useful exact release time.
if(event.time_mode != CALENDAR_TIMEMODE_DATETIME)
continue;
// Keep the earliest matching 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 previous event information before running a fresh search.
InitializeNewsState();
if(!InpEnableNewsFilter)
{
g_newsState.status = NEWS_DISABLED;
return;
}
string currencies[];
// Build one deduplicated currency list from every supported open
// position on the trading account.
if(!CollectExposureCurrencies(currencies))
{
g_newsState.status = NEWS_UNAVAILABLE;
return;
}
int currencyCount = ArraySize(currencies);
// No supported currency exposure means there is nothing for the
// Economic Calendar engine to monitor.
if(currencyCount == 0)
{
g_newsState.hasExposure = false;
g_newsState.monitoredCurrencies = 0;
g_newsState.currencyList = "";
g_newsState.status = NEWS_NO_EXPOSURE;
return;
}
g_newsState.hasExposure = true;
g_newsState.monitoredCurrencies = currencyCount;
g_newsState.currencyList = BuildCurrencyList(currencies);
// Economic Calendar functions operate using trade-server time.
datetime currentTime = TimeTradeServer();
// Include the recent past so an event remains selected throughout its
// configured post-news restriction window.
datetime searchFrom = currentTime - InpMinutesAfterNews * 60;
// Search up to one day ahead for the next relevant event.
datetime searchTo = currentTime + 24 * 60 * 60;
bool foundAny = false;
// Store the selected event in initialized scalar values. This avoids
// possible-uninitialized compiler warnings for MqlCalendarValue objects.
ulong selectedEventId = 0;
string selectedEventName = "";
string selectedCurrency = "";
ENUM_CALENDAR_EVENT_IMPORTANCE selectedImportance = CALENDAR_IMPORTANCE_NONE;
datetime selectedEventTime = 0;
// Search every unique currency currently represented by an open
// supported account position.
for(int i = 0; i < currencyCount; i++)
{
MqlCalendarValue candidateValue;
MqlCalendarEvent candidateEvent;
if(!FindNextNewsForCurrency(currencies[i],
searchFrom,
searchTo,
candidateValue,
candidateEvent))
continue;
// Keep the first qualifying event, then replace it only when another
// exposed currency has an earlier qualifying event.
if(!foundAny ||
candidateValue.time < selectedEventTime)
{
selectedEventId = candidateEvent.id;
selectedEventName = candidateEvent.name;
selectedCurrency = currencies[i];
selectedImportance = candidateEvent.importance;
selectedEventTime = candidateValue.time;
foundAny = true;
}
}
if(!foundAny)
{
g_newsState.status = NEWS_NO_EVENT;
return;
}
// Store the nearest qualifying event across the complete account exposure.
g_newsState.eventFound = true;
g_newsState.eventCurrency = selectedCurrency;
g_newsState.eventId = selectedEventId;
g_newsState.eventName = selectedEventName;
g_newsState.importance = selectedImportance;
g_newsState.eventTime = selectedEventTime;
// Positive values mean the event is still ahead. Negative values mean
// the event has already occurred.
g_newsState.secondsToEvent = (long)(g_newsState.eventTime - currentTime);
// Build the complete prohibited/restricted interval.
g_newsState.restrictionStart = g_newsState.eventTime - InpMinutesBeforeNews * 60;
g_newsState.restrictionEnd = g_newsState.eventTime + InpMinutesAfterNews * 60;
// Determine whether the current trade-server time is inside that window.
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;
}
//+------------------------------------------------------------------+
//| 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();
for(int i = 0; i < totalPositions; i++)
{
ResetLastError();
// PositionGetTicket() selects the indexed position so its remaining
// properties can be read immediately afterward.
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;
// Empty currencies identify instruments outside the current
// Forex and XAUUSD news-monitoring scope.
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);
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()
{
g_newsState.affectedPositions = 0;
g_newsState.protectionPositions = 0;
g_newsState.holdingStatus = NEWS_HOLDING_CLEAR;
int totalMatches = ArraySize(g_newsPositionMatches);
// Nothing needs holding-rule evaluation without a selected event.
if(!g_newsState.eventFound ||
totalMatches == 0)
return;
// First count every position affected by the selected event.
for(int i = 0; i < totalMatches; i++)
{
// Always reset protection state before evaluating the current window.
g_newsPositionMatches[i].protectionRequired = false;
if(g_newsPositionMatches[i].status == NEWS_POSITION_AFFECTED)
g_newsState.affectedPositions++;
}
// No active position is exposed to this particular event.
if(g_newsState.affectedPositions == 0)
return;
// When holding is allowed, affected positions remain untouched even
// while the event is inside its configured restricted window.
if(InpAllowNewsHolding)
{
if(g_newsState.restrictedWindow)
g_newsState.holdingStatus = NEWS_HOLDING_ALLOWED;
else
g_newsState.holdingStatus = NEWS_HOLDING_WARNING;
return;
}
// Holding is prohibited. Outside the restricted window we warn the
// trader that affected positions are exposed to an approaching event.
if(!g_newsState.restrictedWindow)
{
g_newsState.holdingStatus = NEWS_HOLDING_WARNING;
return;
}
// The restricted window is now active and holding is not permitted.
// Mark only affected positions for the protection subsystem.
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;
}
//+------------------------------------------------------------------+
//| Count news-affected positions |
//+------------------------------------------------------------------+
int CountAffectedNewsPositions()
{
int affectedCount = 0;
int totalMatches = ArraySize(g_newsPositionMatches);
for(int i = 0; i < totalMatches; i++)
{
if(g_newsPositionMatches[i].status == NEWS_POSITION_AFFECTED)
affectedCount++;
}
return(affectedCount);
}
//+------------------------------------------------------------------+
//| Build affected symbol list |
//+------------------------------------------------------------------+
string BuildAffectedSymbolList()
{
string result = "";
int totalMatches = ArraySize(g_newsPositionMatches);
for(int i = 0; i < totalMatches; i++)
{
if(g_newsPositionMatches[i].status != NEWS_POSITION_AFFECTED)
continue;
// Avoid repeating the same symbol when a hedging account contains
// several positions for that instrument.
string token = g_newsPositionMatches[i].symbol;
if(StringFind("," + result + ",",
"," + token + ",") >= 0)
continue;
if(result != "")
result += ",";
result += token;
}
if(result == "")
return("NONE");
return(result);
}
//+------------------------------------------------------------------+
//| Print news position matches |
//+------------------------------------------------------------------+
void PrintNewsPositionMatches()
{
if(!g_newsState.eventFound)
return;
Print("--------------------------------------------------");
Print("Prop Firm Guard: News position classification");
Print("Event: ",
g_newsState.eventCurrency,
" | ",
g_newsState.eventName);
int totalMatches = ArraySize(g_newsPositionMatches);
if(totalMatches == 0)
{
Print("No open positions available for classification.");
Print("--------------------------------------------------");
return;
}
for(int i = 0; i < totalMatches; i++)
{
Print("Ticket ",
g_newsPositionMatches[i].ticket,
" | ",
g_newsPositionMatches[i].symbol,
" | ",
NewsPositionStatusToString(g_newsPositionMatches[i].status));
}
Print("--------------------------------------------------");
}
//+------------------------------------------------------------------+
//| 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();
// Reset event tracking when no calendar event is currently selected.
if(!g_newsState.eventFound)
{
g_lastMatchedEventId = 0;
return;
}
// Print the complete classification only when a different calendar
// event becomes active.
if(g_newsState.eventId != g_lastMatchedEventId)
{
PrintNewsPositionMatches();
g_lastMatchedEventId = g_newsState.eventId;
}
}
//+------------------------------------------------------------------+
//| Convert news status to text |
//+------------------------------------------------------------------+
string NewsStatusToString(const ENUM_NEWS_STATUS status)
{
switch(status)
{
case NEWS_DISABLED:
return("DISABLED");
case NEWS_NO_EXPOSURE:
return("NO EXPOSURE");
case NEWS_NO_EVENT:
return("NO EVENT");
case NEWS_SAFE:
return("SAFE");
case NEWS_RESTRICTED:
return("RESTRICTED");
case NEWS_UNAVAILABLE:
default:
return("UNAVAILABLE");
}
}
//+------------------------------------------------------------------+
//| Convert news position status to text |
//+------------------------------------------------------------------+
string NewsPositionStatusToString(const ENUM_NEWS_POSITION_STATUS status)
{
switch(status)
{
case NEWS_POSITION_AFFECTED:
return("AFFECTED");
case NEWS_POSITION_UNSUPPORTED:
return("UNSUPPORTED");
case NEWS_POSITION_NOT_AFFECTED:
default:
return("NOT AFFECTED");
}
}
//+------------------------------------------------------------------+
//| Convert calendar importance to text |
//+------------------------------------------------------------------+
string CalendarImportanceToString(const ENUM_CALENDAR_EVENT_IMPORTANCE importance)
{
switch(importance)
{
case CALENDAR_IMPORTANCE_HIGH:
return("HIGH");
case CALENDAR_IMPORTANCE_MODERATE:
return("MODERATE");
case CALENDAR_IMPORTANCE_LOW:
return("LOW");
case CALENDAR_IMPORTANCE_NONE:
default:
return("NONE");
}
}
//+------------------------------------------------------------------+
//| Format news countdown |
//+------------------------------------------------------------------+
string FormatNewsCountdown(const long secondsToEvent)
{
long absoluteSeconds = secondsToEvent;
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);
if(secondsToEvent >= 0)
return(formatted);
return("+" + formatted);
}
//+------------------------------------------------------------------+
//| 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");
}
}
//+------------------------------------------------------------------+
//| Convert news holding status to text |
//+------------------------------------------------------------------+
string NewsHoldingStatusToString(const ENUM_NEWS_HOLDING_STATUS status)
{
switch(status)
{
case NEWS_HOLDING_ALLOWED:
return("HOLDING ALLOWED");
case NEWS_HOLDING_WARNING:
return("EVENT APPROACHING");
case NEWS_HOLDING_PROTECTION:
return("PROTECTION REQUIRED");
case NEWS_HOLDING_CLEAR:
default:
return("CLEAR");
}
}
//+------------------------------------------------------------------+
//| Check successful position-close return code |
//+------------------------------------------------------------------+
bool IsSuccessfulCloseRetcode(const uint retcode)
{
if(retcode == TRADE_RETCODE_DONE ||
retcode == TRADE_RETCODE_POSITION_CLOSED)
return(true);
return(false);
}
//+------------------------------------------------------------------+
//| Close position by ticket |
//+------------------------------------------------------------------+
bool ClosePositionByTicket(const ulong ticket,
const string reason)
{
ResetLastError();
// Confirm that the position still exists before attempting to close it.
if(!PositionSelectByTicket(ticket))
{
int errorCode = GetLastError();
// A position may already have disappeared because another protection
// action or manual operation closed it.
Print("Prop Firm Guard: Position ",
ticket,
" is no longer available. Error: ",
errorCode);
return(true);
}
string symbol;
if(!PositionGetString(POSITION_SYMBOL,
symbol))
{
Print("Prop Firm Guard: Could not read symbol for position ",
ticket,
". Error: ",
GetLastError());
return(false);
}
// Configure CTrade using the filling policies allowed for this symbol.
if(!g_trade.SetTypeFillingBySymbol(symbol))
{
Print("Prop Firm Guard: Could not determine filling policy for ",
symbol,
".");
return(false);
}
ResetLastError();
// PositionClose() performs the basic request submission, but its Boolean
// result alone is not sufficient to confirm execution by the trade server.
bool requestAccepted = g_trade.PositionClose(ticket);
uint retcode = g_trade.ResultRetcode();
string retcodeDescription = g_trade.ResultRetcodeDescription();
if(!requestAccepted)
{
Print("Prop Firm Guard: Close request failed for ticket ",
ticket,
" [",
symbol,
"]. Reason: ",
reason,
". Retcode: ",
retcode,
" - ",
retcodeDescription,
". Runtime error: ",
GetLastError());
return(false);
}
// Always inspect the server return code after PositionClose().
if(!IsSuccessfulCloseRetcode(retcode))
{
Print("Prop Firm Guard: Trade server did not confirm complete closure of ticket ",
ticket,
" [",
symbol,
"]. Reason: ",
reason,
". Retcode: ",
retcode,
" - ",
retcodeDescription);
return(false);
}
// Verify that the position is no longer present after the synchronous
// close operation.
ResetLastError();
if(PositionSelectByTicket(ticket))
{
Print("Prop Firm Guard: Position ",
ticket,
" [",
symbol,
"] still exists after close request.");
return(false);
}
Print("Prop Firm Guard: Position ",
ticket,
" [",
symbol,
"] closed successfully. Reason: ",
reason,
".");
return(true);
}
//+------------------------------------------------------------------+
//| Close all open positions |
//+------------------------------------------------------------------+
bool CloseAllPositions(const string reason)
{
int totalPositions = PositionsTotal();
if(totalPositions == 0)
return(true);
ulong tickets[];
if(ArrayResize(tickets, totalPositions) != totalPositions)
{
Print("Prop Firm Guard: Could not allocate position ticket array.");
return(false);
}
int ticketCount = 0;
// Build a stable ticket list before modifying the open-position pool.
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;
}
tickets[ticketCount] = ticket;
ticketCount++;
}
bool allClosed = true;
for(int i = 0; i < ticketCount; i++)
{
if(!ClosePositionByTicket(tickets[i],
reason))
allClosed = false;
}
return(allClosed);
}
//+------------------------------------------------------------------+
//| Close news-affected positions |
//+------------------------------------------------------------------+
bool CloseNewsAffectedPositions()
{
ulong tickets[];
int totalMatches = ArraySize(g_newsPositionMatches);
int ticketCount = 0;
// First collect all affected tickets so closing one position cannot
// invalidate our traversal of the match array.
for(int i = 0; i < totalMatches; i++)
{
if(!g_newsPositionMatches[i].protectionRequired)
continue;
int newSize = ticketCount + 1;
if(ArrayResize(tickets, newSize) != newSize)
{
Print("Prop Firm Guard: Could not expand affected-position ticket array.");
return(false);
}
tickets[ticketCount] = g_newsPositionMatches[i].ticket;
ticketCount++;
}
if(ticketCount == 0)
return(true);
bool allClosed = true;
string reason =
"News restriction: " +
g_newsState.eventCurrency +
" " +
g_newsState.eventName;
for(int i = 0; i < ticketCount; i++)
{
if(!ClosePositionByTicket(tickets[i],
reason))
allClosed = false;
}
return(allClosed);
}
//+------------------------------------------------------------------+
//| Handle daily drawdown protection |
//+------------------------------------------------------------------+
void HandleDailyDrawdownProtection()
{
if(!g_dailySession.balanceConfirmed)
return;
if(g_dailyDrawdown.status != COMPLIANCE_BREACHED)
{
g_dailyBreachWarned = false;
return;
}
switch(InpDailyDrawdownAction)
{
case PROTECTION_WARN_ONLY:
if(!g_dailyBreachWarned)
{
Alert("Prop Firm Guard: Daily drawdown limit breached.");
Print("Prop Firm Guard: Daily drawdown breached. Action: WARN ONLY.");
g_dailyBreachWarned = true;
}
break;
case PROTECTION_CLOSE_AFFECTED:
case PROTECTION_CLOSE_ALL:
// Daily drawdown is an account-wide rule, therefore every open
// position contributes to the breached account condition.
if(PositionsTotal() > 0)
{
if(!CloseAllPositions("Daily drawdown breach"))
Print("Prop Firm Guard: One or more positions could not be closed after daily drawdown breach.");
}
break;
}
}
//+------------------------------------------------------------------+
//| Handle overall drawdown protection |
//+------------------------------------------------------------------+
void HandleOverallDrawdownProtection()
{
if(g_overallDrawdown.status != COMPLIANCE_BREACHED)
{
g_overallBreachWarned = false;
return;
}
switch(InpOverallDrawdownAction)
{
case PROTECTION_WARN_ONLY:
if(!g_overallBreachWarned)
{
Alert("Prop Firm Guard: Overall drawdown limit breached.");
Print("Prop Firm Guard: Overall drawdown breached. Action: WARN ONLY.");
g_overallBreachWarned = true;
}
break;
case PROTECTION_CLOSE_AFFECTED:
case PROTECTION_CLOSE_ALL:
// Overall drawdown applies to the complete trading account.
if(PositionsTotal() > 0)
{
if(!CloseAllPositions("Overall drawdown breach"))
Print("Prop Firm Guard: One or more positions could not be closed after overall drawdown breach.");
}
break;
}
}
//+------------------------------------------------------------------+
//| Handle news protection |
//+------------------------------------------------------------------+
void HandleNewsProtection()
{
// Protection is needed only when Phase 11 determined that holding is
// prohibited and the restricted window is currently active.
if(g_newsState.holdingStatus != NEWS_HOLDING_PROTECTION)
return;
if(!g_newsState.eventFound)
return;
switch(InpNewsRestrictionAction)
{
case PROTECTION_WARN_ONLY:
// Warn only once for this particular Economic Calendar event.
if(g_lastNewsWarnedEventId != g_newsState.eventId)
{
Alert("Prop Firm Guard: News holding restriction active for ",
g_newsState.eventCurrency,
" ",
g_newsState.eventName,
".");
Print("Prop Firm Guard: News protection required. Action: WARN ONLY.");
g_lastNewsWarnedEventId = g_newsState.eventId;
}
break;
case PROTECTION_CLOSE_AFFECTED:
if(g_newsState.protectionPositions > 0)
{
if(!CloseNewsAffectedPositions())
Print("Prop Firm Guard: One or more news-affected positions could not be closed.");
}
break;
case PROTECTION_CLOSE_ALL:
if(PositionsTotal() > 0)
{
string reason =
"News holding restriction: " +
g_newsState.eventCurrency +
" " +
g_newsState.eventName;
if(!CloseAllPositions(reason))
Print("Prop Firm Guard: One or more positions could not be closed during news restriction.");
}
break;
}
}
//+------------------------------------------------------------------+
//| Manage protection actions |
//+------------------------------------------------------------------+
void ManageProtectionActions()
{
// Financial breaches receive priority because they represent direct
// account-rule violations.
HandleDailyDrawdownProtection();
HandleOverallDrawdownProtection();
// News protection then applies to any positions that remain open.
HandleNewsProtection();
}
//+------------------------------------------------------------------+
//| Convert protection action to text |
//+------------------------------------------------------------------+
string ProtectionActionToString(const ENUM_PROTECTION_ACTION action)
{
switch(action)
{
case PROTECTION_CLOSE_AFFECTED:
return("CLOSE AFFECTED");
case PROTECTION_CLOSE_ALL:
return("CLOSE ALL");
case PROTECTION_WARN_ONLY:
default:
return("WARN ONLY");
}
}
//+------------------------------------------------------------------+
//| Get news trading-window text |
//+------------------------------------------------------------------+
string GetNewsTradingWindowText()
{
if(!InpEnableNewsFilter)
return("DISABLED");
if(!g_newsState.eventFound)
return("SAFE");
if(g_newsState.restrictedWindow)
return("RESTRICTED");
return("SAFE");
}
//+------------------------------------------------------------------+
//| Get configured news holding rule |
//+------------------------------------------------------------------+
string GetNewsHoldingRuleText()
{
if(InpAllowNewsHolding)
return("ALLOWED");
return("NOT ALLOWED");
}
//+------------------------------------------------------------------+
//| Get overall guard status |
//+------------------------------------------------------------------+
ENUM_GUARD_STATUS GetOverallGuardStatus()
{
// A breach always has the highest priority.
if(g_dailyDrawdown.status == COMPLIANCE_BREACHED ||
g_overallDrawdown.status == COMPLIANCE_BREACHED)
return(GUARD_BREACHED);
// Critical conditions take priority over warnings and target success.
if(g_dailyDrawdown.status == COMPLIANCE_CRITICAL ||
g_overallDrawdown.status == COMPLIANCE_CRITICAL)
return(GUARD_CRITICAL);
// A warning still takes priority over a reached profit target because
// the account may be profitable while simultaneously approaching a loss limit.
if(g_dailyDrawdown.status == COMPLIANCE_WARNING ||
g_overallDrawdown.status == COMPLIANCE_WARNING)
return(GUARD_WARNING);
// Report target completion only when no higher-risk condition exists.
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");
}
}
//+------------------------------------------------------------------+
//| Get guard status color |
//+------------------------------------------------------------------+
color GetGuardStatusColor(const ENUM_GUARD_STATUS status)
{
switch(status)
{
case GUARD_BREACHED:
case GUARD_CRITICAL:
return(clrRed);
case GUARD_WARNING:
return(clrDarkOrange);
case GUARD_TARGET_REACHED:
return(clrGreen);
case GUARD_SAFE:
default:
return(clrGreen);
}
}
//+------------------------------------------------------------------+
//| Open database |
//+------------------------------------------------------------------+
bool OpenDatabase()
{
// Open the database for reading and writing, creating the file
// automatically when Prop Firm Guard runs for the first time.
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);
}
/*
//+------------------------------------------------------------------+
//| Ensure database tables |
//+------------------------------------------------------------------+
bool EnsureDatabaseTables()
{
// Account settings persist the main prop-firm rules independently
// for each combination of account login and trading server.
string settingsSql =
"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)"
");";
// Daily sessions hold values that belong to one specific trading day.
// The daily starting values remain zero until Phase 3 confirms them.
string sessionsSql =
"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 DEFAULT 0,"
"starting_equity REAL NOT NULL DEFAULT 0,"
"balance_confirmed INTEGER NOT NULL DEFAULT 0,"
"created_at INTEGER NOT NULL,"
"updated_at INTEGER NOT NULL,"
"PRIMARY KEY(account_login, account_server, trading_date)"
");";
ResetLastError();
if(!DatabaseExecute(g_database, settingsSql))
{
Print("Prop Firm Guard: Could not create settings table. Error: ",
GetLastError());
return(false);
}
ResetLastError();
if(!DatabaseExecute(g_database, sessionsSql))
{
Print("Prop Firm Guard: Could not create daily_sessions table. Error: ",
GetLastError());
return(false);
}
Print("Prop Firm Guard: Database tables are ready.");
return(true);
}
*/
//+------------------------------------------------------------------+
//| Close database |
//+------------------------------------------------------------------+
void CloseDatabase()
{
// Do nothing if no valid database connection currently exists.
if(g_database == INVALID_HANDLE)
return;
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.");
}
// Never keep a handle after the database has been closed.
g_database = INVALID_HANDLE;
}
//+------------------------------------------------------------------+
//| Check whether database column exists |
//+------------------------------------------------------------------+
bool DatabaseColumnExists(const string tableName,
const string columnName)
{
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;
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;
}
}
FinalizeDatabaseRequest(request);
return(columnFound);
}
//+------------------------------------------------------------------+
//| Ensure database column exists |
//+------------------------------------------------------------------+
bool EnsureDatabaseColumn(const string tableName,
const string columnName,
const string columnDefinition)
{
if(DatabaseColumnExists(tableName,
columnName))
return(true);
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()
{
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()
{
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)"
");";
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)"
");";
ResetLastError();
if(!DatabaseExecute(g_database,
settingsTable))
{
Print("Prop Firm Guard: Could not create settings table. Error: ",
GetLastError());
return(false);
}
ResetLastError();
if(!DatabaseExecute(g_database,
dailySessionsTable))
{
Print("Prop Firm Guard: Could not create daily_sessions table. Error: ",
GetLastError());
return(false);
}
// CREATE TABLE IF NOT EXISTS does not add missing columns to an older
// table, so migrate databases created by earlier EA versions.
if(!EnsureDailySessionRuntimeColumns())
return(false);
return(true);
}
//+------------------------------------------------------------------+
//| Check for new trading day |
//+------------------------------------------------------------------+
void CheckForNewTradingDay()
{
string currentDate = GetTradingDate();
// The current database session already belongs to today.
if(g_hasDailySession &&
g_dailySession.tradingDate == currentDate)
return;
Print("Prop Firm Guard: New trading day detected: ",
currentDate);
// Load today's record if one already exists, or create a new
// unconfirmed session when this is the first launch today.
if(!InitializeDailySession())
{
Print("Prop Firm Guard: Could not initialize the new daily session.");
return;
}
// Rebuild only the starting-balance controls so their state matches
// the newly loaded daily session.
DeleteDailySessionControls();
if(!CreateDailySessionControls())
{
Print("Prop Firm Guard: Could not create daily session controls.");
}
}
//+------------------------------------------------------------------+
//| Confirm daily starting balance |
//+------------------------------------------------------------------+
bool ConfirmDailyStartingBalance()
{
// Never allow normal confirmation logic to overwrite a value that
// has already been confirmed for the current trading day.
if(g_dailySession.balanceConfirmed)
{
Print("Prop Firm Guard: Today's starting balance is already confirmed.");
return(true);
}
string balanceText;
ResetLastError();
// Read the amount entered in the dashboard edit 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);
if(startingBalance <= 0.0)
{
Alert("Prop Firm Guard: Enter a valid starting balance greater than zero.");
return(false);
}
// Store the user-confirmed starting values in memory.
g_dailySession.startingBalance = startingBalance;
g_dailySession.startingEquity = g_accountState.equity;
g_dailySession.balanceConfirmed = true;
g_dailySession.updatedAt = TimeCurrent();
// Persist the confirmed values immediately.
if(!SaveDailySession())
{
Print("Prop Firm Guard: Could not save confirmed daily session.");
// Do not leave memory showing 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,
".");
// The confirmation controls are no longer required after the value
// has been safely stored.
DeleteDailySessionControls();
UpdateDashboard();
return(true);
}
//+------------------------------------------------------------------+
//| Create daily session controls |
//+------------------------------------------------------------------+
bool CreateDailySessionControls()
{
// A confirmed session does not require editable controls.
if(g_dailySession.balanceConfirmed)
return(true);
int controlX = InpDashboardX + 18;
int controlY = InpDashboardY + 120;
// Suggest the current balance without treating it as confirmed.
string suggestedBalance =
DoubleToString(g_accountState.balance, 2);
if(!CreateStartingBalanceEdit(controlX,
controlY,
suggestedBalance))
return(false);
if(!CreateConfirmBalanceButton(controlX + 130,
controlY))
return(false);
return(true);
}
//+------------------------------------------------------------------+
//| Create starting balance edit |
//+------------------------------------------------------------------+
bool CreateStartingBalanceEdit(const int x,
const int y,
const string suggestedBalance)
{
// Create an editable field where the trader may accept or change
// the suggested starting balance.
if(!ObjectCreate(0,
g_startBalanceEdit,
OBJ_EDIT,
0,
0,
0))
{
Print("Prop Firm Guard: Could not create starting balance field. Error: ",
GetLastError());
return(false);
}
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);
}
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 button used to persist the daily starting balance.
if(!ObjectCreate(0,
g_confirmButton,
OBJ_BUTTON,
0,
0,
0))
{
Print("Prop Firm Guard: Could not create confirmation button. Error: ",
GetLastError());
return(false);
}
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);
}
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);
}
//+------------------------------------------------------------------+
//| Delete daily session controls |
//+------------------------------------------------------------------+
void DeleteDailySessionControls()
{
// Delete the editable balance field only when it currently exists.
if(ObjectFind(0, g_startBalanceEdit) >= 0)
{
if(!ObjectDelete(0, g_startBalanceEdit))
{
Print("Prop Firm Guard: Could not delete starting balance field. Error: ",
GetLastError());
}
}
// Delete the confirmation button only when it currently exists.
if(ObjectFind(0, g_confirmButton) >= 0)
{
if(!ObjectDelete(0, g_confirmButton))
{
Print("Prop Firm Guard: Could not delete confirmation button. Error: ",
GetLastError());
}
}
ChartRedraw();
}
//+------------------------------------------------------------------+
//| Get trading date |
//+------------------------------------------------------------------+
string GetTradingDate()
{
// TimeCurrent() represents the trading server time known by the terminal.
// Phase 3 will use this server-based date for daily session management.
datetime serverTime = TimeCurrent();
return(TimeToString(serverTime, TIME_DATE));
}
//+------------------------------------------------------------------+
//| Initialize account settings |
//+------------------------------------------------------------------+
bool InitializeAccountSettings()
{
bool settingsFound = LoadAccountSettings();
// Associate these settings with the current trading account.
g_accountSettings.accountLogin = g_accountState.login;
g_accountSettings.accountServer = AccountInfoString(ACCOUNT_SERVER);
// Synchronize the current EA inputs with persistent account settings.
g_accountSettings.initialBalance = InpInitialAccountBalance;
g_accountSettings.dailyDrawdownPercent = InpDailyDrawdownPercent;
g_accountSettings.overallDrawdownPercent = InpOverallDrawdownPercent;
g_accountSettings.profitTargetPercent = InpProfitTargetPercent;
g_accountSettings.updatedAt = TimeCurrent();
// Store the current configuration so SQLite remains synchronized.
if(!SaveAccountSettings())
return(false);
if(settingsFound)
Print("Prop Firm Guard: Account settings restored and synchronized.");
else
Print("Prop Firm Guard: New account settings saved.");
return(true);
}
//+------------------------------------------------------------------+
//| Save account settings |
//+------------------------------------------------------------------+
bool SaveAccountSettings()
{
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 each value separately so text and numeric values remain data
// rather than being concatenated directly into the SQL 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);
}
// INSERT/UPDATE statements do not return rows. In MQL5 a successful
// DatabaseRead() therefore finishes with ERR_DATABASE_NO_MORE_DATA.
if(!ExecuteDatabaseRequest(request, "saving account settings"))
return(false);
return(true);
}
//+------------------------------------------------------------------+
//| Load account settings |
//+------------------------------------------------------------------+
bool LoadAccountSettings()
{
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);
}
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);
}
ResetLastError();
// A true result means the SELECT statement returned its first row.
if(!DatabaseRead(request))
{
int errorCode = GetLastError();
FinalizeDatabaseRequest(request);
// No row simply means this account has not been saved before.
if(errorCode == ERR_DATABASE_NO_MORE_DATA)
return(false);
Print("Prop Firm Guard: Could not read account settings. Error: ",
errorCode);
return(false);
}
long accountLogin;
string storedServer;
double initialBalance;
double dailyDrawdown;
double overallDrawdown;
double profitTarget;
long updatedAt;
// Read every selected column and verify every database conversion.
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);
}
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;
FinalizeDatabaseRequest(request);
return(true);
}
//+------------------------------------------------------------------+
//| Initialize daily session |
//+------------------------------------------------------------------+
bool InitializeDailySession()
{
string tradingDate = GetTradingDate();
if(DailySessionExists(tradingDate))
{
if(!LoadDailySession())
return(false);
g_hasDailySession = true;
Print("Prop Firm Guard: Daily session restored for ",
tradingDate,
".");
return(true);
}
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();
if(!SaveDailySession())
return(false);
g_hasDailySession = true;
Print("Prop Firm Guard: New daily session created for ",
tradingDate,
".");
return(true);
}
//+------------------------------------------------------------------+
//| Save daily session |
//+------------------------------------------------------------------+
bool SaveDailySession()
{
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);
}
return(ExecuteDatabaseRequest(request,
"saving daily session"));
}
//+------------------------------------------------------------------+
//| Load daily session |
//+------------------------------------------------------------------+
bool LoadDailySession()
{
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);
}
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);
}
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);
}
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;
FinalizeDatabaseRequest(request);
return(true);
}
//+------------------------------------------------------------------+
//| Check daily session existence |
//+------------------------------------------------------------------+
bool DailySessionExists(const string tradingDate)
{
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);
}
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);
}
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);
}
//+------------------------------------------------------------------+
//| Execute prepared database request |
//+------------------------------------------------------------------+
bool ExecuteDatabaseRequest(const int request,
const string operation)
{
ResetLastError();
bool result = DatabaseRead(request);
int errorCode = GetLastError();
// INSERT and UPDATE statements return no result rows. MQL5 therefore
// reports ERR_DATABASE_NO_MORE_DATA after successful execution.
bool success =
(result || errorCode == ERR_DATABASE_NO_MORE_DATA);
if(!success)
{
Print("Prop Firm Guard: Database error while ",
operation,
". Error: ",
errorCode);
}
FinalizeDatabaseRequest(request);
return(success);
}
//+------------------------------------------------------------------+
//| Finalize database request |
//+------------------------------------------------------------------+
void FinalizeDatabaseRequest(const int request)
{
if(request == INVALID_HANDLE)
return;
ResetLastError();
DatabaseFinalize(request);
int errorCode = GetLastError();
if(errorCode != 0)
{
Print("Prop Firm Guard: Could not finalize database request. Error: ",
errorCode);
}
}
//+------------------------------------------------------------------+
//| Create dashboard |
//+------------------------------------------------------------------+
bool CreateDashboard()
{
string panelName = g_objectPrefix + "Panel";
int leftX = InpDashboardX + 18;
int rightX = InpDashboardX + 275;
if(!ObjectCreate(0,
panelName,
OBJ_RECTANGLE_LABEL,
0,
0,
0))
{
Print("Prop Firm Guard: Could not create dashboard panel. Error: ",
GetLastError());
return(false);
}
if(!ObjectSetInteger(0, panelName, OBJPROP_CORNER, CORNER_LEFT_UPPER) ||
!ObjectSetInteger(0, panelName, OBJPROP_XDISTANCE, InpDashboardX) ||
!ObjectSetInteger(0, panelName, OBJPROP_YDISTANCE, InpDashboardY) ||
!ObjectSetInteger(0, panelName, OBJPROP_XSIZE, 520) ||
!ObjectSetInteger(0, panelName, OBJPROP_YSIZE, 500) ||
!ObjectSetInteger(0, panelName, OBJPROP_BGCOLOR, clrWhite) ||
!ObjectSetInteger(0, panelName, OBJPROP_BORDER_COLOR, clrSilver) ||
!ObjectSetInteger(0, panelName, OBJPROP_SELECTABLE, false) ||
!ObjectSetInteger(0, panelName, OBJPROP_HIDDEN, true))
{
Print("Prop Firm Guard: Could not configure dashboard panel. Error: ",
GetLastError());
return(false);
}
//--- Main title
if(!CreateDashboardLabel(g_objectPrefix + "Title", "PROP FIRM GUARD", leftX, InpDashboardY + 12, 11, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "OverallStatus", "", rightX, InpDashboardY + 14, 10, clrBlack))
return(false);
//--- SESSION
if(!CreateDashboardLabel(g_objectPrefix + "SessionHeader", "SESSION", leftX, InpDashboardY + 42, 9, clrDimGray))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "TradingDate", "", leftX, InpDashboardY + 62, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "SessionState", "", leftX, InpDashboardY + 82, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "DailyStart", "", leftX, InpDashboardY + 102, 9, clrBlack))
return(false);
//--- ACCOUNT
if(!CreateDashboardLabel(g_objectPrefix + "AccountHeader", "ACCOUNT", leftX, InpDashboardY + 145, 9, clrDimGray))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "AccountLogin", "", leftX, InpDashboardY + 165, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "Balance", "", leftX, InpDashboardY + 185, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "Equity", "", leftX, InpDashboardY + 205, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "FloatingPL", "", leftX, InpDashboardY + 225, 9, clrBlack))
return(false);
//--- DAILY DRAWDOWN
if(!CreateDashboardLabel(g_objectPrefix + "DailyDrawdownHeader", "DAILY DRAWDOWN", leftX, InpDashboardY + 255, 9, clrDimGray))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "DailyLossLimit", "", leftX, InpDashboardY + 275, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "DailyCurrentLoss", "", leftX, InpDashboardY + 295, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "DailyLimitUsage", "", leftX, InpDashboardY + 315, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "DailyRemaining", "", leftX, InpDashboardY + 335, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "DailyDrawdownStatus", "", leftX, InpDashboardY + 355, 9, clrBlack))
return(false);
//--- OVERALL DRAWDOWN
if(!CreateDashboardLabel(g_objectPrefix + "OverallDrawdownHeader", "OVERALL DRAWDOWN", rightX, InpDashboardY + 42, 9, clrDimGray))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "OverallInitialBalance", "", rightX, InpDashboardY + 62, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "OverallFloor", "", rightX, InpDashboardY + 82, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "OverallEquity", "", rightX, InpDashboardY + 102, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "OverallLoss", "", rightX, InpDashboardY + 122, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "OverallLimitUsage", "", rightX, InpDashboardY + 142, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "OverallRemaining", "", rightX, InpDashboardY + 162, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "OverallDrawdownStatus", "", rightX, InpDashboardY + 182, 9, clrBlack))
return(false);
//--- PROFIT TARGET
if(!CreateDashboardLabel(g_objectPrefix + "ProfitTargetHeader", "PROFIT TARGET", rightX, InpDashboardY + 220, 9, clrDimGray))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "TargetBalance", "", rightX, InpDashboardY + 240, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "TargetCurrentProfit", "", rightX, InpDashboardY + 260, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "TargetProgress", "", rightX, InpDashboardY + 280, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "TargetRemaining", "", rightX, InpDashboardY + 300, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "ProfitTargetStatus", "", rightX, InpDashboardY + 320, 9, clrBlack))
return(false);
//--- NEWS
if(!CreateDashboardLabel(g_objectPrefix + "NewsHeader", "NEWS", rightX, InpDashboardY + 350, 9, clrDimGray))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "NewsEvent", "", rightX, InpDashboardY + 370, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "NewsTime", "", rightX, InpDashboardY + 390, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "NewsCountdown", "", rightX, InpDashboardY + 410, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "NewsRule", "", rightX, InpDashboardY + 430, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "NewsStatus", "", rightX, InpDashboardY + 450, 9, clrBlack))
return(false);
//--- STATUS
if(!CreateDashboardLabel(g_objectPrefix + "StatusHeader", "STATUS", leftX, InpDashboardY + 390, 9, clrDimGray))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "StatusDaily", "", leftX, InpDashboardY + 410, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "StatusOverall", "", leftX, InpDashboardY + 430, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "StatusTarget", "", leftX, InpDashboardY + 450, 9, clrBlack))
return(false);
if(!CreateDashboardLabel(g_objectPrefix + "StatusNews", "", leftX, InpDashboardY + 470, 9, clrBlack))
return(false);
if(!CreateDailySessionControls())
return(false);
UpdateDashboard();
ChartRedraw();
return(true);
}
//+------------------------------------------------------------------+
//| Create dashboard label |
//+------------------------------------------------------------------+
bool CreateDashboardLabel(const string name,
const string text,
const int x,
const int y,
const int fontSize,
const color textColor)
{
// Create a fixed text label positioned relative to the chart corner.
if(!ObjectCreate(0,
name,
OBJ_LABEL,
0,
0,
0))
{
Print("Prop Firm Guard: Could not create label ",
name,
". Error: ",
GetLastError());
return(false);
}
// Configure all visual and positioning properties of the label.
if(!ObjectSetInteger(0,
name,
OBJPROP_CORNER,
CORNER_LEFT_UPPER) ||
!ObjectSetInteger(0,
name,
OBJPROP_XDISTANCE,
x) ||
!ObjectSetInteger(0,
name,
OBJPROP_YDISTANCE,
y) ||
!ObjectSetInteger(0,
name,
OBJPROP_FONTSIZE,
fontSize) ||
!ObjectSetInteger(0,
name,
OBJPROP_COLOR,
textColor) ||
!ObjectSetInteger(0,
name,
OBJPROP_SELECTABLE,
false) ||
!ObjectSetInteger(0,
name,
OBJPROP_HIDDEN,
true))
{
Print("Prop Firm Guard: Could not configure label ",
name,
". Error: ",
GetLastError());
return(false);
}
if(!ObjectSetString(0,
name,
OBJPROP_FONT,
"Tahoma") ||
!ObjectSetString(0,
name,
OBJPROP_TEXT,
text))
{
Print("Prop Firm Guard: Could not initialize label ",
name,
". Error: ",
GetLastError());
return(false);
}
return(true);
}
//+------------------------------------------------------------------+
//| Update dashboard text |
//+------------------------------------------------------------------+
void UpdateDashboardText(const string objectName,
const string text)
{
// Update only objects that currently exist on the chart.
if(ObjectFind(0, objectName) < 0)
{
Print("Prop Firm Guard: Dashboard object not found: ",
objectName);
return;
}
if(!ObjectSetString(0,
objectName,
OBJPROP_TEXT,
text))
{
Print("Prop Firm Guard: Could not update dashboard object ",
objectName,
". Error: ",
GetLastError());
}
}
//+------------------------------------------------------------------+
//| Update dashboard color |
//+------------------------------------------------------------------+
void UpdateDashboardColor(const string objectName,
const color textColor)
{
// Change the color only when the dashboard object exists.
if(ObjectFind(0, objectName) < 0)
{
Print("Prop Firm Guard: Dashboard object not found: ",
objectName);
return;
}
if(!ObjectSetInteger(0,
objectName,
OBJPROP_COLOR,
textColor))
{
Print("Prop Firm Guard: Could not update dashboard color for ",
objectName,
". Error: ",
GetLastError());
}
}
//+------------------------------------------------------------------+
//| Update dashboard |
//+------------------------------------------------------------------+
void UpdateDashboard()
{
string sessionState;
string dailyStart;
string headerStatus;
ENUM_GUARD_STATUS guardStatus = GetOverallGuardStatus();
if(g_dailySession.balanceConfirmed)
{
sessionState = "Session: ACTIVE";
dailyStart = "Starting Balance: " + DoubleToString(g_dailySession.startingBalance, 2);
headerStatus = "STATUS: " + GuardStatusToString(guardStatus);
}
else
{
sessionState = "Session: AWAITING CONFIRMATION";
dailyStart = "Starting Balance: Not confirmed";
headerStatus = "STATUS: SETUP REQUIRED";
}
//--- Session
UpdateDashboardText(g_objectPrefix + "TradingDate",
"Trading Date: " + g_dailySession.tradingDate);
UpdateDashboardText(g_objectPrefix + "SessionState",
sessionState);
UpdateDashboardText(g_objectPrefix + "DailyStart",
dailyStart);
//--- Account
UpdateDashboardText(g_objectPrefix + "AccountLogin",
"Account: " + IntegerToString(g_accountState.login));
UpdateDashboardText(g_objectPrefix + "Balance",
"Balance: " + DoubleToString(g_accountState.balance, 2));
UpdateDashboardText(g_objectPrefix + "Equity",
"Equity: " + DoubleToString(g_accountState.equity, 2));
UpdateDashboardText(g_objectPrefix + "FloatingPL",
"Floating P/L: " + DoubleToString(g_accountState.floatingPL, 2));
//--- Daily drawdown
if(g_dailySession.balanceConfirmed)
{
UpdateDashboardText(g_objectPrefix + "DailyLossLimit",
"Maximum Loss: " +
DoubleToString(g_dailyDrawdown.maximumDailyLoss, 2) +
" (" +
DoubleToString(g_accountSettings.dailyDrawdownPercent, 2) +
"%)");
UpdateDashboardText(g_objectPrefix + "DailyCurrentLoss",
"Current Loss: " +
DoubleToString(g_dailyDrawdown.currentDailyLoss, 2) +
" (" +
DoubleToString(g_dailyDrawdown.drawdownPercent, 2) +
"%)");
UpdateDashboardText(g_objectPrefix + "DailyLimitUsage",
"Limit Used: " +
DoubleToString(g_dailyDrawdown.limitUsagePercent, 2) +
"%");
UpdateDashboardText(g_objectPrefix + "DailyRemaining",
"Remaining: " +
DoubleToString(g_dailyDrawdown.remainingAllowance, 2));
UpdateDashboardText(g_objectPrefix + "DailyDrawdownStatus",
"Status: " +
ComplianceStatusToString(g_dailyDrawdown.status));
}
else
{
UpdateDashboardText(g_objectPrefix + "DailyLossLimit", "Maximum Loss: --");
UpdateDashboardText(g_objectPrefix + "DailyCurrentLoss", "Current Loss: --");
UpdateDashboardText(g_objectPrefix + "DailyLimitUsage", "Limit Used: --");
UpdateDashboardText(g_objectPrefix + "DailyRemaining", "Remaining: --");
UpdateDashboardText(g_objectPrefix + "DailyDrawdownStatus", "Status: WAITING");
}
//--- Overall drawdown
UpdateDashboardText(g_objectPrefix + "OverallInitialBalance",
"Initial Balance: " +
DoubleToString(g_overallDrawdown.initialBalance, 2));
UpdateDashboardText(g_objectPrefix + "OverallFloor",
"Equity Floor: " +
DoubleToString(g_overallDrawdown.overallFloor, 2));
UpdateDashboardText(g_objectPrefix + "OverallEquity",
"Current Equity: " +
DoubleToString(g_overallDrawdown.currentEquity, 2));
UpdateDashboardText(g_objectPrefix + "OverallLoss",
"Overall Loss: " +
DoubleToString(g_overallDrawdown.currentOverallLoss, 2));
UpdateDashboardText(g_objectPrefix + "OverallLimitUsage",
"Limit Used: " +
DoubleToString(g_overallDrawdown.limitUsagePercent, 2) +
"%");
UpdateDashboardText(g_objectPrefix + "OverallRemaining",
"Remaining: " +
DoubleToString(g_overallDrawdown.remainingAllowance, 2));
UpdateDashboardText(g_objectPrefix + "OverallDrawdownStatus",
"Status: " +
ComplianceStatusToString(g_overallDrawdown.status));
//--- Profit target
UpdateDashboardText(g_objectPrefix + "TargetBalance",
"Target Balance: " +
DoubleToString(g_profitTarget.targetBalance, 2));
UpdateDashboardText(g_objectPrefix + "TargetCurrentProfit",
"Current Profit: " +
DoubleToString(g_profitTarget.currentProfit, 2));
UpdateDashboardText(g_objectPrefix + "TargetProgress",
"Progress: " +
DoubleToString(g_profitTarget.progressPercent, 2) +
"%");
UpdateDashboardText(g_objectPrefix + "TargetRemaining",
"Remaining: " +
DoubleToString(g_profitTarget.remainingProfit, 2));
UpdateDashboardText(g_objectPrefix + "ProfitTargetStatus",
"Status: " +
TargetStatusToString(g_profitTarget.status));
//--- News
if(g_newsState.status == NEWS_DISABLED)
{
UpdateDashboardText(g_objectPrefix + "NewsEvent",
"Filter: Disabled");
UpdateDashboardText(g_objectPrefix + "NewsTime",
"Trading Window: DISABLED");
UpdateDashboardText(g_objectPrefix + "NewsCountdown",
"Countdown: --");
UpdateDashboardText(g_objectPrefix + "NewsRule",
"Holding: --");
}
else if(g_newsState.status == NEWS_NO_EXPOSURE)
{
UpdateDashboardText(g_objectPrefix + "NewsEvent",
"No supported active exposure");
UpdateDashboardText(g_objectPrefix + "NewsTime",
"Trading Window: SAFE");
UpdateDashboardText(g_objectPrefix + "NewsCountdown",
"Countdown: --");
UpdateDashboardText(g_objectPrefix + "NewsRule",
"Holding: " +
GetNewsHoldingRuleText());
}
else if(!g_newsState.eventFound)
{
UpdateDashboardText(g_objectPrefix + "NewsEvent",
"No relevant event found");
UpdateDashboardText(g_objectPrefix + "NewsTime",
"Trading Window: SAFE");
UpdateDashboardText(g_objectPrefix + "NewsCountdown",
"Currencies: " +
g_newsState.currencyList);
UpdateDashboardText(g_objectPrefix + "NewsRule",
"Holding: " +
GetNewsHoldingRuleText());
}
else
{
UpdateDashboardText(g_objectPrefix + "NewsEvent",
g_newsState.eventCurrency +
" | " +
g_newsState.eventName +
" | " +
CalendarImportanceToString(g_newsState.importance));
UpdateDashboardText(g_objectPrefix + "NewsTime",
"Trading Window: " +
GetNewsTradingWindowText());
UpdateDashboardText(g_objectPrefix + "NewsCountdown",
"In: " +
FormatNewsCountdown(g_newsState.secondsToEvent));
UpdateDashboardText(g_objectPrefix + "NewsRule",
"Holding: " +
GetNewsHoldingRuleText() +
" | Affected: " +
IntegerToString(g_newsState.affectedPositions));
}
UpdateDashboardText(g_objectPrefix + "NewsStatus",
"Status: " +
NewsHoldingStatusToString(g_newsState.holdingStatus));
//--- Main header
UpdateDashboardText(g_objectPrefix + "OverallStatus",
headerStatus);
if(g_dailySession.balanceConfirmed)
UpdateDashboardColor(g_objectPrefix + "OverallStatus",
GetGuardStatusColor(guardStatus));
else
UpdateDashboardColor(g_objectPrefix + "OverallStatus",
clrDarkOrange);
//--- Status summary
UpdateDashboardText(g_objectPrefix + "StatusDaily",
"Daily DD: " +
(g_dailySession.balanceConfirmed ?
ComplianceStatusToString(g_dailyDrawdown.status) :
"WAITING"));
UpdateDashboardText(g_objectPrefix + "StatusOverall",
"Overall DD: " +
ComplianceStatusToString(g_overallDrawdown.status));
UpdateDashboardText(g_objectPrefix + "StatusTarget",
"Target: " +
TargetStatusToString(g_profitTarget.status));
UpdateDashboardText(g_objectPrefix + "StatusNews",
"News: " +
NewsHoldingStatusToString(g_newsState.holdingStatus));
ChartRedraw();
}
//+------------------------------------------------------------------+
//| Delete dashboard |
//+------------------------------------------------------------------+
void DeleteDashboard()
{
// Delete only chart objects created by Prop Firm Guard.
int deletedObjects = ObjectsDeleteAll(0, g_objectPrefix);
if(deletedObjects < 0)
{
Print("Prop Firm Guard: Could not delete dashboard objects. Error: ",
GetLastError());
}
ChartRedraw();
}
//+------------------------------------------------------------------+
//| Send guard notification |
//+------------------------------------------------------------------+
void SendGuardNotification(const string message)
{
Print("Prop Firm Guard: ",
message);
if(InpEnableAlerts)
Alert("Prop Firm Guard: ",
message);
if(!InpEnablePushNotifications)
return;
if(!TerminalInfoInteger(TERMINAL_NOTIFICATIONS_ENABLED))
{
Print("Prop Firm Guard: Push notifications are enabled in the EA ",
"but disabled in the terminal settings.");
return;
}
ResetLastError();
if(!SendNotification("Prop Firm Guard: " + message))
{
Print("Prop Firm Guard: Could not send push notification. Error: ",
GetLastError());
}
}
//+------------------------------------------------------------------+
//| Build daily drawdown alert |
//+------------------------------------------------------------------+
string BuildDailyDrawdownAlert(const ENUM_COMPLIANCE_STATUS status)
{
switch(status)
{
case COMPLIANCE_WARNING:
return("Daily drawdown reached WARNING level.");
case COMPLIANCE_CRITICAL:
return("CRITICAL: Only " +
DoubleToString(g_dailyDrawdown.remainingAllowance, 2) +
" remains before the daily loss limit.");
case COMPLIANCE_BREACHED:
return("Daily drawdown limit breached.");
case COMPLIANCE_SAFE:
default:
return("");
}
}
//+------------------------------------------------------------------+
//| Build overall drawdown alert |
//+------------------------------------------------------------------+
string BuildOverallDrawdownAlert(const ENUM_COMPLIANCE_STATUS status)
{
switch(status)
{
case COMPLIANCE_WARNING:
return("Overall drawdown reached WARNING level.");
case COMPLIANCE_CRITICAL:
return("CRITICAL: Only " +
DoubleToString(g_overallDrawdown.remainingAllowance, 2) +
" remains before the overall loss limit.");
case COMPLIANCE_BREACHED:
return("Overall drawdown limit breached.");
case COMPLIANCE_SAFE:
default:
return("");
}
}
//+------------------------------------------------------------------+
//| Check daily drawdown alert |
//+------------------------------------------------------------------+
void CheckDailyDrawdownAlert()
{
if(!g_dailySession.balanceConfirmed)
return;
if(g_dailyDrawdown.status == g_alertState.dailyDrawdownStatus)
return;
g_alertState.dailyDrawdownStatus = g_dailyDrawdown.status;
string message = BuildDailyDrawdownAlert(g_dailyDrawdown.status);
if(message == "")
return;
g_alertState.dashboardMessage = message;
SendGuardNotification(message);
}
//+------------------------------------------------------------------+
//| Check overall drawdown alert |
//+------------------------------------------------------------------+
void CheckOverallDrawdownAlert()
{
if(g_overallDrawdown.status == g_alertState.overallDrawdownStatus)
return;
g_alertState.overallDrawdownStatus = g_overallDrawdown.status;
string message = BuildOverallDrawdownAlert(g_overallDrawdown.status);
if(message == "")
return;
g_alertState.dashboardMessage = message;
SendGuardNotification(message);
}
//+------------------------------------------------------------------+
//| Check profit target alert |
//+------------------------------------------------------------------+
void CheckProfitTargetAlert()
{
if(g_profitTarget.status == g_alertState.profitTargetStatus)
return;
g_alertState.profitTargetStatus = g_profitTarget.status;
if(g_profitTarget.status != TARGET_REACHED)
return;
string message = "Profit target reached.";
g_alertState.dashboardMessage = message;
SendGuardNotification(message);
}
//+------------------------------------------------------------------+
//| Check economic news alerts |
//+------------------------------------------------------------------+
void CheckNewsAlert()
{
if(!InpEnableNewsFilter ||
!g_newsState.eventFound ||
g_newsState.affectedPositions == 0)
return;
// A new calendar event receives a fresh alert state.
if(g_alertState.newsEventId != g_newsState.eventId)
{
g_alertState.newsEventId = g_newsState.eventId;
g_alertState.newsApproachAlerted = false;
g_alertState.newsRestrictedAlerted = false;
}
long warningThreshold =
(long)InpMinutesBeforeNews * 60;
// Issue one advance warning when the event reaches the configured
// pre-news interval.
if(g_newsState.secondsToEvent > 0 &&
g_newsState.secondsToEvent <= warningThreshold &&
!g_alertState.newsApproachAlerted)
{
string message =
CalendarImportanceToString(g_newsState.importance) +
"-impact " +
g_newsState.eventCurrency +
" news in " +
IntegerToString((int)MathCeil((double)g_newsState.secondsToEvent / 60.0)) +
" minute(s): " +
g_newsState.eventName +
".";
g_alertState.newsApproachAlerted = true;
g_alertState.dashboardMessage = message;
SendGuardNotification(message);
}
// If holding is prohibited, report entry into the restricted window.
if(g_newsState.holdingStatus == NEWS_HOLDING_PROTECTION &&
!g_alertState.newsRestrictedAlerted)
{
string message =
"News holding restriction active for " +
g_newsState.eventCurrency +
" " +
g_newsState.eventName +
".";
g_alertState.newsRestrictedAlerted = true;
g_alertState.dashboardMessage = message;
SendGuardNotification(message);
}
}
//+------------------------------------------------------------------+
//| Manage alerts |
//+------------------------------------------------------------------+
void ManageAlerts()
{
CheckDailyDrawdownAlert();
CheckOverallDrawdownAlert();
CheckProfitTargetAlert();
CheckNewsAlert();
}
//+------------------------------------------------------------------+
//| Get dashboard alert message |
//+------------------------------------------------------------------+
string GetDashboardAlertMessage()
{
if(g_alertState.dashboardMessage != "")
return(g_alertState.dashboardMessage);
return("Monitoring account...");
}
//+------------------------------------------------------------------+
//| Get daily session status |
//+------------------------------------------------------------------+
string GetDailySessionStatus()
{
if(!g_dailySession.balanceConfirmed)
return("AWAITING_CONFIRMATION");
if(g_dailyDrawdown.status == COMPLIANCE_BREACHED ||
g_overallDrawdown.status == COMPLIANCE_BREACHED)
return("BREACHED");
if(g_profitTarget.status == TARGET_REACHED)
return("TARGET_REACHED");
if(g_dailyDrawdown.status == COMPLIANCE_CRITICAL ||
g_overallDrawdown.status == COMPLIANCE_CRITICAL)
return("CRITICAL");
if(g_dailyDrawdown.status == COMPLIANCE_WARNING ||
g_overallDrawdown.status == COMPLIANCE_WARNING)
return("WARNING");
return("ACTIVE");
}
//+------------------------------------------------------------------+
//| Update runtime daily-session state |
//+------------------------------------------------------------------+
bool UpdateDailySessionRuntimeState()
{
if(!g_hasDailySession)
return(false);
g_dailySession.latestBalance = g_accountState.balance;
g_dailySession.latestEquity = g_accountState.equity;
g_dailySession.targetProgress = g_profitTarget.progressPercent;
g_dailySession.sessionStatus = GetDailySessionStatus();
g_dailySession.updatedAt = TimeCurrent();
if(g_dailySession.balanceConfirmed)
{
g_dailySession.dailyLoss = g_dailyDrawdown.currentDailyLoss;
// Preserve the worst actual loss observed during this trading day.
if(g_dailyDrawdown.currentDailyLoss >
g_dailySession.maximumDailyLossReached)
{
g_dailySession.maximumDailyLossReached =
g_dailyDrawdown.currentDailyLoss;
}
}
else
{
g_dailySession.dailyLoss = 0.0;
}
return(SaveDailySession());
}
//+------------------------------------------------------------------+
//| Update runtime database when due |
//+------------------------------------------------------------------+
void UpdateRuntimeDatabase()
{
datetime currentTime = TimeCurrent();
// Runtime snapshots do not need the dashboard's one-second frequency.
if(g_lastRuntimeDatabaseUpdate != 0 &&
currentTime - g_lastRuntimeDatabaseUpdate < 10)
return;
if(UpdateDailySessionRuntimeState())
g_lastRuntimeDatabaseUpdate = currentTime;
}
//+------------------------------------------------------------------+
Reference in a new issue View git blame Copy permalink