526 lines
18 KiB
MQL5
526 lines
18 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| PlaceOrders.mqh |
|
|
//| Copyright 2024, MetaQuotes Ltd. |
|
|
//| https://www.mql5.com |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Copyright 2024, MetaQuotes Ltd."
|
|
#property link "https://www.mql5.com"
|
|
#property version "1.00"
|
|
|
|
#include <Trade\PositionInfo.mqh>
|
|
#include <Trade\Trade.mqh>
|
|
#include "..\\Includes\\CalculateBreakeven.mqh"
|
|
|
|
#include"..\\Includes\\BreakEvenResult.mqh"
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
class OrderManager
|
|
{
|
|
private:
|
|
|
|
public:
|
|
|
|
int recoveryOrdersSell;
|
|
int recoveryOrdersBuy;
|
|
|
|
CPositionInfo m_position;
|
|
CTrade m_trade;
|
|
OrderManager(int iM1,int iM2);
|
|
~OrderManager();
|
|
void CloseTrades(long MagicNumber,bool buy,bool sell,double profit=0,double parttoclose=0);
|
|
int TrailTrades(long MagicNumber,bool buy,bool sell,double profit,double parttoclose, double iTrailingStart, double iTrailStep,double iTrailingStop);
|
|
int HedgePositions(long MagicNumber);
|
|
void FirstOrder(long Mymagic,double Volume);
|
|
bool PlaceOrder(ENUM_POSITION_TYPE TypeOrder, double Volume, int magic, string Comment);
|
|
double RelativeProfitOnMagic(long MyMagic,double lots,double min,double lotstobreakdown,datetime hedge,bool proces,bool forcerecover);
|
|
double RelativeProfitOnMagic2(long MyMagic,double lots,double min,double lotstobreakdown,datetime hedge,bool proces,bool forcerecover);
|
|
double TrallB ;
|
|
double LastOrderProfit();
|
|
double RetreiverLastOrder();
|
|
int GetHighestMagicNumberAll();
|
|
long GetDirectionOfTheLastProfitTrade(int mtype, string symbol, int magicx);
|
|
void CloseAll();
|
|
int PositionTotalOnThis();
|
|
double ProfitTotalOnThis();
|
|
int GetHighestMagicNumber();
|
|
bool ToMuchMagic();
|
|
int GetHighestMagic();
|
|
int iMax1;
|
|
int iMax2;
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
OrderManager::OrderManager(int iM1,int iM2)
|
|
{
|
|
m_trade.SetTypeFillingBySymbol(m_position.Symbol());
|
|
TrallB = 0;
|
|
recoveryOrdersSell=0;
|
|
recoveryOrdersBuy=0;
|
|
iMax1=iM1;
|
|
iMax2=iM2;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
OrderManager::~OrderManager()
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void OrderManager::FirstOrder(long Mymagic,double Volume)
|
|
{
|
|
MqlRates rates[];
|
|
CopyRates(Symbol(),PERIOD_M15,0,2,rates);
|
|
|
|
MqlTick tick;
|
|
if(!SymbolInfoTick(Symbol(),tick))
|
|
Print("SymbolInfoTick() failed, error = ",GetLastError());
|
|
|
|
|
|
if(GetDirectionOfTheLastProfitTrade(-99, _Symbol, -1)== DEAL_TYPE_BUY)
|
|
{
|
|
if(!PlaceOrder(POSITION_TYPE_SELL,Volume,Mymagic,NULL))
|
|
printf("error");
|
|
|
|
}
|
|
else
|
|
{
|
|
if(!PlaceOrder(POSITION_TYPE_BUY,Volume,Mymagic,NULL))
|
|
printf("error");
|
|
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
long OrderManager::GetDirectionOfTheLastProfitTrade(int mtype, string symbol, int magicx)
|
|
{
|
|
|
|
|
|
|
|
ulong ticket=0;
|
|
int cta=0;
|
|
HistorySelect(0,TimeCurrent());
|
|
for(int i=HistoryOrdersTotal(); i>=0; i--)
|
|
{
|
|
if((ticket=HistoryDealGetTicket(i))>0)
|
|
{
|
|
if(HistoryDealGetInteger(ticket,DEAL_ENTRY) == DEAL_ENTRY_OUT)
|
|
{
|
|
string s= HistoryDealGetString(ticket,DEAL_SYMBOL);
|
|
if(s==symbol || symbol=="ALL")
|
|
{
|
|
long type =HistoryDealGetInteger(ticket,DEAL_TYPE);
|
|
if(type==mtype || mtype==-99)
|
|
{
|
|
long m =HistoryDealGetInteger(ticket, DEAL_MAGIC);
|
|
if(m==magicx || magicx==-1)
|
|
{
|
|
double profit=HistoryDealGetDouble(ticket, DEAL_PROFIT);
|
|
if(profit>0)
|
|
return type;
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
return 0;
|
|
|
|
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
double OrderManager::LastOrderProfit()
|
|
{
|
|
int totalPositions = PositionsTotal();
|
|
double lastPositionProfit = 0.0;
|
|
|
|
for (int i = totalPositions - 1; i >= 0; i--) {
|
|
ulong ticket = PositionGetTicket(i);
|
|
if (PositionSelectByTicket(ticket)) {
|
|
if (PositionGetString(POSITION_SYMBOL) == _Symbol) {
|
|
lastPositionProfit = PositionGetDouble(POSITION_PROFIT);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return lastPositionProfit;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
int OrderManager::GetHighestMagicNumber()
|
|
{
|
|
int highest_magic = 1;
|
|
int total_positions = PositionsTotal();
|
|
CPositionInfo m_position;
|
|
for(int i = 0; i < total_positions; i++)
|
|
{
|
|
if(m_position.SelectByIndex(i))
|
|
{
|
|
if(m_position.Symbol()==_Symbol){
|
|
int magic_number = PositionGetInteger(POSITION_MAGIC);
|
|
if(magic_number > highest_magic)
|
|
highest_magic = magic_number;}
|
|
}
|
|
}
|
|
|
|
return highest_magic;
|
|
}
|
|
int OrderManager::GetHighestMagicNumberAll()
|
|
{
|
|
int highest_magic = 1;
|
|
int total_positions = PositionsTotal();
|
|
CPositionInfo m_position;
|
|
for(int i = 0; i < total_positions; i++)
|
|
{
|
|
if(m_position.SelectByIndex(i))
|
|
{
|
|
|
|
int magic_number = PositionGetInteger(POSITION_MAGIC);
|
|
if(magic_number > highest_magic)
|
|
highest_magic = magic_number;
|
|
}
|
|
}
|
|
|
|
return highest_magic;
|
|
}
|
|
double OrderManager::RelativeProfitOnMagic(long MyMagic,double lots,double min,double lotstobreakdown,datetime hedge,bool proces,bool forcerecover)
|
|
{
|
|
MqlDateTime rightNow;
|
|
TimeCurrent(rightNow);
|
|
CalculateBreakeven breakEven;
|
|
m_trade.SetMarginMode();
|
|
BreakEvenInput breakEvenInput;
|
|
breakEvenInput.Buys=true;
|
|
breakEvenInput.Sells=true;
|
|
|
|
breakEvenInput.MagicNumber=MyMagic;
|
|
breakEvenInput.ProfitInMoney=0;
|
|
breakEvenInput.HedgeToBreakDownLots=lotstobreakdown;
|
|
BreakEvenResult breakevenResult=breakEven.GetBreakEven(breakEvenInput);
|
|
//
|
|
if((NormalizeDouble(breakevenResult.Net_Lots,2)==0) && proces && breakevenResult.Net_Trades>0 ||((breakevenResult.Net_Trades==0)))
|
|
{
|
|
|
|
//FirstOrder(MyMagic, lots);
|
|
// FirstOrder(MyMagic, lots);
|
|
// FirstOrder(MyMagic, lots);
|
|
// FirstOrder(MyMagic, lots);
|
|
recoveryOrdersBuy=0;
|
|
recoveryOrdersSell=0;
|
|
}
|
|
|
|
//&&(hedge+=0* PeriodSeconds(PERIOD_H1))<TimeCurrent()
|
|
double relativ= (breakevenResult.Net_Result*MathAbs(lots/(breakevenResult.Net_Lots==0?lots:breakevenResult.Net_Lots)));
|
|
if((LastOrderProfit()<min) && breakevenResult.Net_Lots>0 )
|
|
{
|
|
if(recoveryOrdersBuy<(MyMagic>1?iMax1:iMax2))
|
|
{
|
|
PlaceOrder(POSITION_TYPE_BUY,lots,MyMagic,MyMagic);
|
|
recoveryOrdersBuy=recoveryOrdersBuy+1;
|
|
recoveryOrdersSell=0;
|
|
}
|
|
}
|
|
if((LastOrderProfit()<min) && breakevenResult.Net_Lots<0 )
|
|
{
|
|
if(recoveryOrdersSell<(MyMagic>1?iMax1:iMax2)) // (MyMagic>1?2:3))
|
|
{
|
|
PlaceOrder(POSITION_TYPE_SELL,lots,MyMagic,MyMagic);
|
|
recoveryOrdersBuy=0;
|
|
recoveryOrdersSell=recoveryOrdersSell+1;
|
|
}
|
|
}
|
|
|
|
return breakevenResult.Net_Result;
|
|
}
|
|
|
|
double OrderManager::RelativeProfitOnMagic2(long MyMagic,double lots,double min,double lotstobreakdown,datetime hedge,bool proces,bool forcerecover)
|
|
|
|
{
|
|
MqlDateTime rightNow;
|
|
TimeCurrent(rightNow);
|
|
CalculateBreakeven breakEven;
|
|
m_trade.SetMarginMode();
|
|
BreakEvenInput breakEvenInput;
|
|
breakEvenInput.Buys=true;
|
|
breakEvenInput.Sells=true;
|
|
|
|
breakEvenInput.MagicNumber=MyMagic;
|
|
breakEvenInput.ProfitInMoney=0;
|
|
breakEvenInput.HedgeToBreakDownLots=lotstobreakdown;
|
|
BreakEvenResult breakevenResult=breakEven.GetBreakEven(breakEvenInput);
|
|
//
|
|
// if(((NormalizeDouble(breakevenResult.Net_Lots,2)==0)&&(hedge+=0* PeriodSeconds(PERIOD_H1))<TimeCurrent() && proces && breakevenResult.Net_Trades>0 && rightNow.hour>10)||forcerecover)
|
|
// FirstOrder(MyMagic, lots);
|
|
/*
|
|
double relativ= (breakevenResult.Net_Result*MathAbs(lots/(breakevenResult.Net_Lots==0?lots:breakevenResult.Net_Lots)));
|
|
if((LastOrderProfit()<min) && breakevenResult.Net_Lots>0 && proces){
|
|
if (recoveryOrdersBuy<4){
|
|
PlaceOrder(POSITION_TYPE_BUY,lots,MyMagic,NULL);
|
|
recoveryOrdersBuy=recoveryOrdersBuy+1;
|
|
recoveryOrdersSell=0;}
|
|
}
|
|
if((LastOrderProfit()<min) && breakevenResult.Net_Lots<0 && proces){
|
|
if (recoveryOrdersSell<4){
|
|
PlaceOrder(POSITION_TYPE_SELL,lots,MyMagic,NULL);
|
|
recoveryOrdersBuy=0;
|
|
recoveryOrdersSell=recoveryOrdersSell+1;
|
|
}}
|
|
*/
|
|
return breakevenResult.Net_Result;
|
|
}
|
|
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
bool OrderManager::PlaceOrder(ENUM_POSITION_TYPE TypeOrder, double Volume, int magic, string Comment)
|
|
{
|
|
m_trade.SetExpertMagicNumber(magic);
|
|
|
|
if(TypeOrder == POSITION_TYPE_BUY)
|
|
{
|
|
if(!m_trade.Buy(Volume,Symbol(),0,0,0,Comment))
|
|
return(false);
|
|
}
|
|
|
|
if(TypeOrder == POSITION_TYPE_SELL)
|
|
{
|
|
if(!m_trade.Sell(Volume,Symbol(),0,0,0,Comment))
|
|
return(false);
|
|
}
|
|
|
|
return(true);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
|
|
|
|
|
|
void OrderManager::CloseAll()
|
|
{
|
|
for(int i=PositionsTotal()-1; i>=0; i--) // returns the number of current positions
|
|
if(m_position.SelectByIndex(i))
|
|
{if (m_position.Symbol()==_Symbol)
|
|
m_trade.PositionClose(m_position.Ticket());
|
|
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
int OrderManager::PositionTotalOnThis()
|
|
{
|
|
int total=0;
|
|
for(int i=PositionsTotal()-1; i>=0; i--) // returns the number of current positions
|
|
if(m_position.SelectByIndex(i))
|
|
{
|
|
if(m_position.Symbol()==_Symbol)
|
|
total=total+1;
|
|
}
|
|
return total;
|
|
}
|
|
|
|
double OrderManager::ProfitTotalOnThis()
|
|
{
|
|
|
|
|
|
double profit = 0.0;
|
|
|
|
// Loop through all positions
|
|
for(int i = PositionsTotal() - 1; i >= 0; i--)
|
|
{
|
|
ulong ticket = PositionGetTicket(i);
|
|
if(PositionSelectByTicket(ticket))
|
|
{
|
|
if(PositionGetString(POSITION_SYMBOL) == _Symbol)
|
|
{
|
|
profit += PositionGetDouble(POSITION_PROFIT);
|
|
}
|
|
}
|
|
}
|
|
|
|
return profit;
|
|
}
|
|
|
|
bool OrderManager::ToMuchMagic()
|
|
{
|
|
MqlDateTime SDateTime;
|
|
TimeToStruct(TimeCurrent(),SDateTime);
|
|
|
|
SDateTime.hour=0;
|
|
SDateTime.min=0;
|
|
SDateTime.sec=0;
|
|
datetime from_date=StructToTime(SDateTime); // From date
|
|
|
|
SDateTime.hour=10;
|
|
SDateTime.min=59;
|
|
SDateTime.sec=59;
|
|
datetime to_date=StructToTime(SDateTime); // To date
|
|
to_date-=60*60*24;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
int OrderManager::GetHighestMagic()
|
|
{
|
|
int magic=1;
|
|
for(int i=PositionsTotal()-1; i>=0; i--) // returns the number of current positions
|
|
if(m_position.SelectByIndex(i))
|
|
{
|
|
if(m_position.Symbol()==_Symbol)
|
|
if (m_position.Magic()>magic)
|
|
magic=m_position.Magic();
|
|
|
|
}
|
|
return magic;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void OrderManager::CloseTrades(long MagicNumber,bool buy,bool sell,double profit=0,double parttoclose=0)
|
|
{
|
|
|
|
CalculateBreakeven breakEven;
|
|
m_trade.SetMarginMode();
|
|
BreakEvenInput breakEvenInput;
|
|
breakEvenInput.Buys=true;
|
|
breakEvenInput.Sells=true;
|
|
|
|
breakEvenInput.MagicNumber=MagicNumber;
|
|
breakEvenInput.ProfitInMoney=profit;
|
|
breakEvenInput.HedgeToBreakDownLots=parttoclose;
|
|
BreakEvenResult breakevenResult=breakEven.GetBreakEven(breakEvenInput);
|
|
if((breakevenResult.Net_Lots>0 && SymbolInfoDouble(_Symbol, SYMBOL_BID)>=breakevenResult.Average_Price) || (breakevenResult.Net_Lots<0 && SymbolInfoDouble(_Symbol, SYMBOL_ASK)<=breakevenResult.Average_Price)|| profit==0 || MagicNumber==0)
|
|
for(int i=breakevenResult.TicketsToClose.Total()-1; i>=0; i--) // returns the number of current positions
|
|
if(m_position.SelectByTicket(breakevenResult.TicketsToClose.At(i))) // selects the position by index for further access to its properties
|
|
{
|
|
if(breakevenResult.TicketsLotSizeToClose.At(i)==0)
|
|
printf("error zero volume");
|
|
m_trade.PositionClosePartial(m_position.Ticket(),breakevenResult.TicketsLotSizeToClose.At(i));
|
|
recoveryOrdersSell=0;
|
|
recoveryOrdersBuy=0;
|
|
|
|
}
|
|
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
int OrderManager::TrailTrades(long MagicNumber,bool buy,bool sell,double profit,double parttoclose, double iTrailingStart, double iTrailStep,double iTrailingStop)
|
|
{
|
|
|
|
CalculateBreakeven breakEven;
|
|
m_trade.SetMarginMode();
|
|
BreakEvenInput breakEvenInput;
|
|
breakEvenInput.Buys=true;
|
|
breakEvenInput.Sells=true;
|
|
int themagic=0;
|
|
breakEvenInput.MagicNumber=MagicNumber;
|
|
breakEvenInput.ProfitInMoney=profit;
|
|
breakEvenInput.HedgeToBreakDownLots=parttoclose;
|
|
BreakEvenResult breakevenResult=breakEven.GetBreakEven(breakEvenInput);
|
|
double p = breakevenResult.Net_Result;
|
|
if(breakevenResult.TicketsToClose.Total()==0)
|
|
TrallB=0;
|
|
double SL=breakevenResult.Net_Result-iTrailingStop;
|
|
|
|
if(breakevenResult.Net_Result>=iTrailingStart && (TrallB==0 || TrallB+iTrailStep<SL))
|
|
TrallB=SL;
|
|
if((breakevenResult.Net_Result<=TrallB) && (TrallB>0))
|
|
|
|
|
|
for(int i=breakevenResult.TicketsToClose.Total()-1; i>=0; i--)
|
|
if(m_position.SelectByTicket(breakevenResult.TicketsToClose.At(i)))
|
|
{
|
|
{
|
|
m_trade.PositionClosePartial(m_position.Ticket(),breakevenResult.TicketsLotSizeToClose.At(i));
|
|
recoveryOrdersSell=0;
|
|
recoveryOrdersBuy=0;
|
|
themagic==GetHighestMagic();
|
|
}
|
|
TrallB=0;
|
|
|
|
}
|
|
|
|
return themagic;
|
|
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
int OrderManager::HedgePositions(long MagicNumber)
|
|
{
|
|
CalculateBreakeven breakEven;
|
|
m_trade.SetMarginMode();
|
|
BreakEvenInput breakEvenInput;
|
|
breakEvenInput.Buys=true;
|
|
breakEvenInput.Sells=true;
|
|
BreakEvenResult breakevenResult=breakEven.GetBreakEven(breakEvenInput);
|
|
if(breakevenResult.Net_Lots<0)
|
|
{
|
|
PlaceOrder(POSITION_TYPE_BUY,NormalizeDouble(MathAbs(breakevenResult.Net_Lots),2),MagicNumber,"HEDGE");
|
|
return 1;
|
|
}
|
|
if(breakevenResult.Net_Lots>0)
|
|
{
|
|
PlaceOrder(POSITION_TYPE_SELL,NormalizeDouble(breakevenResult.Net_Lots,2),MagicNumber,"HEDGE");
|
|
return 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
double OrderManager::RetreiverLastOrder()
|
|
{
|
|
double TheMagic;
|
|
bool includeBuys=true;
|
|
bool includeSells=true;
|
|
double profitTarget=0;
|
|
long magic=0;
|
|
double hedgeToBreakDownLots=0;
|
|
CalculateBreakeven breakEven;
|
|
BreakEvenInput breakEvenInput;
|
|
|
|
breakEvenInput.Buys= includeBuys;
|
|
breakEvenInput.Sells= includeSells;
|
|
breakEvenInput.ProfitInMoney=profitTarget;
|
|
breakEvenInput.MagicNumber=magic;
|
|
breakEvenInput.HedgeToBreakDownLots=hedgeToBreakDownLots;
|
|
|
|
BreakEvenResult breakevenResult=breakEven.GetBreakEven(breakEvenInput);
|
|
TheMagic= GetHighestMagic();
|
|
if (PositionTotalOnThis()==0) return 1;
|
|
if (breakevenResult.Net_Lots<0)
|
|
{TheMagic=TheMagic*-1;}
|
|
if(breakevenResult.Net_Lots==0)
|
|
{
|
|
if (PositionTotalOnThis()>0)
|
|
{
|
|
TheMagic=TheMagic+1;
|
|
}
|
|
|
|
}
|
|
return TheMagic;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
|
|
//+------------------------------------------------------------------+
|