diff --git a/BKPS/14030505/Test/x-saherelm.test.setup.mq5 b/BKPS/14030505/Test/x-saherelm.test.setup.mq5 new file mode 100644 index 0000000..8e7b6df --- /dev/null +++ b/BKPS/14030505/Test/x-saherelm.test.setup.mq5 @@ -0,0 +1,1779 @@ +/////////////////////////////////////////////////////// +// +// SaherElm IT Center MQL5 Class Library +// ---------------------------------------------- +// Name: XTestSetup +// Description: provides implementation of Test +// Setup ... +// +// +// Maintainer: +// ------------ +// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com) +// +////////////////////////////////////////////////////// +// +// Global Properties ... +#property library +#property copyright "Copyright 2023, SaherElm IT Center" +#property link "https://www.saherelm.ir" +#property version "1.00" +#property strict + +// +// Imports ... + +// +#include "../Libraries/x-saherelm.xtrade.lib.mq5" +#include "../Classes/x-saherelm.xalert.class.mq5" + +// +#include "../Helpers/x-saherelm.xrl.helper.mq5" +#include "../Helpers/x-saherelm.xmc.helper.mq5" +#include "../Helpers/x-saherelm.xpv.helper.mq5" +#include "../Helpers/x-saherelm.xtd.helper.mq5" +#include "../Helpers/x-saherelm.xhk.helper.mq5" +#include "../Helpers/x-saherelm.xsln.helper.mq5" +#include "../Helpers/x-saherelm.xstr.helper.mq5" +#include "../Helpers/x-saherelm.xche.helper.mq5" +#include "../Helpers/x-saherelm.xich.helper.mq5" +#include "../Helpers/x-saherelm.xmrb.helper.mq5" +#include "../Helpers/x-saherelm.xosc.helper.mq5" +#include "../Helpers/x-saherelm.xvlm.helper.mq5" +#include "../Helpers/x-saherelm.xhtd.helper.mq5" +#include "../Helpers/x-saherelm.xchma.helper.mq5" +#include "../Helpers/x-saherelm.xatsl.helper.mq5" +#include "../Helpers/x-saherelm.xdmnt.helper.mq5" +#include "../Helpers/x-saherelm.xasct.helper.mq5" +#include "../Helpers/x-saherelm.xsslc.helper.mq5" +#include "../Helpers/x-saherelm.xhull.helper.mq5" +#include "../Helpers/x-saherelm.xadxtd.helper.mq5" + +// +struct XTestInputs +{ + // + // Props ... + + // + // Commons ... + string symbol; // Symbol + ENUM_TIMEFRAMES period; // Time Frame + + // + double volume; // + double tpPoint; // + double slPoint; // + + // + // Helpers Inputs ... + XRLInputs rlInputs; // XRL Inputs + XMCInputs mcInputs; // XMC Inputs + XPVInputs pvInputs; // XPV Inputs + XTDInputs tdInputs; // XTD Inputs + XHKInputs hkInputs; // XHK Inputs + XHTDInputs htdInputs; // XHTD Inputs + XCHEInputs cheInputs; // XCHE Inputs + XICHInputs ichInputs; // XICH Inputs + XSTRInputs strInputs; // XSTR Inputs + XMRBInputs mrbInputs; // XMRB Inputs + XOSCInputs oscInputs; // XOSC Inputs + XVLMInputs vlmInputs; // XVLM Inputs + XSLNInputs slnInputs; // XSLN Inputs + XCHMAInputs chmaInputs; // XCHMA Inputs + XATSLInputs atslInputs; // XATSL Inputs + XDMNTInputs dmntInputs; // XDMNT Inputs + XASCTInputs asctInputs; // XASCT Inputs + XSSLCInputs sslcInputs; // XSSLC Inputs + XHULLInputs hullInputs; // XHULL Inputs + XADXTDInputs adxtdInputs; // XADXTD Inputs + + // + // Constructor ... + XTestInputs() + { + Clean(); + } + + // + // Tools ... + // + bool Init() + { + // + Default(); + + // + bool result = IsValid(); + + // + return result; + } + bool Init( + string _symbol, // Symbol + ENUM_TIMEFRAMES _period, // Time Frame + XRLInputs &_rlInputs, // XRL Inputs + XMCInputs &_mcInputs, // XMC Inputs + XPVInputs &_pvInputs, // XPV Inputs + XTDInputs &_tdInputs, // XTD Inputs + XHKInputs &_hkInputs, // XHK Inputs + XHTDInputs &_htdInputs, // XHTD Inputs + XCHEInputs &_cheInputs, // XCHE Inputs + XICHInputs &_ichInputs, // XICH Inputs + XSTRInputs &_strInputs, // XSTR Inputs + XMRBInputs &_mrbInputs, // XMRB Inputs + XOSCInputs &_oscInputs, // XOSC Inputs + XVLMInputs &_vlmInputs, // XVLM Inputs + XSLNInputs &_slnInputs, // XSLN Inputs + XCHMAInputs &_chmaInputs, // XCHMA Inputs + XATSLInputs &_atslInputs, // XATSL Inputs + XDMNTInputs &_dmntInputs, // XDMNT Inputs + XASCTInputs &_asctInputs, // XASCT Inputs + XSSLCInputs &_sslcInputs, // XSSLC Inputs + XHULLInputs &_hullInputs, // XHULL Inputs + XADXTDInputs &_adxtdInputs // XADXTD Inputs + ) + { + // + this.symbol = _symbol; + this.period = _period; + + // + // Helpers Inputs ... + this.rlInputs = _rlInputs; + this.mcInputs = _mcInputs; + this.pvInputs = _pvInputs; + this.tdInputs = _tdInputs; + this.hkInputs = _hkInputs; + this.htdInputs = _htdInputs; + this.cheInputs = _cheInputs; + this.ichInputs = _ichInputs; + this.strInputs = _strInputs; + this.mrbInputs = _mrbInputs; + this.oscInputs = _oscInputs; + this.vlmInputs = _vlmInputs; + this.chmaInputs = _chmaInputs; + this.atslInputs = _atslInputs; + this.dmntInputs = _dmntInputs; + this.asctInputs = _asctInputs; + this.sslcInputs = _sslcInputs; + this.hullInputs = _hullInputs; + this.adxtdInputs = _adxtdInputs; + + // + bool result = IsValid(); + + // + return result; + } + + // + // Cleanup ... + void Clean() + { + // + symbol = NULL; + period = NULL; + + // + tpPoint = 0; + slPoint = 0; + + // + rlInputs.Clean(); + mcInputs.Clean(); + pvInputs.Clean(); + tdInputs.Clean(); + hkInputs.Clean(); + cheInputs.Clean(); + ichInputs.Clean(); + strInputs.Clean(); + mrbInputs.Clean(); + oscInputs.Clean(); + vlmInputs.Clean(); + slnInputs.Clean(); + htdInputs.Clean(); + chmaInputs.Clean(); + asctInputs.Clean(); + sslcInputs.Clean(); + hullInputs.Clean(); + atslInputs.Clean(); + dmntInputs.Clean(); + adxtdInputs.Clean(); + } + + // + // Default ... + void Default() + { + // + tpPoint = 0; + slPoint = 0; + + // + rlInputs.Default(); + mcInputs.Default(); + pvInputs.Default(); + tdInputs.Default(); + hkInputs.Default(); + cheInputs.Default(); + ichInputs.Default(); + strInputs.Default(); + mrbInputs.Default(); + oscInputs.Default(); + vlmInputs.Default(); + slnInputs.Default(); + htdInputs.Default(); + chmaInputs.Default(); + asctInputs.Default(); + sslcInputs.Default(); + hullInputs.Default(); + atslInputs.Default(); + dmntInputs.Default(); + adxtdInputs.Default(); + } + + // + // Validate ... + bool IsValid() + { + // + bool result = false; + + // + result = + // + IsValid(symbol) && + IsValid(period) + // + ; + if (!result) + { + return result; + } + + // + result = rlInputs.IsValid(); + if (!result) + { + return result; + } + + // + result = chmaInputs.IsValid(); + if (!result) + { + return result; + } + + // + result = tdInputs.IsValid(); + if (!result) + { + return result; + } + + // + result = slnInputs.IsValid(); + if (!result) + { + return result; + } + + // + result = pvInputs.IsValid(); + if (!result) + { + return result; + } + + // + result = hkInputs.IsValid(); + if (!result) + { + return result; + } + + // + result = cheInputs.IsValid(); + if (!result) + { + return result; + } + + // + result = ichInputs.IsValid(); + if (!result) + { + return result; + } + + // + result = strInputs.IsValid(); + if (!result) + { + return result; + } + + // + result = mrbInputs.IsValid(); + if (!result) + { + return result; + } + + // + result = oscInputs.IsValid(); + if (!result) + { + return result; + } + + // + result = vlmInputs.IsValid(); + if (!result) + { + return result; + } + + // + result = mcInputs.IsValid(); + if (!result) + { + return result; + } + + // + result = asctInputs.IsValid(); + if (!result) + { + return result; + } + + // + result = sslcInputs.IsValid(); + if (!result) + { + return result; + } + + // + result = hullInputs.IsValid(); + if (!result) + { + return result; + } + + // + result = adxtdInputs.IsValid(); + if (!result) + { + return result; + } + + // + result = htdInputs.IsValid(); + if (!result) + { + return result; + } + + // + result = atslInputs.IsValid(); + if (!result) + { + return result; + } + + // + result = dmntInputs.IsValid(); + if (!result) + { + return result; + } + + // + return result; + } +}; + +// +struct XTestConditions +{ + // + // Props ... + // + // Common ... + string symbol; + ENUM_TIMEFRAMES period; + datetime time; + + // + // Conditions ... + XRLConditions rlConditions; + XMCConditions mcConditions; + XPVConditions pvConditions; + XTDConditions tdConditions; + XHKConditions hkConditions; + XCHEConditions cheConditions; + XICHConditions ichConditions; + XSTRConditions strConditions; + XMRBConditions mrbConditions; + XVLMConditions vlmConditions; + XHTDConditions htdConditions; + XSLNConditions slnConditions; + XCHMAConditions chmaConditions; + XATSLConditions atslConditions; + XASCTConditions asctConditions; + XSSLCConditions sslcConditions; + XHULLConditions hullConditions; + XDMNTConditions dmntConditions; + XADXTDConditions adxtdConditions; + + // + // Oscillators ... + double cci[]; + double rsi[]; + double macd[]; + double macdSignal[]; + + // + // Signal ... + + // + // Conditions Provided Signal ... + XSignal signal; + + // + // Signal Verifications ... + int pushers; + + // + // Signal Providers .... + string providers[]; + + // + // Conditions Verifications ... + int longVerifications; + int shortVerifications; + + // + void CleanSignal() + { + // + signal.Clean(); + Clean(providers); + + // + pushers = 0; + longVerifications = 0; + shortVerifications = 0; + } + + // + // Generate Conditions Based Signals ... + bool GenerateSignal( + double &tp, + double &sl, + double volume, + double tpPoint, + double slPoint // + ) + { + // + bool result = false; + + // + bool hasLong = GenerateLongSignal( + tp, + sl, + volume, + tpPoint, + slPoint // + ); + if (hasLong) + { + // + result = hasLong; + return result; + } + + // + bool hasShort = GenerateShortSignal( + tp, + sl, + volume, + tpPoint, + slPoint // + ); + if (hasShort) + { + // + result = hasShort; + return result; + } + + // + return result; + } + + // + bool GenerateLongSignal( + double &tp, + double &sl, + double volume, + double tpPoint, + double slPoint // + ) + { + // + bool result = false; + + // + double mTP = 0; + double mSL = 0; + double mR2R = 1.5; + double mEntry = 0; + + // + ENUM_POSITION_TYPE mType = POSITION_TYPE_BUY; + ENUM_X_ORDER_MODES mMode = X_ORDER_MODE_MARKET; + + // + mEntry = GetEntry( + symbol, + mType // + ); + + // + // XATRL ... + bool long1 = + // + // Start Conditions ... + (rlConditions.isVerifierSwitchedToBullish && + rlConditions.isFastBullish && + rlConditions.isSlowBearish && + rlConditions.isFastOverSlow) + // + && + // + // Verifications ... + // XSTR ... + (strConditions.isTrendBullish || + strConditions.isTrendSwitchedToBullish) + // + && + // + // XATSL ... + (atslConditions.isBullish || + atslConditions.isSwitchedToBullish) + // + && + // + // XHTD ... + (htdConditions.isBullish || + htdConditions.isSwitchedToBullish) + // + && + // + // XVLM ... + (vlmConditions.isVolumeBullish || + vlmConditions.isVolumeChangedToBullish) + // + && + // + // XCHE ... + (cheConditions.isBullish || + cheConditions.isStrongBullish || + cheConditions.isSwitchedToBullish || + cheConditions.isStrongSwitchedToBullish) + // + && + // + // XHK ... + (hkConditions.isHKBullish || + hkConditions.isSMHKBullish || + hkConditions.isHKSwitchedToBullish || + hkConditions.isSMHKSwitchedToBullish) + // + ; + if (long1) + { + // + Add( + "XATRL", + providers // + ); + + // + pushers++; + + // + // Calculate TP and SL ... + + // + mSL = atslConditions.atsl[1]; + + // + double risk = MathAbs(mSL - mEntry); + double reward = risk * mR2R; + + // + mTP = mEntry + reward; + + // + tp = mTP; + sl = mSL; + } + + // + result = + // + long1 + // + ; + if (result) + { + // + result = signal.Prepare( + symbol, + "XATRL", + period, + mType, + mMode, + mEntry, + volume, + 0, // mSL, + mTP // + ); + // if (result) + // { + // // + // XSignal opposit; + // bool canSupport = signal.GenerateOpposit(opposit); + // if (canSupport) + // { + // // + // AddRef( + // opposit, + // signal.supports // + // ); + // } + // } + } + + // + return result; + } + + // + bool GenerateShortSignal( + double &tp, + double &sl, + double volume, + double tpPoint, + double slPoint // + ) + { + // + bool result = false; + + // + return result; + + // + double mTP = 0; + double mSL = 0; + double mR2R = 1.5; + double mEntry = 0; + + // + ENUM_POSITION_TYPE mType = POSITION_TYPE_SELL; + ENUM_X_ORDER_MODES mMode = X_ORDER_MODE_MARKET; + + // + mEntry = GetEntry( + symbol, + mType // + ); + + // + // XATRL ... + bool long1 = + // + (rlConditions.isVerifierSwitchedToBullish && + rlConditions.isFastBullish && + rlConditions.isSlowBearish && + rlConditions.isFastOverSlow && + atslConditions.isBullish) + // + ; + if (long1) + { + // + Add( + "XATRL", + providers // + ); + + // + pushers++; + + // + // Calculate TP and SL ... + + // + mSL = atslConditions.atsl[1]; + + // + double risk = MathAbs(mSL - mEntry); + double reward = risk * mR2R; + + // + mSL = mEntry + risk; + mTP = mEntry - reward; + + // + tp = mTP; + sl = mSL; + } + + // + result = + // + long1 + // + ; + if (result) + { + // + result = signal.Prepare( + symbol, + "XATRL", + period, + mType, + mMode, + mEntry, + volume, + mSL, + mTP // + ); + } + + // + return result; + } + + // + // Generate Supports ... + // TODO: + + // + // Tools ... + + // + // Cleanup ... + void Clean() + { + // + time = NULL; + symbol = NULL; + period = NULL; + + // + Clean(cci); + Clean(rsi); + Clean(macd); + Clean(macdSignal); + + // + rlConditions.Clean(); + mcConditions.Clean(); + tdConditions.Clean(); + hkConditions.Clean(); + cheConditions.Clean(); + ichConditions.Clean(); + strConditions.Clean(); + mrbConditions.Clean(); + vlmConditions.Clean(); + slnConditions.Clean(); + htdConditions.Clean(); + chmaConditions.Clean(); + atslConditions.Clean(); + asctConditions.Clean(); + sslcConditions.Clean(); + hullConditions.Clean(); + dmntConditions.Clean(); + adxtdConditions.Clean(); + + // + CleanSignal(); + } + + // + void GenerateScore( + double &bullishScore, + double &bearishScore // + ) + { + // + bullishScore = 0; + bearishScore = 0; + + // + double tempBullishScore = 0; + double tempBearishScore = 0; + + // + rlConditions.GenerateScore( + tempBullishScore, + tempBearishScore // + ); + bullishScore += tempBullishScore; + bearishScore += tempBearishScore; + + // + mcConditions.GenerateScore( + tempBullishScore, + tempBearishScore // + ); + bullishScore += tempBullishScore; + bearishScore += tempBearishScore; + + // + pvConditions.GenerateScore( + tempBullishScore, + tempBearishScore // + ); + bullishScore += tempBullishScore; + bearishScore += tempBearishScore; + + // + slnConditions.GenerateScore( + tempBullishScore, + tempBearishScore // + ); + bullishScore += tempBullishScore; + bearishScore += tempBearishScore; + + // + adxtdConditions.GenerateScore( + tempBullishScore, + tempBearishScore // + ); + bullishScore += tempBullishScore; + bearishScore += tempBearishScore; + + // + strConditions.GenerateScore( + tempBullishScore, + tempBearishScore // + ); + bullishScore += tempBullishScore; + bearishScore += tempBearishScore; + + // + cheConditions.GenerateScore( + tempBullishScore, + tempBearishScore // + ); + bullishScore += tempBullishScore; + bearishScore += tempBearishScore; + + // + asctConditions.GenerateScore( + tempBullishScore, + tempBearishScore // + ); + bullishScore += tempBullishScore; + bearishScore += tempBearishScore; + + // + tdConditions.GenerateScore( + tempBullishScore, + tempBearishScore // + ); + bullishScore += tempBullishScore; + bearishScore += tempBearishScore; + + // + ichConditions.GenerateScore( + tempBullishScore, + tempBearishScore // + ); + bullishScore += tempBullishScore; + bearishScore += tempBearishScore; + + // + hkConditions.GenerateScore( + tempBullishScore, + tempBearishScore // + ); + bullishScore += tempBullishScore; + bearishScore += tempBearishScore; + + // + mrbConditions.GenerateScore( + tempBullishScore, + tempBearishScore // + ); + bullishScore += tempBullishScore; + bearishScore += tempBearishScore; + + // + vlmConditions.GenerateScore( + tempBullishScore, + tempBearishScore // + ); + bullishScore += tempBullishScore; + bearishScore += tempBearishScore; + + // + sslcConditions.GenerateScore( + tempBullishScore, + tempBearishScore // + ); + bullishScore += tempBullishScore; + bearishScore += tempBearishScore; + + // + chmaConditions.GenerateScore( + tempBullishScore, + tempBearishScore // + ); + bullishScore += tempBullishScore; + bearishScore += tempBearishScore; + + // + hullConditions.GenerateScore( + tempBullishScore, + tempBearishScore // + ); + bullishScore += tempBullishScore; + bearishScore += tempBearishScore; + + // + htdConditions.GenerateScore( + tempBullishScore, + tempBearishScore // + ); + bullishScore += tempBullishScore; + bearishScore += tempBearishScore; + + // + atslConditions.GenerateScore( + tempBullishScore, + tempBearishScore // + ); + bullishScore += tempBullishScore; + bearishScore += tempBearishScore; + + // + dmntConditions.GenerateScore( + tempBullishScore, + tempBearishScore // + ); + bullishScore += tempBullishScore; + bearishScore += tempBearishScore; + + // + } + + // + string GenerateSummary( + bool onlyCommons = false, + bool onlyConditions = false, + bool includeScores = true, + bool ignoreFalseConditions = true, + string separator = "\n" // + ) + { + // + string result = NULL; + + // + double bullishScore = 0; + double bearishScore = 0; + GenerateScore( + bullishScore, + bearishScore // + ); + + // + string scoresStr = + // + "Scores: " + separator + + "---------------" + separator + + "Bullish: " + ToString(bullishScore) + separator + + "Bearish: " + ToString(bearishScore) + separator + + "" + // + ; + + // + string commonStr = GenerateSpecifiedCommonSummary( + this, + separator, + includeScores // + ); + + // + string pvSummary = pvConditions.GenerateSummary(false, true, false, ignoreFalseConditions); + string rlSummary = rlConditions.GenerateSummary(false, true, false, ignoreFalseConditions); + string mcSummary = mcConditions.GenerateSummary(false, true, false, ignoreFalseConditions); + string tdSummary = tdConditions.GenerateSummary(false, true, false, ignoreFalseConditions); + string hkSummary = hkConditions.GenerateSummary(false, true, false, ignoreFalseConditions); + string strSummary = strConditions.GenerateSummary(false, true, false, ignoreFalseConditions); + string cheSummary = cheConditions.GenerateSummary(false, true, false, ignoreFalseConditions); + string ichSummary = ichConditions.GenerateSummary(false, true, false, ignoreFalseConditions); + string mrbSummary = mrbConditions.GenerateSummary(false, true, false, ignoreFalseConditions); + string vlmSummary = vlmConditions.GenerateSummary(false, true, false, ignoreFalseConditions); + string slnSummary = slnConditions.GenerateSummary(false, true, false, ignoreFalseConditions); + string htdSummary = htdConditions.GenerateSummary(false, true, false, ignoreFalseConditions); + string chmaSummary = chmaConditions.GenerateSummary(false, true, false, ignoreFalseConditions); + string atslSummary = atslConditions.GenerateSummary(false, true, false, ignoreFalseConditions); + string asctSummary = asctConditions.GenerateSummary(false, true, false, ignoreFalseConditions); + string sslcSummary = sslcConditions.GenerateSummary(false, true, false, ignoreFalseConditions); + string hullSummary = hullConditions.GenerateSummary(false, true, false, ignoreFalseConditions); + string dmntSummary = dmntConditions.GenerateSummary(false, true, false, ignoreFalseConditions); + string adxtdSummary = adxtdConditions.GenerateSummary(false, true, false, ignoreFalseConditions); + + // + string conditionsStr = + // + pvSummary + separator + + rlSummary + separator + + mcSummary + separator + + tdSummary + separator + + hkSummary + separator + + ichSummary + separator + + mrbSummary + separator + + vlmSummary + separator + + slnSummary + separator + + strSummary + separator + + cheSummary + separator + + asctSummary + separator + + sslcSummary + separator + + hullSummary + separator + + adxtdSummary + separator + + htdSummary + separator + + atslSummary + separator + + dmntSummary + separator + + chmaSummary + separator + + "" + // + ; + + // + result = + // + "[" + GetTag() + "]" + separator + + (onlyConditions + ? "" + : commonStr) + + (!includeScores + ? "" + : scoresStr) + + " " + separator + + (onlyCommons + ? "" + : conditionsStr) + + "" + // + ; + + // + return result; + } + + // + string GetTag() + { + return "XTestSetup"; + } + + // +}; + +// +// Class ... +class XSCXTestSetup : public XSCBaseAlert +{ + // + // Public ... +public: + // + // Props ... + XSCXRLHelper *rlHelper; + XSCXMCHelper *mcHelper; + XSCXPVHelper *pvHelper; + XSCXTDHelper *tdHelper; + XSCXHKHelper *hkHelper; + XSCXCHEHelper *cheHelper; + XSCXICHHelper *ichHelper; + XSCXSTRHelper *strHelper; + XSCXMRBHelper *mrbHelper; + XSCXOSCHelper *oscHelper; + XSCXVLMHelper *vlmHelper; + XSCXSLNHelper *slnHelper; + XSCXHTDHelper *hdtHelper; + XSCXASCTHelper *asctHelper; + XSCXSSLCHelper *sslcHelper; + XSCXHULLHelper *hullHelper; + XSCXATSLHelper *atslHelper; + XSCXCHMAHelper *chmaHelper; + XSCXDMNTHelper *dmntHelper; + XSCXADXTDHelper *adxtdHelper; + + // + XBarTracker barTracker; + + // + // Constructor(s) ... + void XSCXTestSetup() {} + + // + // Deconstructor ... + void ~XSCXTestSetup() + { + // + delete rlHelper; + delete mcHelper; + delete pvHelper; + delete tdHelper; + delete hkHelper; + delete cheHelper; + delete ichHelper; + delete strHelper; + delete mrbHelper; + delete oscHelper; + delete vlmHelper; + delete hdtHelper; + delete asctHelper; + delete sslcHelper; + delete hullHelper; + delete atslHelper; + delete chmaHelper; + delete dmntHelper; + delete adxtdHelper; + } + + // + // Initializer ... + bool Init( + XTestInputs &_inputs // Configurations + ) + { + // + bool result = false; + + // + result = _inputs.IsValid(); + if (!result) + { + return result; + } + + // + inputs = _inputs; + + // + // Initialize Helpers ... + + // + // XRL ... + rlHelper = new XSCXRLHelper(); + result = rlHelper.Init( + inputs.symbol, + inputs.period, + inputs.rlInputs // + ); + if (!result) + { + return result; + } + + // + // XPV ... + pvHelper = new XSCXPVHelper(); + result = pvHelper.Init( + inputs.symbol, + inputs.period, + inputs.pvInputs // + ); + if (!result) + { + return result; + } + + // + // XCHMA ... + chmaHelper = new XSCXCHMAHelper(); + result = chmaHelper.Init( + inputs.symbol, + inputs.period, + inputs.chmaInputs // + ); + if (!result) + { + return result; + } + + // + // XSLN ... + slnHelper = new XSCXSLNHelper(); + result = slnHelper.Init( + inputs.symbol, + inputs.period, + inputs.slnInputs // + ); + if (!result) + { + return result; + } + + // + // XTD ... + tdHelper = new XSCXTDHelper(); + result = tdHelper.Init( + inputs.symbol, + inputs.period, + inputs.tdInputs // + ); + if (!result) + { + return result; + } + + // + // XHTD ... + hdtHelper = new XSCXHTDHelper(); + result = hdtHelper.Init( + inputs.symbol, + inputs.period, + inputs.htdInputs // + ); + if (!result) + { + return result; + } + + // + // XATSL ... + atslHelper = new XSCXATSLHelper(); + result = atslHelper.Init( + inputs.symbol, + inputs.period, + inputs.atslInputs // + ); + if (!result) + { + return result; + } + + // + // XDMNT ... + dmntHelper = new XSCXDMNTHelper(); + result = dmntHelper.Init( + inputs.symbol, + inputs.period, + inputs.dmntInputs // + ); + if (!result) + { + return result; + } + + // + // XHK ... + hkHelper = new XSCXHKHelper(); + result = hkHelper.Init( + inputs.symbol, + inputs.period, + inputs.hkInputs // + ); + if (!result) + { + return result; + } + + // + // XCHE ... + cheHelper = new XSCXCHEHelper(); + result = cheHelper.Init( + inputs.symbol, + inputs.period, + inputs.cheInputs // + ); + if (!result) + { + return result; + } + + // + // XICH ... + ichHelper = new XSCXICHHelper(); + result = ichHelper.Init( + inputs.symbol, + inputs.period, + inputs.ichInputs // + ); + if (!result) + { + return result; + } + + // + // XSTR ... + strHelper = new XSCXSTRHelper(); + result = strHelper.Init( + inputs.symbol, + inputs.period, + inputs.strInputs // + ); + if (!result) + { + return result; + } + + // + // XMRB ... + mrbHelper = new XSCXMRBHelper(); + result = mrbHelper.Init( + inputs.symbol, + inputs.period, + inputs.mrbInputs // + ); + if (!result) + { + return result; + } + + // + // XOSC ... + oscHelper = new XSCXOSCHelper(); + result = oscHelper.Init( + inputs.symbol, + inputs.period, + inputs.oscInputs // + ); + if (!result) + { + return result; + } + + // + // XVLM ... + vlmHelper = new XSCXVLMHelper(); + result = vlmHelper.Init( + inputs.symbol, + inputs.period, + inputs.vlmInputs // + ); + if (!result) + { + return result; + } + + // + // XMC ... + mcHelper = new XSCXMCHelper(); + result = mcHelper.Init( + inputs.symbol, + inputs.period, + inputs.mcInputs // + ); + if (!result) + { + return result; + } + + // + // XASCT ... + asctHelper = new XSCXASCTHelper(); + result = asctHelper.Init( + inputs.symbol, + inputs.period, + inputs.asctInputs // + ); + if (!result) + { + return result; + } + + // + // XSSLC ... + sslcHelper = new XSCXSSLCHelper(); + result = sslcHelper.Init( + inputs.symbol, + inputs.period, + inputs.sslcInputs // + ); + if (!result) + { + return result; + } + + // + // XHULL ... + hullHelper = new XSCXHULLHelper(); + result = hullHelper.Init( + inputs.symbol, + inputs.period, + inputs.hullInputs // + ); + if (!result) + { + return result; + } + + // + // XADXTD ... + adxtdHelper = new XSCXADXTDHelper(); + result = adxtdHelper.Init( + inputs.symbol, + inputs.period, + inputs.adxtdInputs // + ); + if (!result) + { + return result; + } + + // + // Initial Bar Tracker ... + result = barTracker.Init( + inputs.symbol, + inputs.period // + ); + if (!result) + { + return result; + } + + // + return result; + } + + // + // Getter(s) / Setter(s) ... + + // + string GetSymbol() + { + return inputs.symbol; + } + + // + ENUM_TIMEFRAMES GetPeriod() + { + return inputs.period; + } + + // + XTestInputs GetInputs() + { + return inputs; + } + + // + bool SetInputs( + XTestInputs &_inputs // Configurations + ) + { + return Init(_inputs); + } + + // + // Tools ... + + // + // Retrieve Conditions ... + bool GetConditions( + XTestConditions &conditions, // + int barIndex = 0, // + int loopback = 5 // + ) + { + // + bool result = false; + + // + conditions.Clean(); + + // + conditions.symbol = GetSymbol(); + conditions.period = GetPeriod(); + conditions.time = TimeCurrent(); + + // + // Checking Can Process Bar ... + result = barTracker.CanProcessBar(); + if (!result) + { + return result; + } + + // + result = rlHelper.GetConditions( + conditions.rlConditions, + barIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + result = hdtHelper.GetConditions( + conditions.htdConditions, + barIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + result = slnHelper.GetConditions( + conditions.slnConditions, + barIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + result = chmaHelper.GetConditions( + conditions.chmaConditions, + barIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + result = atslHelper.GetConditions( + conditions.atslConditions, + barIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + result = dmntHelper.GetConditions( + conditions.dmntConditions, + barIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + result = pvHelper.GetConditions( + conditions.pvConditions, + barIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + result = tdHelper.GetConditions( + conditions.tdConditions, + barIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + result = hkHelper.GetConditions( + conditions.hkConditions, + barIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + result = cheHelper.GetConditions( + conditions.cheConditions, + barIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + result = ichHelper.GetConditions( + conditions.ichConditions, + barIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + result = strHelper.GetConditions( + conditions.strConditions, + barIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + result = mrbHelper.GetConditions( + conditions.mrbConditions, + barIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + result = mcHelper.GetConditions( + conditions.mcConditions, + barIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + result = asctHelper.GetConditions( + conditions.asctConditions, + barIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + result = vlmHelper.GetConditions( + conditions.vlmConditions, + barIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + result = sslcHelper.GetConditions( + conditions.sslcConditions, + barIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + result = hullHelper.GetConditions( + conditions.hullConditions, + barIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + result = adxtdHelper.GetConditions( + conditions.adxtdConditions, + barIndex, + loopback // + ); + if (!result) + { + return result; + } + + // + oscHelper.CopyCCI( + barIndex, + loopback, + conditions.cci // + ); + oscHelper.CopyRSI( + barIndex, + loopback, + conditions.rsi // + ); + oscHelper.CopyMACD( + barIndex, + loopback, + conditions.macd // + ); + oscHelper.CopyMACDSignal( + barIndex, + loopback, + conditions.macdSignal // + ); + + // + // Generating Signal ... + double mTP = 0; + double mSL = 0; + bool hasSignal = conditions.GenerateSignal( + mTP, + mSL, + inputs.volume, + inputs.tpPoint, + inputs.slPoint // + ); + if (hasSignal) + { + barTracker.Waits(); + } + + // + return result; + } + + // + // Protected ... +protected: + // + // Private ... +private: + // + // Props ... + XTestInputs inputs; // Setup Configurations ... +}; + +// \ No newline at end of file diff --git a/BKPS/14030505/Test/x-saherelm.test.xea.mq5 b/BKPS/14030505/Test/x-saherelm.test.xea.mq5 new file mode 100644 index 0000000..95efcd5 --- /dev/null +++ b/BKPS/14030505/Test/x-saherelm.test.xea.mq5 @@ -0,0 +1,354 @@ +/////////////////////////////////////////////////////// +// +// SaherElm IT Center MQL5 Class Library +// ---------------------------------------------- +// Name: XSCXTestSetupEA +// Description: provides implementation of XTest +// Setup EA ... +// +// +// Maintainer: +// ------------ +// Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com) +// +////////////////////////////////////////////////////// +// +// Global Properties ... +#property library +#property copyright "Copyright 2023, SaherElm IT Center" +#property link "https://www.saherelm.ir" +#property version "1.00" +#property strict + +// +// Imports ... +#include "../Test/x-saherelm.test.setup.mq5" +#include "../Classes/x-saherelm.xea.class.mq5" + +// +class XSCXTestSetupEA : public XSCBaseEA +{ + // + // Public ... +public: + // + // Constructors ... + XSCXTestSetupEA( + // + // XTrade Class Requirements ... + int slippage, // Specify Slippage + ulong magicNumber, // Specify Magic Number + // + // XSCTrade Event Handlers ... + TOnSignal onSignal = NULL, // On Signal Recieved Event Handler + TOnModify onModifyPosition = NULL, // On Modify Position Event Handler + TOnStopLoss onStopLossTriggered = NULL, // On StopLoass Triggered Event Handler + TOnTakeProfit onTakeProfitTriggered = NULL, // On TakeProfit Triggered Event Handler + TOnForceClose onForceClosePosition = NULL, // On Force Close Position Event Handler + TOnPartialClose onPartialClosePosition = NULL, // On Partial Close Position Event Handler + TOnDealsChanged onDealsChangedHandler = NULL, // On Deals Changed Event Handler + TOnOrdersChanged onOrdersChangedHandler = NULL, // On Orders Changed Event Handler + TOnPositionsChanged onPositionsChangedHandler = NULL, // On Positions Changed Event Handler + TOnTradeStateChanged onTradeStateChangedHandler = NULL // On Trade State Changed Event Handler + ) : XSCBaseEA(slippage, + magicNumber, + onSignal, + onModifyPosition, + onStopLossTriggered, + onTakeProfitTriggered, + onForceClosePosition, + onPartialClosePosition, + onDealsChangedHandler, + onOrdersChangedHandler, + onPositionsChangedHandler, + onTradeStateChangedHandler // + ) + { + // + DefaultConfig(); + } + + // + // Deconstructor ... + ~XSCXTestSetupEA() {} + + // + // Getter(s) / Setter(s) ... + + // + double Volume() + { + return mVolume; + } + + // + void Volume(double value) + { + // + if (value < 0.01) + { + value = 0.01; + } + + // + mVolume = value; + } + + // + bool AllowLong() + { + return mAllowLong; + } + + // + void AllowLong(bool value) + { + mAllowLong = value; + } + + // + bool AllowShort() + { + return mAllowShort; + } + + // + void AllowShort(bool value) + { + mAllowShort = value; + } + + // + // Add Setup ... + bool AddSetup(XSCXTestSetup *setup) + { + // + bool result = false; + + // + result = setup != NULL; + if (!result) + { + return result; + } + + // + Add( + setup, + setups // + ); + + // + return result; + } + + // + // Overrides ... + + // + // Customize Token ... + string GetToken() override + { + return GetSpecificToken(this); + } + + // + string GetTag() override + { + return this.GetToken(); + } + + // + // Check Provider for any Guards ... + bool CheckForGuard(XGuard &guards[]) override + { + // + bool result = false; + + // + return result; + } + + // + // Request Fro Signals ... + int RequestForSignal( + XSignal &signals[] // Holds Signals ... + ) override + { + // + int result = 0; + + // + int count = CountSetups(); + if (!IsValidSize(count)) + { + return result; + } + + // + for (int i = 0; i < count; i++) + { + // + XTestConditions iConditions; + bool iHasConditions = setups[i].GetConditions( + iConditions, + 0, + 5 // + ); + if (!iHasConditions) + { + continue; + } + + // + // Check iConditions Signal is Valid or not ... + bool hasSignal = iConditions.signal.IsValid(); + if (!hasSignal) + { + continue; + } + + // + bool isLong = IsLong(iConditions.signal.type); + + // + // TODO: Implement Management ... + + // + AddRef( + iConditions.signal, + signals // + ); + } + + // + result = ArraySize(signals); + + // + return result; + } + + // + // Protected ... +protected: + // + // Private ... +private: + // + // Props ... + + // + bool mVolume; + bool mAllowLong; + bool mAllowShort; + + // + void DefaultConfig() + { + // + Volume(0.01); + AllowLong(true); + AllowShort(true); + } + + // + // Provider(s) ... + + // + XSCXTestSetup *setups[]; + + // + int CountSetups() + { + return ArraySize(setups); + } + + // + int FindSetupIndex( + string _symbol // + ) + { + // + int result = -1; + + // + if (!IsValid(_symbol)) + { + return result; + } + + // + int count = CountSetups(); + if (!IsValidSize(count)) + { + return result; + } + + // + for (int i = 0; i < count; i++) + { + // + bool isOwn = _symbol == setups[i].GetSymbol(); + if (isOwn) + { + // + result = i; + break; + } + } + + // + return result; + } + + // + int FindSetupIndex( + string _symbol, // + ENUM_TIMEFRAMES _period // + ) + { + // + int result = -1; + + // + if (!IsValid(_symbol)) + { + return result; + } + + // + if (!IsValid(_period)) + { + return result; + } + + // + int count = CountSetups(); + if (!IsValidSize(count)) + { + return result; + } + + // + for (int i = 0; i < count; i++) + { + // + bool isOwn = + _symbol == setups[i].GetSymbol() && + _period == setups[i].GetPeriod(); + if (isOwn) + { + // + result = i; + break; + } + } + + // + return result; + } + + // +}; + +// \ No newline at end of file