1374 lines
29 KiB
Plaintext
1374 lines
29 KiB
Plaintext
////////////////////////////////////////////////////////////
|
|
//
|
|
// SaherElm IT Center MQL5 XUSCHF5 Signal Provider Library
|
|
// --------------------------------------------------------
|
|
// Name: XUSCHF5SignalProvider
|
|
// Description: XUSCHF5 based signal provider ...
|
|
//
|
|
//
|
|
// 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
|
|
|
|
#define XUSCHF5ProviderName "XUSCHF5"
|
|
|
|
//
|
|
// START Inputs ...
|
|
//
|
|
|
|
#include "x-saherelm.xuschf5.provider.inputs.lib.mq5";
|
|
|
|
//
|
|
// END Inputs ...
|
|
//
|
|
|
|
//
|
|
// Include Common Library ...
|
|
#include "../Libraries/x-saherelm.common.lib.mq5"
|
|
|
|
//
|
|
// Include Logger Library ...
|
|
#include "../Libraries/x-saherelm.log.lib.mq5"
|
|
|
|
//
|
|
// Include Alert Library ...
|
|
#include "../Libraries/x-saherelm.alert.lib.mq5"
|
|
|
|
//
|
|
// Include Draw Library ...
|
|
#include "../Libraries/x-saherelm.draw.lib.mq5"
|
|
|
|
//
|
|
// Include Class Libraries ...
|
|
#include "../Classes/x-saherelm.class.lib.mq5"
|
|
|
|
//
|
|
// START Global Definitions: Variables, Properties and etc ...
|
|
//
|
|
|
|
//
|
|
XCGuard *xUSCHF5Guard;
|
|
XCTrade *xUSCHF5Trader;
|
|
XCReporter *xUSCHF5Reporter;
|
|
XCCollector *xUSCHF5Collector;
|
|
XCAccountInfo *xUSCHF5AccountInfo;
|
|
XCVolumeManager *xUSCHF5VolumeManager;
|
|
|
|
//
|
|
#include "x-saherelm.xuschf5.provider.indicators.lib.mq5"
|
|
|
|
//
|
|
// Controlling Variables ...
|
|
bool xUSCHF5MEnableProvider = false;
|
|
bool xUSCHF5MAllowLongTrades = false;
|
|
bool xUSCHF5MAllowShortTrades = false;
|
|
|
|
//
|
|
double xUSCHF5Deposit = 0;
|
|
double xUSCHF5Balance = 0;
|
|
double xUSCHF5MinReward = 0;
|
|
double xUSCHF5FreeMargin = 0;
|
|
double xUSCHF5BalanceForOpenTrades = 0;
|
|
double xUSCHF5FreeMarginForOpenTrades = 0;
|
|
|
|
//
|
|
// Guard ...
|
|
double xUSCHF5CriticalDrawDown = 0;
|
|
double xUSCHF5MaxAllowedDrawDown = 0;
|
|
|
|
//
|
|
double xUSCHF5MaxDrawUp = 0;
|
|
double xUSCHF5MaxDrawDown = 0;
|
|
|
|
//
|
|
int NOT_ENOUGH_MONEY_ERROR = 4756;
|
|
const string XUSCHF5_SUPPORT_ID = "SP";
|
|
|
|
//
|
|
// END Global Definitions: Variables, Properties and etc ...
|
|
//
|
|
|
|
//
|
|
// START Provided Functions ...
|
|
//
|
|
|
|
//
|
|
// Initial Library if required ...
|
|
bool XUSCHF5InitSignalProviderLibrary()
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
if (!xUSCHF5EnableProvider)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Controlling Variables ...
|
|
xUSCHF5MEnableProvider = xUSCHF5EnableProvider;
|
|
xUSCHF5MAllowLongTrades = xUSCHF5AllowLongTrades;
|
|
xUSCHF5MAllowShortTrades = xUSCHF5AllowShortTrades;
|
|
|
|
//
|
|
// Validate Inputs ...
|
|
result = XUSCHF5ValidateInputs();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Init Indicators ...
|
|
result = XUSCHF5InitIndicators();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
xUSCHF5Reporter = new XCReporter();
|
|
xUSCHF5Collector = new XCCollector();
|
|
xUSCHF5AccountInfo = new XCAccountInfo();
|
|
|
|
//
|
|
// Calculate Account Deposit ...
|
|
xUSCHF5Deposit = xUSCHF5AccountInfo.GetInitialBalance();
|
|
|
|
//
|
|
// Prepare Min Reward ...
|
|
if (xUSCHF5MinRewardInPips > 0)
|
|
{
|
|
xUSCHF5MinReward = PipsToPrice(xUSCHF5MinRewardInPips);
|
|
}
|
|
|
|
//
|
|
// Calculate Min Balance for Trades ...
|
|
if (xUSCHF5BalanceFactorForOpenTrades > 0)
|
|
{
|
|
xUSCHF5BalanceForOpenTrades = xUSCHF5BalanceFactorForOpenTrades * xUSCHF5Deposit;
|
|
}
|
|
|
|
//
|
|
// Claculate Min Free Marging for Trades ...
|
|
if (xUSCHF5FreeMarginFactorForOpenTrades > 0)
|
|
{
|
|
xUSCHF5FreeMarginForOpenTrades = xUSCHF5FreeMarginFactorForOpenTrades * xUSCHF5Deposit;
|
|
}
|
|
|
|
//
|
|
// Calculate Init Time Critical DrawDown Value ...
|
|
if (xUSCHF5CriticalDrawDownFactor > 0)
|
|
{
|
|
xUSCHF5CriticalDrawDown = xUSCHF5CriticalDrawDownFactor * xUSCHF5Deposit;
|
|
}
|
|
|
|
//
|
|
// Calculate Init Time Max Allowed DrawDown Value ...
|
|
if (xUSCHF5MaxAllowedDrawDownFactor > 0)
|
|
{
|
|
xUSCHF5MaxAllowedDrawDown = xUSCHF5MaxAllowedDrawDownFactor * xUSCHF5Deposit;
|
|
}
|
|
|
|
//
|
|
// Instant Volume Manager ...
|
|
xUSCHF5VolumeManager = new XCVolumeManager(
|
|
xUSCHF5StaticVolumeFactor,
|
|
xUSCHF5StaticVolumeMethod,
|
|
xUSCHF5VolumeMultiplier,
|
|
xUSCHF5ApplyVolumeMultiplierFactor,
|
|
xUSCHF5MaxSupportedVolumePerTradeFactor,
|
|
xUSCHF5IncreasedMaxSupportedVolumeRate);
|
|
|
|
//
|
|
// Make XCTrader instance ...
|
|
xUSCHF5Trader = new XCTrade(
|
|
XUSCHF5ProviderName,
|
|
_Symbol,
|
|
xUSCHF5Slippage,
|
|
xUSCHF5MagicNumber,
|
|
xUSCHF5UseVirtualTPSl,
|
|
xUSCHF5MaxAllowedTrades,
|
|
xUSCHF5FreeMarginForOpenTrades,
|
|
xUSCHF5BalanceForOpenTrades);
|
|
|
|
//
|
|
// Instantiate Account Guard ...
|
|
xUSCHF5Guard = new XCGuard(
|
|
//
|
|
// Old Trades ...
|
|
xUSCHF5MaxAllowedTradeAge,
|
|
xUSCHF5OldTradesAction,
|
|
//
|
|
// Critical DrawDown ...
|
|
xUSCHF5CriticalDrawDownFactor,
|
|
xUSCHF5CriticalGuardAction,
|
|
//
|
|
// Max Allowed DrawDown ...
|
|
xUSCHF5MaxAllowedDrawDownFactor,
|
|
xUSCHF5MaxAllowedGuardAction,
|
|
xUSCHF5GuardStopoutFiredAfterTouches,
|
|
//
|
|
// xUSCHF5GuardSupportMethod
|
|
X_SUPPORT_DO_NOTHING
|
|
//
|
|
);
|
|
|
|
//
|
|
// Reset Calculations Buffers and Variables ...
|
|
XUSCHF5ResetCollectors();
|
|
|
|
//
|
|
XUSCHF5UpdateReports();
|
|
|
|
//
|
|
result = true;
|
|
|
|
//
|
|
// Logging State ...
|
|
XUSCHF5IssueInitializationSucceedAlert();
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// DeInitial Library if required ...
|
|
void XUSCHF5DeinitSignalProviderLibrary(const int reason)
|
|
{
|
|
//
|
|
// Release Handlers ...
|
|
XUSCHF5ReleaseIndicators();
|
|
|
|
//
|
|
// Logging State ...
|
|
XUSCHF5IssueDeinitializationSucceedAlert();
|
|
}
|
|
|
|
//
|
|
// this is a Globally Function which do all of
|
|
// checkings and positions handling ...
|
|
void XUSCHF5SignalProviderHandleTick()
|
|
{
|
|
//
|
|
// Check Provider is Enable or Not ...
|
|
if (!xUSCHF5MEnableProvider)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
XUSCHF5SignalProviderDoControlState();
|
|
|
|
//
|
|
// Reading Indicator Buffers ...
|
|
XUSCHF5HandleReadingBuffers();
|
|
if (xUSCHF5CalculatedBars < xUSCHF5MaxLengthOfInputs)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Handle Open Trades ...
|
|
XUSCHF5HandleOpenTrades();
|
|
|
|
//
|
|
// Handle Close Trades ...
|
|
XUSCHF5HandleCloseTrades();
|
|
|
|
//
|
|
// DrawDown and DrawUp ...
|
|
XUSCHF5HandleCalculateDrawDownUp();
|
|
}
|
|
|
|
//
|
|
// Do Control Checks here ...
|
|
void XUSCHF5SignalProviderDoControlState()
|
|
{
|
|
//
|
|
// Update account Balance ...
|
|
xUSCHF5Balance = xUSCHF5AccountInfo.GetBalance();
|
|
xUSCHF5FreeMargin = xUSCHF5AccountInfo.GetFreeMargin();
|
|
|
|
//
|
|
// Check Provider is Enable or Not ...
|
|
if (!xUSCHF5MEnableProvider)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Protect Account by Guarding Maximum Drawdown ...
|
|
// TODO: add Guard Result here ...
|
|
string guardMessage = "";
|
|
XGuardHandlerResult guardHandlerResult;
|
|
bool isGuarded = xUSCHF5Guard.Guard(
|
|
guardHandlerResult,
|
|
guardMessage,
|
|
xUSCHF5Trader,
|
|
_Period);
|
|
if (isGuarded)
|
|
{
|
|
//
|
|
// Criticals ...
|
|
int criticalsCount = ArraySize(guardHandlerResult.criticals);
|
|
if (criticalsCount > 0)
|
|
{
|
|
//
|
|
for (int i = 0; i < criticalsCount; i++)
|
|
{
|
|
//
|
|
XSignal iSignal = guardHandlerResult.criticals[i];
|
|
|
|
//
|
|
XUSCHF5OnGuard(
|
|
iSignal,
|
|
X_GUARDED_CRITICAL,
|
|
guardMessage);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Maxes ...
|
|
int maxesCount = ArraySize(guardHandlerResult.maxes);
|
|
if (maxesCount > 0)
|
|
{
|
|
//
|
|
for (int i = 0; i < maxesCount; i++)
|
|
{
|
|
//
|
|
XSignal iSignal = guardHandlerResult.maxes[i];
|
|
|
|
//
|
|
XUSCHF5OnGuard(
|
|
iSignal,
|
|
X_GUARDED_MAX,
|
|
guardMessage,
|
|
guardHandlerResult.isStopOut);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Olds ...
|
|
int oldsCount = ArraySize(guardHandlerResult.olds);
|
|
if (oldsCount > 0)
|
|
{
|
|
//
|
|
for (int i = 0; i < oldsCount; i++)
|
|
{
|
|
//
|
|
XSignal iSignal = guardHandlerResult.olds[i];
|
|
|
|
//
|
|
XUSCHF5OnGuard(
|
|
iSignal,
|
|
X_GUARDED_OLD,
|
|
guardMessage);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Signal Protection ...
|
|
XSignal protectSupports[];
|
|
bool isSupported = xUSCHF5Guard.ProtectSignals(
|
|
protectSupports,
|
|
xUSCHF5Trader);
|
|
if (isSupported)
|
|
{
|
|
//
|
|
LogMessage("Guard do Support Trdae ...");
|
|
}
|
|
|
|
//
|
|
// Handling Signals ...
|
|
XTraderHandlerResult signalHandlerResult;
|
|
xUSCHF5Trader.HandleSignals(
|
|
signalHandlerResult,
|
|
false // Ignore Risk Free Trdaes
|
|
);
|
|
|
|
//
|
|
// Handle Sl Reports ...
|
|
int handledSLsCount = ArraySize(signalHandlerResult.sl);
|
|
if (handledSLsCount > 0)
|
|
{
|
|
//
|
|
for (int i = 0; i < handledSLsCount; i++)
|
|
{
|
|
//
|
|
XSignal iSignal = signalHandlerResult.sl[i];
|
|
XUSCHF5OnSL(iSignal);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Handle TP Reports ...
|
|
int handledTPsCount = ArraySize(signalHandlerResult.tp);
|
|
if (handledTPsCount > 0)
|
|
{
|
|
//
|
|
for (int i = 0; i < handledTPsCount; i++)
|
|
{
|
|
//
|
|
XSignal iSignal = signalHandlerResult.tp[i];
|
|
XUSCHF5OnTP(iSignal);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Handle RFs as TP Reports ...
|
|
int handledRFsCount = ArraySize(signalHandlerResult.rf);
|
|
if (handledRFsCount > 0)
|
|
{
|
|
//
|
|
for (int i = 0; i < handledRFsCount; i++)
|
|
{
|
|
//
|
|
XSignal iSignal = signalHandlerResult.rf[i];
|
|
XUSCHF5OnRF(iSignal);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Handle Trades when OnTrade Event Hnadler Calls ...
|
|
void XUSCHF5SignalProviderHandleTrade()
|
|
{
|
|
//
|
|
// Check Provider Enabled ...
|
|
if (!xUSCHF5MEnableProvider)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Handle OnTrade Event ...
|
|
XOnTradeHandlerResult result = {};
|
|
xUSCHF5Trader.HandleOnTradeEvent(
|
|
result);
|
|
|
|
//
|
|
// Detected TP or SL ...
|
|
if (result.hasNewDeal)
|
|
{
|
|
//
|
|
XDeal last = xUSCHF5Trader.GetLastDeal();
|
|
|
|
//
|
|
if (last.reason == DEAL_REASON_SL)
|
|
{
|
|
xUSCHF5Reporter.AddTradeSLInReports();
|
|
}
|
|
else if (last.reason == DEAL_REASON_TP)
|
|
{
|
|
xUSCHF5Reporter.AddTradeTPInReports();
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Handle Open Trades ...
|
|
void XUSCHF5HandleOpenTrades()
|
|
{
|
|
//
|
|
// Check Can Trade ...
|
|
bool canTrade = xUSCHF5MAllowLongTrades || xUSCHF5MAllowShortTrades;
|
|
if (!canTrade)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Check Max Open Trades ...
|
|
int openSignals = xUSCHF5Trader.Count();
|
|
bool canOpenPositions = openSignals < xUSCHF5MaxAllowedTrades;
|
|
if (!canOpenPositions)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Check Signals Exists ...
|
|
XProvidedSignal longSignalInfo;
|
|
XProvidedSignal shortSignalInfo;
|
|
bool hasLongSignal = XUSCHF5CanOpenLongTrade(longSignalInfo);
|
|
bool hasShortSignal = XUSCHF5CanOpenShortTrade(shortSignalInfo);
|
|
if (!hasLongSignal && !hasShortSignal)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Update Reports ...
|
|
XUSCHF5UpdateReports();
|
|
|
|
//
|
|
xUSCHF5WaitUntilNextCandle = true;
|
|
|
|
//
|
|
// Open Long Trades ...
|
|
if (
|
|
//
|
|
hasLongSignal &&
|
|
xUSCHF5MAllowLongTrades)
|
|
{
|
|
//
|
|
bool isOpened = XUSCHF5OpenLongPosition(longSignalInfo);
|
|
}
|
|
|
|
//
|
|
// Open Short Trades ...
|
|
if (
|
|
//
|
|
hasShortSignal &&
|
|
xUSCHF5MAllowShortTrades)
|
|
{
|
|
//
|
|
bool isOpened = XUSCHF5OpenShortPosition(shortSignalInfo);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Handle Close Trades ...
|
|
void XUSCHF5HandleCloseTrades()
|
|
{
|
|
//
|
|
// Force Close Long Trades ...
|
|
bool isClosedLongTrades = false;
|
|
bool canCloseLongTrades = XUSCHF5CanCloseLongTrade();
|
|
if (xUSCHF5MAllowLongTrades && canCloseLongTrades)
|
|
{
|
|
//
|
|
ENUM_X_SIGNAL_TYPE type = X_SIGNAL_LONG;
|
|
|
|
//
|
|
XSignal closed[];
|
|
xUSCHF5Trader.CloseSignals(
|
|
closed,
|
|
type);
|
|
|
|
//
|
|
int closedTradesCount = ArraySize(closed);
|
|
isClosedLongTrades = closedTradesCount > 0;
|
|
if (isClosedLongTrades)
|
|
{
|
|
//
|
|
for (int i = 0; i < closedTradesCount; i++)
|
|
{
|
|
//
|
|
XSignal iSignal = closed[i];
|
|
XUSCHF5OnFC(iSignal);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Force Close Short Trades ...
|
|
bool isClosedShortTrades = false;
|
|
bool canCloseShortTrades = XUSCHF5CanCloseShortTrade();
|
|
if (xUSCHF5MAllowShortTrades && canCloseShortTrades)
|
|
{
|
|
//
|
|
ENUM_X_SIGNAL_TYPE type = X_SIGNAL_SHORT;
|
|
|
|
//
|
|
XSignal closed[];
|
|
xUSCHF5Trader.CloseSignals(
|
|
closed,
|
|
type);
|
|
|
|
//
|
|
int closedTradesCount = ArraySize(closed);
|
|
isClosedShortTrades = closedTradesCount > 0;
|
|
if (isClosedShortTrades)
|
|
{
|
|
//
|
|
for (int i = 0; i < closedTradesCount; i++)
|
|
{
|
|
//
|
|
XSignal iSignal = closed[i];
|
|
XUSCHF5OnFC(iSignal);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Open Long Position ...
|
|
bool XUSCHF5OpenLongPosition(
|
|
XProvidedSignal &info // Retrieve Signal Additional Info on this Object
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Calculate Required Data for Position ...
|
|
double entry = GetEntry(_Symbol, X_SIGNAL_LONG);
|
|
double sl = info.sl > 0 ? info.sl : 0;
|
|
// entry - (200 * _Point);
|
|
// info.sl > 0 ? info.sl : 0;
|
|
double tp = info.tp > 0 ? info.tp : entry + xUSCHF5MinReward;
|
|
double riskFreeRate = xUSCHF5RiskFreeRate;
|
|
double riskFreeStep = xUSCHF5RiskFreeStepInPips;
|
|
double volume = XUSCHF5CalculateVolume(ArraySize(info.signallers));
|
|
|
|
//
|
|
XSignal signal = {};
|
|
signal = xUSCHF5Trader.GenerateSignal(
|
|
X_SIGNAL_LONG,
|
|
tp,
|
|
sl,
|
|
volume,
|
|
riskFreeStep,
|
|
riskFreeRate);
|
|
bool isValidSignal = IsValid(
|
|
signal,
|
|
xUSCHF5MagicNumber);
|
|
if (!isValidSignal)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int signalsCount = xUSCHF5Trader.Count();
|
|
bool isCross = signalsCount >= 1;
|
|
if (isCross)
|
|
{
|
|
//
|
|
// Handle Cross Signals ...
|
|
XUSCHF5HnadleCrossSignal(signal);
|
|
}
|
|
|
|
//
|
|
// Retrieve Can Execute Signal or not ...
|
|
bool canExecuteSignal =
|
|
!isCross
|
|
//
|
|
||
|
|
//
|
|
(
|
|
//
|
|
isCross &&
|
|
xUSCHF5CrossSignalsMethod != X_CROSS_SIGNAL_DO_NOTHING
|
|
//
|
|
);
|
|
if (!canExecuteSignal)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Execute Signal ...
|
|
ENUM_EXECUTION_SIGNAL_RESULT executionResult = xUSCHF5Trader.ExecuteSignal(
|
|
signal,
|
|
false, // Ignore Number of Trades ...
|
|
true // Check Account Conditions ...
|
|
);
|
|
result = executionResult == X_TRADER_SUCCEED_EXECUTION;
|
|
if (result)
|
|
{
|
|
//
|
|
// Update Reports ...
|
|
string providers[];
|
|
ArrayCopy(
|
|
providers,
|
|
info.signallers
|
|
);
|
|
|
|
//
|
|
XSignal tSignal = xUSCHF5Trader.GetSignal(signal.ticket);
|
|
|
|
//
|
|
XUSCHF5OnSignal(
|
|
tSignal,
|
|
providers);
|
|
}
|
|
else
|
|
{
|
|
XUSCHF5IssueSignalExecutionError(executionResult);
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Open Short Position ...
|
|
bool XUSCHF5OpenShortPosition(
|
|
XProvidedSignal &info // Retrieve Signal Additional Info on this Object
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
|
|
//
|
|
// Calculate Required Data for Position ...
|
|
double entry = GetEntry(_Symbol, X_SIGNAL_SHORT);
|
|
double sl = info.sl > 0 ? info.sl : 0;
|
|
// entry + (200 * _Point);
|
|
// info.sl > 0 ? info.sl : 0;
|
|
double tp = info.tp > 0 ? info.tp : entry - xUSCHF5MinReward;
|
|
double riskFreeRate = xUSCHF5RiskFreeRate;
|
|
double riskFreeStep = xUSCHF5RiskFreeStepInPips;
|
|
double volume = XUSCHF5CalculateVolume(ArraySize(info.signallers));
|
|
|
|
//
|
|
XSignal signal = {};
|
|
signal = xUSCHF5Trader.GenerateSignal(
|
|
X_SIGNAL_SHORT,
|
|
tp,
|
|
sl,
|
|
volume,
|
|
riskFreeStep,
|
|
riskFreeRate);
|
|
bool isValidSignal = IsValid(
|
|
signal,
|
|
xUSCHF5MagicNumber);
|
|
if (!isValidSignal)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
int signalsCount = xUSCHF5Trader.Count();
|
|
bool isCross = signalsCount >= 1;
|
|
if (isCross)
|
|
{
|
|
//
|
|
// Handle Cross Signals ...
|
|
XUSCHF5HnadleCrossSignal(signal);
|
|
}
|
|
|
|
//
|
|
// Retrieve Can Execute Signal or not ...
|
|
bool canExecuteSignal =
|
|
!isCross
|
|
//
|
|
||
|
|
//
|
|
(
|
|
//
|
|
isCross &&
|
|
xUSCHF5CrossSignalsMethod != X_CROSS_SIGNAL_DO_NOTHING
|
|
//
|
|
);
|
|
if (!canExecuteSignal)
|
|
{
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Execute Signal ...
|
|
ENUM_EXECUTION_SIGNAL_RESULT executionResult = xUSCHF5Trader.ExecuteSignal(
|
|
signal,
|
|
false, // Ignore Number of Trades ...
|
|
true // Check Account Conditions ...
|
|
);
|
|
result = executionResult == X_TRADER_SUCCEED_EXECUTION;
|
|
if (result)
|
|
{
|
|
string providers[];
|
|
ArrayCopy(
|
|
providers,
|
|
info.signallers
|
|
);
|
|
|
|
//
|
|
XSignal tSignal = xUSCHF5Trader.GetSignal(signal.ticket);
|
|
|
|
//
|
|
XUSCHF5OnSignal(
|
|
tSignal,
|
|
providers);
|
|
}
|
|
else
|
|
{
|
|
XUSCHF5IssueSignalExecutionError(executionResult);
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Apply Cross Signal Actions ...
|
|
void XUSCHF5HnadleCrossSignal(
|
|
XSignal &signal // Specified Signal ...
|
|
)
|
|
{
|
|
//
|
|
// Check Cross Signal Handling Enabled ...
|
|
if (xUSCHF5CrossSignalsMethod == X_CROSS_SIGNAL_DO_NOTHING)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// First We have to Change Cross Signals Comment ...
|
|
string comment = xUSCHF5Trader.GenerateSignalComment(
|
|
signal,
|
|
true);
|
|
|
|
//
|
|
signal.comment = comment;
|
|
|
|
//
|
|
// If Every thing is Regular, prevent any changes here ...
|
|
if (xUSCHF5CrossSignalsMethod == X_CROSS_SIGNAL_REGULAR)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Retrieve Max in Drawdown Signal ...
|
|
XSignal maxInDDSignal = xUSCHF5Trader.GetMaxInDrawdownSignal();
|
|
|
|
//
|
|
// Validate Signal ...
|
|
bool isValidSignal =
|
|
maxInDDSignal.ticket > 0 &&
|
|
maxInDDSignal.symbol == signal.symbol &&
|
|
IsValid(maxInDDSignal, xUSCHF5MagicNumber);
|
|
if (!isValidSignal)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
double volume = signal.volume;
|
|
bool isDirectional = maxInDDSignal.type == signal.type;
|
|
|
|
//
|
|
// Prevent any changes on Regular Conditions ...
|
|
bool isRegular =
|
|
isDirectional
|
|
? (
|
|
//
|
|
xUSCHF5CrossSignalsMethod == X_CROSS_SIGNAL_DIRECTION_REGULAR ||
|
|
xUSCHF5CrossSignalsMethod == X_CROSS_SIGNAL_DIRECTION_REGULAR_INDIRECTION_IMPORTANT
|
|
//
|
|
)
|
|
: (
|
|
//
|
|
xUSCHF5CrossSignalsMethod == X_CROSS_SIGNAL_INDIRECTION_REGULAR ||
|
|
xUSCHF5CrossSignalsMethod == X_CROSS_SIGNAL_DIRECTION_IMPORTANT_INDIRECTION_REGULAR
|
|
//
|
|
);
|
|
if (isRegular)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Important Act needs to Multiply volume by 2 ...
|
|
volume *= 2;
|
|
|
|
//
|
|
// Set Volume of signal ...
|
|
signal.volume = volume;
|
|
}
|
|
|
|
//
|
|
// Calculate Usefull data ...
|
|
void XUSCHF5HandleCalculateDrawDownUp()
|
|
{
|
|
//
|
|
XSignal signals[];
|
|
xUSCHF5Trader.GetSignals(signals);
|
|
int signalsCount = ArraySize(signals);
|
|
if (signalsCount <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
double profit = 0;
|
|
double volume = 0;
|
|
XCollector collector = {};
|
|
double maxAllowedVolume = xUSCHF5VolumeManager.GetMaxAllowedVolume();
|
|
for (int i = 0; i < signalsCount; i++)
|
|
{
|
|
//
|
|
XSignal iSignal = signals[i];
|
|
|
|
//
|
|
profit += iSignal.profit;
|
|
|
|
//
|
|
volume =
|
|
volume == 0 ||
|
|
volume < iSignal.volume
|
|
? iSignal.volume
|
|
: volume;
|
|
}
|
|
|
|
//
|
|
if (profit < 0)
|
|
{
|
|
//
|
|
xUSCHF5MaxDrawDown =
|
|
xUSCHF5MaxDrawDown == 0 ||
|
|
xUSCHF5MaxDrawDown > MathAbs(profit)
|
|
? MathAbs(profit)
|
|
: xUSCHF5MaxDrawDown;
|
|
|
|
//
|
|
// Update Buffers ...
|
|
datetime time = iTime(_Symbol, _Period, 0);
|
|
|
|
//
|
|
// Calculate Max Allowed Drawdown ...
|
|
//
|
|
collector.time = time;
|
|
collector.volume = volume;
|
|
collector.maxDrawDown = xUSCHF5MaxDrawDown;
|
|
collector.maxAllowedVolume = maxAllowedVolume;
|
|
collector.minBalanceForOpenTrade = xUSCHF5Trader.GetMinBalanceForOpenTrades();
|
|
}
|
|
else
|
|
{
|
|
//
|
|
xUSCHF5MaxDrawUp =
|
|
xUSCHF5MaxDrawUp == 0 ||
|
|
xUSCHF5MaxDrawUp < profit
|
|
? profit
|
|
: xUSCHF5MaxDrawUp;
|
|
}
|
|
|
|
//
|
|
// Update Collector ...
|
|
xUSCHF5Collector.Add(collector);
|
|
|
|
//
|
|
// Update Reports ...
|
|
xUSCHF5Reporter.UpdateMaxDrawUpInReports(xUSCHF5MaxDrawUp);
|
|
xUSCHF5Reporter.UpdateMaxDrawDownInReports(xUSCHF5MaxDrawDown);
|
|
xUSCHF5Reporter.UpdateMaxSameTimeTradesInReports(signalsCount);
|
|
}
|
|
|
|
//
|
|
// START Event Handlers ...
|
|
//
|
|
|
|
//
|
|
// Runs When a Signal Successfully Executed ...
|
|
void XUSCHF5OnSignal(
|
|
XSignal &signal, // Specified Signal
|
|
string &providers[] // Signal Providers
|
|
)
|
|
{
|
|
//
|
|
// Issue Propper Alert ...
|
|
XUSCHF5IssueSignalExecutionAlert(
|
|
signal,
|
|
providers);
|
|
|
|
//
|
|
// Add Signal To Supports on Guard ...
|
|
xUSCHF5Guard.AddSupport(signal);
|
|
|
|
//
|
|
// Update Reports ...
|
|
xUSCHF5Reporter.AddSignalToReports(
|
|
signal,
|
|
providers);
|
|
}
|
|
|
|
//
|
|
// Runs when a Position Got Take Profit ...
|
|
void XUSCHF5OnTP(
|
|
XSignal &signal // Specified Signal
|
|
)
|
|
{
|
|
//
|
|
// Issue Propper Alert ...
|
|
XUSCHF5IssueTPAlert(signal);
|
|
|
|
//
|
|
// Remove Signal From Guard Protector ...
|
|
xUSCHF5Guard.Remove(signal.ticket);
|
|
xUSCHF5Guard.RemoveSupport(signal.ticket);
|
|
|
|
//
|
|
// Update Reports ...
|
|
xUSCHF5Reporter.AddTradeTPInReports();
|
|
XUSCHF5UpdateReports();
|
|
}
|
|
|
|
//
|
|
// Runs when a Position Got Stop Loss ...
|
|
void XUSCHF5OnSL(
|
|
XSignal &signal // Specified Signal
|
|
)
|
|
{
|
|
//
|
|
// Issue Propper Alert ...
|
|
XUSCHF5IssueSLAlert(signal);
|
|
|
|
//
|
|
// Remove Signal From Guard Protector ...
|
|
xUSCHF5Guard.Remove(signal.ticket);
|
|
xUSCHF5Guard.RemoveSupport(signal.ticket);
|
|
|
|
//
|
|
// Update Reports ...
|
|
xUSCHF5Reporter.AddTradeSLInReports();
|
|
XUSCHF5UpdateReports();
|
|
}
|
|
|
|
//
|
|
// Runs when a Position Risk Free ...
|
|
void XUSCHF5OnRF(
|
|
XSignal &signal // Specified Signal
|
|
)
|
|
{
|
|
//
|
|
// Issue Propper Alert ...
|
|
XUSCHF5IssueRFAlert(signal);
|
|
|
|
//
|
|
// Remove Signal From Guard Protector ...
|
|
// since RiskFree Signals has SL ...
|
|
xUSCHF5Guard.Remove(signal.ticket);
|
|
xUSCHF5Guard.RemoveSupport(signal.ticket);
|
|
|
|
//
|
|
// Update Reports ...
|
|
xUSCHF5Reporter.AddTradeSLInReports();
|
|
XUSCHF5UpdateReports();
|
|
}
|
|
|
|
//
|
|
// Runs when a Position Force Closed ...
|
|
void XUSCHF5OnFC(
|
|
XSignal &signal // Specified Signal
|
|
)
|
|
{
|
|
//
|
|
// Issue Propper Alert ...
|
|
XUSCHF5IssueFCAlert(signal);
|
|
|
|
//
|
|
// Remove Signal From Guard Protector ...
|
|
xUSCHF5Guard.Remove(signal.ticket);
|
|
xUSCHF5Guard.RemoveSupport(signal.ticket);
|
|
|
|
//
|
|
// Update Reports ...
|
|
xUSCHF5Reporter.AddTradeSLInReports();
|
|
XUSCHF5UpdateReports();
|
|
}
|
|
|
|
//
|
|
// Runs when a Position Guarded ...
|
|
void XUSCHF5OnGuard(
|
|
XSignal &signal, // Specified Signal
|
|
ENUM_X_GUARD_REASONS reason, // Reason of Guard Applied
|
|
string message, // Guard Returned Message
|
|
bool isStopOut = false // Specified StopOut Fired or not
|
|
)
|
|
{
|
|
//
|
|
// Chekc StopOut ...
|
|
if (isStopOut)
|
|
{
|
|
//
|
|
LogMessage(message);
|
|
|
|
//
|
|
xUSCHF5MEnableProvider = false;
|
|
}
|
|
|
|
//
|
|
// Issue Propper Alert ...
|
|
XUSCHF5IssueGuardAlert(signal, reason, isStopOut);
|
|
|
|
//
|
|
// Update Reports ...
|
|
xUSCHF5Reporter.AddTradeSLInReports();
|
|
XUSCHF5UpdateReports();
|
|
}
|
|
|
|
//
|
|
// END Event Handlers ...
|
|
//
|
|
|
|
//
|
|
// END Provided Functions ...
|
|
//
|
|
|
|
//
|
|
// START Private Functions ...
|
|
//
|
|
|
|
//
|
|
// START Volume Baseed Functions ...
|
|
//
|
|
|
|
//
|
|
// Calculating Volume for Tradings ...
|
|
double XUSCHF5CalculateVolume(
|
|
double forceMultiplier = 0 // some times we get more than one signal at the same time, here we increase volume using this ...
|
|
)
|
|
{
|
|
//
|
|
// Check Open Trades ...
|
|
int openSignals = xUSCHF5Trader.Count();
|
|
|
|
//
|
|
double result = xUSCHF5VolumeManager.CalculateVolume(
|
|
openSignals,
|
|
_Symbol);
|
|
|
|
//
|
|
result *= forceMultiplier;
|
|
|
|
//
|
|
// Normalize Volume ...
|
|
result = NormalizeVolume(result, _Symbol, 2);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// END Volume Baseed Functions ...
|
|
//
|
|
|
|
//
|
|
// START Report/Collect and Guard Functions ...
|
|
//
|
|
|
|
//
|
|
// Update Report Info ...
|
|
void XUSCHF5UpdateReports()
|
|
{
|
|
//
|
|
double staticVolume = xUSCHF5VolumeManager.GetStaticVolume();
|
|
string staticVolumeCalculationMethod = EnumToString(xUSCHF5StaticVolumeMethod);
|
|
double maxAllowedVolume = xUSCHF5VolumeManager.GetMaxAllowedVolume();
|
|
double volumeIncreaseMultiplier = xUSCHF5VolumeManager.GetVolumeMultiplier();
|
|
double balanceGowingToApplyMultiplier = xUSCHF5VolumeManager.GetIncreaseMultiplierBalance();
|
|
|
|
double balanceGrowingToIncreaseMaxAllowedVolume = xUSCHF5VolumeManager.GetIncreaseMaxAllowedVolumeBalance();
|
|
|
|
//
|
|
// Update Reports Volume Info ...
|
|
xUSCHF5Reporter.UpdateReportsVolumeInfo(
|
|
staticVolume,
|
|
staticVolumeCalculationMethod,
|
|
maxAllowedVolume,
|
|
volumeIncreaseMultiplier,
|
|
balanceGowingToApplyMultiplier,
|
|
balanceGrowingToIncreaseMaxAllowedVolume);
|
|
|
|
//
|
|
// Calculate Max Allowed Drawdown ...
|
|
double minBalanceForTradeBasedOnBalance = xUSCHF5Trader.GetMinBalanceForOpenTrades();
|
|
xUSCHF5Reporter.UpdateMinBalanceForOpenTradesInReports(minBalanceForTradeBasedOnBalance);
|
|
}
|
|
|
|
//
|
|
// Reset XUSCHF5 Info Buffers ...
|
|
void XUSCHF5ResetCollectors()
|
|
{
|
|
//
|
|
// Reset Calculations Buffers and Variables ...
|
|
xUSCHF5MaxDrawUp = 0;
|
|
xUSCHF5MaxDrawDown = 0;
|
|
|
|
//
|
|
xUSCHF5Trader.Reset();
|
|
xUSCHF5Reporter.Reset();
|
|
xUSCHF5Collector.Reset();
|
|
xUSCHF5VolumeManager.ResetForceVolumeMultiplier();
|
|
}
|
|
|
|
//
|
|
// END Report/Collect and Guard Functions ...
|
|
//
|
|
|
|
//
|
|
// START Alert Functions ...
|
|
//
|
|
|
|
//
|
|
// Send Alert ...
|
|
void XUSCHF5IssueAlert(string message)
|
|
{
|
|
//
|
|
// Validate Args ...
|
|
if (StringLen(message) <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
if (xUSCHF5EnableAlerts)
|
|
{
|
|
SendAlert(message);
|
|
}
|
|
else
|
|
{
|
|
LogMessage(message);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Send Take Profit Alert on Specific Signal ...
|
|
void XUSCHF5IssueTPAlert(
|
|
XSignal &signal // Specified Signal
|
|
)
|
|
{
|
|
//
|
|
string message = "";
|
|
|
|
//
|
|
message = xUSCHF5Trader.GenerateSignalTPComment(signal);
|
|
|
|
//
|
|
XUSCHF5IssueAlert(message);
|
|
}
|
|
|
|
//
|
|
// Send Stop Loss Alert on Specific Signal ...
|
|
void XUSCHF5IssueSLAlert(
|
|
XSignal &signal // Specified Signal
|
|
)
|
|
{
|
|
//
|
|
string message = "";
|
|
|
|
//
|
|
message = xUSCHF5Trader.GenerateSignalSLComment(signal);
|
|
|
|
//
|
|
XUSCHF5IssueAlert(message);
|
|
}
|
|
|
|
//
|
|
// Send Force Close Alert on Specific Signal ...
|
|
void XUSCHF5IssueFCAlert(
|
|
XSignal &signal // Specified Signal
|
|
)
|
|
{
|
|
//
|
|
string message = "";
|
|
|
|
//
|
|
message = xUSCHF5Trader.GenerateSignalForceCloseComment(signal);
|
|
|
|
//
|
|
XUSCHF5IssueAlert(message);
|
|
}
|
|
|
|
//
|
|
// Send Risk Free Alert on Specific Signal ...
|
|
void XUSCHF5IssueRFAlert(
|
|
XSignal &signal // Specified Signal
|
|
)
|
|
{
|
|
//
|
|
string message = "";
|
|
|
|
//
|
|
message = xUSCHF5Trader.GenerateSignalRFComment(signal, 0);
|
|
|
|
//
|
|
XUSCHF5IssueAlert(message);
|
|
}
|
|
|
|
//
|
|
// Send Guard Alert on Specific Signal ...
|
|
void XUSCHF5IssueGuardAlert(
|
|
XSignal &signal, // Specified Signal
|
|
ENUM_X_GUARD_REASONS reason, // Specified Guard Reason
|
|
bool isStopOut = false // Specified StopOut Fired or not
|
|
)
|
|
{
|
|
//
|
|
string message = "";
|
|
|
|
//
|
|
message = xUSCHF5Guard.GenerateGuardedSignalComment(
|
|
signal,
|
|
reason);
|
|
|
|
//
|
|
XUSCHF5IssueAlert(message);
|
|
}
|
|
|
|
//
|
|
// Send Initialization Succeed Alert ...
|
|
void XUSCHF5IssueInitializationSucceedAlert()
|
|
{
|
|
//
|
|
string message = "Initializion of (" + XUSCHF5ProviderName + " Provider" + " _ " + _Symbol + " _ " + EnumToString(_Period) + ") Succeeded ...";
|
|
XUSCHF5IssueAlert(message);
|
|
}
|
|
|
|
//
|
|
// Send De Initialization Succeed Alert ...
|
|
void XUSCHF5IssueDeinitializationSucceedAlert()
|
|
{
|
|
//
|
|
string message = "De Initializion of (" + XUSCHF5ProviderName + " Provider" + ") Succeeded ...";
|
|
XUSCHF5IssueAlert(message);
|
|
}
|
|
|
|
//
|
|
// Send Signal Successfully Execution Alert ...
|
|
void XUSCHF5IssueSignalExecutionAlert(
|
|
XSignal &signal, // Specified Signal
|
|
string &providers[] // Signal Providers
|
|
)
|
|
{
|
|
//
|
|
string message = xUSCHF5Trader.ToString(signal);
|
|
|
|
//
|
|
string providersMsg = ToString(providers);
|
|
if (StringLen(providersMsg) > 0)
|
|
{
|
|
message += ", Providers: " + providersMsg;
|
|
}
|
|
|
|
//
|
|
XUSCHF5IssueAlert(message);
|
|
}
|
|
|
|
//
|
|
// Send Signal Execution Alert ...
|
|
void XUSCHF5IssueSignalExecutionError(int error)
|
|
{
|
|
//
|
|
string message = GetSignalExecutionError(error);
|
|
if (StringLen(message) == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
XUSCHF5IssueAlert(message);
|
|
}
|
|
|
|
//
|
|
// END Alert Functions ...
|
|
//
|
|
|
|
//
|
|
// END Private Functions ...
|
|
//
|