/////////////////////////////////////////////////////// // // SaherElm IT Center XTest MQL5 Expert Advisor // ------------------------------------------------- // Name: XCHICHWAP // Description: an Exper Advisor which used to // XCH and XCHCHE Strategy to Analyse Market ... // // Maintainer: // ------------ // Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com) // //////////////////////////////////////////////////////x // // Global Properties ... #property copyright "Copyright 2023, SaherElm IT Center" #property link "https://saherelm.ir" #property version "1.00" #property description "SaherElm XCHICHWAP" #property strict // #define ShortName "XCHICHWAP" // // Imports ... #include "../Classes/x-saherelm.x121.xtrade.handler.class.mq5" #include "../Helpers/x-saherelm.xcc.helper.mq5" #include "../Helpers/x-saherelm.xct.helper.mq5" // #include "../Parsers/x-saherelm.xch.ichwap.parser.mq5" #include "../Strategies/x-saherelm.xch.ichwap.strategy.mq5" // // Inputs ... // // Common ... input group "Common"; input long eaMagicNumber = 78692110; // Magic Number input int eaSlippage = 10; // Slippgae input string eaLogSuffix = ""; // Log Suffix // // Symbols ... input group "Symbols"; input bool eaMultiSymbol = false; // Use Multi Symbol input bool eaUseMaxAllowedTradesPerSymbol = true; // Use Max Allowed Trades Per Symbol input string eaSymbols = "EURUSDb,GBPUSDb,EURGBPb,USDJPYb,EURJPYb,USDCHFb,EURCHFb,AUDUSDb,EURAUDb,NZDUSDb,EURNZDb,USDCADb,EURCADb,XAUUSDb,XAGUSDb,BRENT,DowJones30"; // Trading Symbols // // Risk Management ... input group "Risk Management"; // // Risk Management > Risk / Reward Calculation ... input group "Risk/Reward"; input bool eaIgnoreTP = false; // Ignore TP input bool eaIgnoreSL = false; // Ignore SL input double eaTPPoint = 200; // Static TP Point input double eaSLPoint = 200; // Static SL Point // // Risk Management > Volume Calculation ... input group "Volume"; input bool eaUseDynamicVolume = false; // Use Dynamic Volume input double eaDynamicVolumeStep = 0.01; // Increase Volume Step input double eaDynamicVolumeBalanceFactor = 200; // Balance Factor for Generate Dynamic Volume input double eaVolume = 0.02; // Static Volume // // Risk Management > Trade Management ... input group "Trade Management"; input bool eaAllowLong = true; // Allow Long Positions input bool eaAllowShort = true; // Allow Short Positions input int eaMaxAllowedLongs = 2; // Max Allowed Long Positions input int eaMaxAllowedShorts = 2; // Max Allowed Short Positions input double eaMaxDrawdownPercentForOpenTrades = 3; // Max Drawdown Percent for Open Trades // // Protector ... input group "Protector"; input int eaDelayBarBetweenTwoSameSignal = 5; // Delay Bars Between Two Same Type Signal // // Protector > Hedging Properties ... input group "Hedging"; input bool eaAllowHedge = false; // Allow Hedge Positions input double eaHedgeMinVolumeStep = 0.01; // Minimum Volume Step For Hedge input int eaMinimumOpenPositionsForHEHedge = 2; // Minimum Open Positions For HE Hedge input double eaHedgeHEMinProfitPerVolumeStep = 1; // Minimum Required Profit For HE Hedge Per Volume Step input double eaHedgeBEMinProfitPerVolumeStep = 0.5; // Minimum Required Profit For BE Hedge Per Volume Step // // Protector > In Profit Positions Protecting ... input group "In Profit Positions Protecting"; // // Trail ... input group "Trail"; input bool eaAllowTrail = false; // Allow Trail Stop for Positions input double eaTrailStartDistance = 35; // Specify Trail Start in Point input double eaTrailStep = 10; // Trail Step in Point input bool eaOnlyTrailUnprotected = true; // Only Trail Unprotected Positionss // // Partial Close (In Profit) ... input group "Partial Close"; input double eaPartialCloseInProfitDistance = 0; // Specify Partial Close Profit in Point input double eaPartialCloseInProfitVolume = 0; // Specify Partial Close in Profit Volume // // Protector > In Drawdown Positions Protecting ... input group "In Drawdown Positions Protecting"; // // Protect ... input group "Protect"; input bool eaAllowProtect = false; // Allow Proptecting input int eaProtectionDelay = 300; // Delay Between two Protection in Secconds input bool eaProtectOnConditions = true; // Do Protection only when Conditions happens input bool eaAllowDirectionProtct = false; // Allow also Directional Protect input double eaProtectionStartDistance = 100; // Protection Start Drawdown in Profit input double eaProtectionVolumeMultiplier = 1; // Protection Volume Multiplier // // Partial Close (In Drawdown) ... input group "Partial Close"; input double eaPartialCloseInDrawdownDistance = 0; // Specify Partial Close Drawdown in Point input double eaPartialCloseInDrawdownVolume = 0; // Specify Partial Close in Drawdown Volume // // Alert ... input group "Alert"; input bool eAEnableAlerts = true; // Enable Alerts input bool eALogAlerts = true; // Log Alerts input bool eAMailAlerts = false; // Mail Alerts input bool eAPushAlerts = false; // Push Alerts input bool eATerminalAlerts = false; // Terminal Alerts // // Time Report ... input group "Reports"; input bool eaAlertNewMonths = false; // Alert New Month input bool eaAlertNewWeeks = false; // Alert New Weeks input bool eaAlertNewDays = true; // Alert New Days input bool eaAlertNewHours = false; // Alert New Hours input bool eaAlertRawSignals = false; // Alert Raw Signals input bool eaAlertStrongSignals = false; // Alert Strong Signals // // Variables ... // // Bar Style nad Time Instances ... XSCXCTHelper *mCTHelper; XSCXCCHelper *mCCHelper; // // Registred Strategies ... XSCBaseStrategy *strategies[]; // // Trader Instance Class ... XSCTrade *eaTrader; // // Alert Class ... XSCAlert *eaAlert; // // Time Tracker ... XTimeTracker eaTimeTracker; // // Trade Handler Instance Class ... X121SCTradeHandler *eaTradeHandler; // string mTag = ""; // double eaR2R = 1.5; datetime lastSignalOn = NULL; bool eaUseFixedTPSLPoints = true; bool eaEnableLongs = eaAllowLong && eaMaxAllowedLongs >= 0; bool eaEnableShorts = eaAllowShort && eaMaxAllowedShorts >= 0; // // Event Handlers ... // // Initialization ... int OnInit() { // if (!ValidateInputs()) { return INIT_PARAMETERS_INCORRECT; } // if (!InitEA()) { return INIT_FAILED; } // mTag = !IsValid(eaLogSuffix) ? ShortName : ShortName + "_" + eaLogSuffix; // drawPrefix = mTag; // // EventSetTimer(1); // EventSetMillisecondTimer(100); // // Alert Initialization ... string msg = "Initialized Successfully ..."; eaAlert.Alert(msg); // // Init Succeed ... return INIT_SUCCEEDED; } // // DeInitialization ... void OnDeinit(const int reason) { // // REASON_PROGRAM 0 The EA has stopped working calling the ExpertRemove() function // REASON_REMOVE 1 Program removed from a chart // REASON_RECOMPILE 2 Program recompiled // REASON_CHARTCHANGE 3 A symbol or a chart period is changed // REASON_CHARTCLOSE 4 Chart closed // REASON_PARAMETERS 5 Inputs changed by a user // REASON_ACCOUNT 6 Another account has been activated or reconnection to the trade server has occurred due to changes in the account settings // REASON_TEMPLATE 7 Another chart template applied // REASON_INITFAILED 8 The OnInit() handler returned a non-zero value // REASON_CLOSE 9 Terminal closed // // Alert De Initialization Succeeded ... string msg = "De Initialized Successfully ..."; eaAlert.Alert(msg); // // De Initialize XSampleEA Providers ... delete mCTHelper; delete mCCHelper; // delete eaAlert; delete eaTrader; delete eaTradeHandler; // Clean(strategies); } // // On Tick Handler ... void OnTick() { // HandleTradeState(); HandleTimeReport(); HandleStrategiesOnTick(); } // // Handle On Trade Event ... void OnTrade() { eaTrader.HandleOnTrade(); } // // On Timer ... void OnTimer() { // // HandleTradeState(); // HandleTimeReport(); // HandleStrategiesOnTick(); } // // Custom Functions ... // // Validate Inputs ... bool ValidateInputs() { // bool result = false; // string errMessage = ""; // bool isCommonValid = ( // eaSlippage > 0 && eaMagicNumber > 0 // ); if (!isCommonValid) { // errMessage += "common configurations error;" + "\n"; } // bool isSymbolsValid = ( // eaMultiSymbol ? IsValid(eaSymbols) : true // ); if (!isSymbolsValid) { // errMessage += "symbols configurations error;" + "\n"; } // bool isRiskRewardValid = ( // (eaUseFixedTPSLPoints ? eaTPPoint > 0 || eaSLPoint > 0 : eaR2R > 0) && !(eaIgnoreTP && eaIgnoreSL) // ); if (!isRiskRewardValid) { // errMessage += "risk/reward configurations error;" + "\n"; } // bool isVolumeValid = ( // eaUseDynamicVolume ? eaDynamicVolumeStep >= 0.01 && eaDynamicVolumeBalanceFactor > 0 : eaVolume >= 0.01 // ); if (!isVolumeValid) { // errMessage += "volume configurations error;" + "\n"; } // bool isTradeManagementValid = ( // !(!eaAllowLong && !eaAllowShort) && eaMaxAllowedLongs >= 0 && eaMaxAllowedShorts >= 0 // ); if (!isTradeManagementValid) { // errMessage += "trade management configurations error;" + "\n"; } // result = // // Common ... isCommonValid && // // Symbols ... isSymbolsValid && // // Risk/Reward ... isRiskRewardValid && // // Volume ... isVolumeValid && // // Trade Management ... isTradeManagementValid // ; // if (!result) { Print("Errors: \n", errMessage); } // return result; } // // Initialize all Requirements ... bool InitEA() { // bool result = false; // // Bar Timer ... XCTInputs ctInputs; ctInputs.Default(); mCTHelper = new XSCXCTHelper(); result = mCTHelper.Init( _Symbol, _Period, ctInputs // ); if (!result) { return result; } // // Bar Styles ... XCCInputs ccInputs; ccInputs.Default(); mCCHelper = new XSCXCCHelper(); result = mCCHelper.Init( _Symbol, _Period, ccInputs // ); if (!result) { return result; } // // Create Instance of Alert Class ... eaAlert = new XSCAlert(); eaAlert.SetPrefix(mTag); eaAlert.SetLogAlerts(eALogAlerts); eaAlert.SetMailAlerts(eAMailAlerts); eaAlert.SetPushAlerts(eAPushAlerts); eaAlert.SetEnableAlerts(eAEnableAlerts); eaAlert.SetTerminalAlerts(eATerminalAlerts); // // Create Trader Instance ... eaTrader = new XSCTrade( eaSlippage, eaMagicNumber // ); eaTrader.AddOnStopLossEventHandler(OnStopLossTriggered); eaTrader.AddOnTakeProfitEventHandler(OnTakeProfitTriggered); eaTrader.AddOnForceClosePositionEventHandler(OnPositionForceClosed); // // Initialize Trade Handler ... eaTradeHandler = new X121SCTradeHandler(eaTrader); eaTradeHandler.SaveTrades(true); eaTradeHandler.SaveSignals(true); eaTradeHandler.SaveConditions(true); // // Configure Alerts ... eaTradeHandler.SetAlertPrefix(mTag); eaTradeHandler.SetAlertEnableAlerts(eAEnableAlerts); eaTradeHandler.SetAlertLogAlerts(eALogAlerts); eaTradeHandler.SetAlertMailAlerts(eAMailAlerts); eaTradeHandler.SetAlertPushAlerts(eAPushAlerts); eaTradeHandler.SetAlertTerminalAlerts(eATerminalAlerts); // // Configure Trade Management ... eaTradeHandler.AllowLong(eaAllowLong); eaTradeHandler.AllowShort(eaAllowShort); eaTradeHandler.MaxAllowedLongs(eaMaxAllowedLongs); eaTradeHandler.MaxAllowedShorts(eaMaxAllowedShorts); eaTradeHandler.UseMaxAllowedTradesPerSymbol(eaUseMaxAllowedTradesPerSymbol); eaTradeHandler.MaxDrawdownPercentForOpenTrades(eaMaxDrawdownPercentForOpenTrades); // // Configure Position Protector ... // eaTradeHandler.DelayBarBetweenTwoSignal(eaDelayBarBetweenTwoSameSignal); // // Configure Hedging ... eaTradeHandler.AllowHedge(eaAllowHedge); eaTradeHandler.HedgeMinVolumeStep(eaHedgeMinVolumeStep); eaTradeHandler.MinimumOpenPositionsForHEHedge(eaMinimumOpenPositionsForHEHedge); eaTradeHandler.HedgeHEMinProfitPerVolumeStep(eaHedgeHEMinProfitPerVolumeStep); eaTradeHandler.HedgeBEMinProfitPerVolumeStep(eaHedgeBEMinProfitPerVolumeStep); // // In Profit Position Protecting ... // // Trail ... eaTradeHandler.AllowTrail(eaAllowTrail); eaTradeHandler.TrailStartDistance(eaTrailStartDistance); eaTradeHandler.TrailStep(eaTrailStep); eaTradeHandler.OnlyTrailUnprotected(eaOnlyTrailUnprotected); // // Partial Close (In Profit) ... eaTradeHandler.PartialCloseInProfitDistance(eaPartialCloseInProfitDistance); eaTradeHandler.PartialCloseInProfitVolume(eaPartialCloseInProfitVolume); // // In Drawdown Positions Protecting ... // // Protect ... eaTradeHandler.AllowProtect(eaAllowProtect); eaTradeHandler.ProtectionDelay(eaProtectionDelay); eaTradeHandler.ProtectOnConditions(eaProtectOnConditions); eaTradeHandler.AllowDirectionProtct(eaAllowDirectionProtct); eaTradeHandler.ProtectionStartDistance(eaProtectionStartDistance); eaTradeHandler.ProtectionVolumeMultiplier(eaProtectionVolumeMultiplier); // // Partial Close (In Profit) ... eaTradeHandler.PartialCloseInDrawdownDistance(eaPartialCloseInDrawdownDistance); eaTradeHandler.PartialCloseInDrawdownVolume(eaPartialCloseInDrawdownVolume); // // Configure Strategies ... // // Single Symbol ... if (!eaMultiSymbol) { // // Register XCHICHWAP Strategy ... // // Create Class Instance ... XSCXCHICHWAPStrategy *xchichwapStrategy; xchichwapStrategy = new XSCXCHICHWAPStrategy( _Symbol, _Period, PERIOD_H1, // Analyzing Period eaVolume, eaR2R, // R2R ... eaSlippage, eaMagicNumber, true, // Ignore Signal Execution eaUseFixedTPSLPoints, // Use TP SL Point false, // Use Max eaTPPoint, // TP eaSLPoint, // SL eaIgnoreTP, eaIgnoreSL, eaAllowLong, eaAllowShort, eaMaxAllowedLongs, // Max Longs eaMaxAllowedShorts // Max Shorts ); // // Configuere Strategy ... xchichwapStrategy.DrawImportantAreas(false); xchichwapStrategy.AddXCHSignalEventHandler(OnSignalRecieved); // // Configure Alerts ... xchichwapStrategy.SetAlertPrefix(mTag); xchichwapStrategy.SetAlertEnableAlerts(eAEnableAlerts); xchichwapStrategy.SetAlertLogAlerts(eALogAlerts); xchichwapStrategy.SetAlertMailAlerts(eAMailAlerts); xchichwapStrategy.SetAlertPushAlerts(eAPushAlerts); xchichwapStrategy.SetAlertTerminalAlerts(eATerminalAlerts); // // Register Strategy ... RegisterStrategy(xchichwapStrategy); } // // Multi Symbol ... else { // // Parse Symbols ... string symbols[]; int symbolsCount = SplitContent( symbols, eaSymbols // ); result = IsValidSize(symbolsCount); if (!result) { return result; } // for (int i = 0; i < symbolsCount; i++) { // // Select Symbol ... string iSymbol = symbols[i]; // // Register XCHICHWAP Strategy ... // // Create Class Instance ... XSCXCHICHWAPStrategy *iXCHICHWAPStrategy; iXCHICHWAPStrategy = new XSCXCHICHWAPStrategy( iSymbol, _Period, PERIOD_H1, // Analyzing Period eaVolume, eaR2R, // R2R ... eaSlippage, eaMagicNumber, true, // Ignore Signal Execution eaUseFixedTPSLPoints, // Use TP SL Point false, // Use Max eaTPPoint, // TP eaSLPoint, // SL eaIgnoreTP, eaIgnoreSL, eaAllowLong, eaAllowShort, eaMaxAllowedLongs, // Max Longs eaMaxAllowedShorts // Max Shorts ); // // Configuere Strategy ... iXCHICHWAPStrategy.DrawImportantAreas(false); iXCHICHWAPStrategy.AddXCHSignalEventHandler(OnSignalRecieved); // // Configure Alerts ... iXCHICHWAPStrategy.SetAlertPrefix(mTag); iXCHICHWAPStrategy.SetAlertEnableAlerts(eAEnableAlerts); iXCHICHWAPStrategy.SetAlertLogAlerts(eALogAlerts); iXCHICHWAPStrategy.SetAlertMailAlerts(eAMailAlerts); iXCHICHWAPStrategy.SetAlertPushAlerts(eAPushAlerts); iXCHICHWAPStrategy.SetAlertTerminalAlerts(eATerminalAlerts); // // Register Strategy ... RegisterStrategy(iXCHICHWAPStrategy); } } // return result; } // // HANDLERS ... // // Call All Registered Strategis Tick Handler Functions ... void HandleStrategiesOnTick() { // int count = ArraySize(strategies); if (!IsValidSize(count)) { return; } // for (int i = 0; i < count; i++) { // // Call Tick Handler Function ... strategies[i].HandleTick(); } } // // Manage Trading States ... void HandleTradeState() { // // Implement All Trade States here ... eaTradeHandler.UpdateData(); // // Do Protection Senarios ... eaTradeHandler.HandleProtection(); } // // Time Reporting ... void HandleTimeReport() { // // Monthly Report .... if (eaAlertNewMonths && eaTimeTracker.IsNewMonth()) { // string msg = "New Month ..."; // eaAlert.Alert(msg); } // // Weekly Report .... if (eaAlertNewWeeks && eaTimeTracker.IsNewWeek()) { // string msg = "New Week ..."; // eaAlert.Alert(msg); } // // Daily Report .... if (eaAlertNewDays && eaTimeTracker.IsNewDay()) { // string msg = "New Day ..."; // eaAlert.Alert(msg); } // // Hourly Report .... if (eaAlertNewHours && eaTimeTracker.IsNewHour()) { // string msg = "New Hour ..."; // eaAlert.Alert(msg); } } // // Report Account Balance ... void HandleReportBalance() { // if (!IsRunningOnTestMode()) { return; } // string msg = "Balance: " + ToString(eaTrader.mAccount.GetBalance()); eaAlert.Log(msg); } // // SIGNAL EVENT Handlers ... // // All Signals from Strategies Comming Here for Execution or // Analyzing ... void OnSignalRecieved( XSignal &signal, XCHStrategyConditions &conditions // ) { // // Check Signal and Conditions Validations ... // if (!signal.IsValid()) { return; } // if (!conditions.IsValid()) { return; } // bool isLong = IsLong(signal.type); // // Notify When a Raw (Unfiltered) Signal Recieved // if it's Provided ... if (eaAlertRawSignals) { // string msg = "Raw " + (IsLong(signal.type) ? "Long" : "Short") + " Signal Recieved: (" + signal.provider + "," + signal.symbol + "," + ToString(signal.period) + ") ..."; eaAlert.Alert(msg); } // // Prepare Signal Dynamic Volume // if Provided ... if (eaUseDynamicVolume && eaDynamicVolumeStep > 0 && eaDynamicVolumeBalanceFactor > 0) { // double dVolume = eaTrader.GetDynamicVolume( signal.symbol, eaDynamicVolumeBalanceFactor, eaDynamicVolumeStep // ); // if (dVolume > 0) { signal.volume = dVolume; } else { signal.volume = eaVolume; } // eaTradeHandler.UpdateSignal(signal); } else { signal.volume = eaVolume; } // // Chekc Signalling Enable or not ... bool canContinue = isLong ? eaEnableLongs : eaEnableShorts; if (!canContinue) { return; } // // Since Signal Filtering done based on // Strategy and it's not related to Public // TradeHandler for Seperation of Concern issue, // we do this here ... XCHICHWAPStartegyConditionsParser chcichwapParser; // bool isFiltered = chcichwapParser.IsFiltered( signal, conditions // ); if (isFiltered) { // eaTradeHandler.RemoveSignal(signal); return; } // // Attach Conditions Summary to Signal ... string conditionsSummary = conditions.GenerateSummary( false, false, true, false // ); // signal.conditions = chcichwapParser.GenerateSignalConditions( signal, conditions // ); // // Check Signal Delay ... datetime currentTime = TimeCurrent(); int delay = eaDelayBarBetweenTwoSameSignal; bool isDelayPassed = delay <= 0 ? true : !IsValid(lastSignalOn) ? true : MathAbs(TimeToSeconds(currentTime)) - MathAbs(TimeToSeconds(lastSignalOn)) >= ulong(delay * PeriodSeconds(_Period)); if (!isDelayPassed) { return; } // // Execute Signal Using Trade Handler ... ENUM_X_SIGNAL_EXECUTION_RESULT state; bool isExecuted = eaTradeHandler.ExecuteSignal( signal, state // ); // if (isExecuted) { lastSignalOn = currentTime; } } // // Handle StopLoss Triggered Positions ... void OnStopLossTriggered(const XDeal &deal) { // // Finish ... eaTradeHandler.Finish(deal); // HandleReportBalance(); } // // Handle Take Profit Triggered Positions ... void OnTakeProfitTriggered(const XDeal &deal) { // // Finish ... eaTradeHandler.Finish(deal); // HandleReportBalance(); } // // Handle Force Close a Position ... void OnPositionForceClosed( const ulong ticket, const XPosition &position, const string comment // ) { // // Finish ... eaTradeHandler.Finish( ticket, position, comment // ); // HandleReportBalance(); } // // HELPERS ... // // Register Strategy ... void RegisterStrategy(XSCBaseStrategy *strategy) { // if (strategy == NULL) { return; } // ArrayResize( strategies, ArraySize(strategies) + 1 // ); // strategies[ArraySize(strategies) - 1] = strategy; } //