Multivariate close all

ÿþ//+------------------------------------------------------------------+

//|                                       Multivariate close all.mq5 |

//|                              Copyright © 2019, Vladimir Karputov |

//|                                           http://wmua.ru/slesar/ |

//+------------------------------------------------------------------+

#property copyright "Copyright © 2019, Vladimir Karputov"

#property link      "http://wmua.ru/slesar/"

#property version   "1.001"

/*

   barabashkakvn Trading engine 3.006

*/

#include <Trade\PositionInfo.mqh>

#include <Trade\Trade.mqh>

#include <Trade\SymbolInfo.mqh>  

#include <Trade\AccountInfo.mqh>

CPositionInfo  m_position;                   // trade position object

CTrade         m_trade;                      // trading object

CSymbolInfo    m_symbol;                     // symbol info object

CAccountInfo   m_account;                    // account info wrapper

//+------------------------------------------------------------------+

//| Enum Close By                                                    |

//+------------------------------------------------------------------+

enum ENUM_CLOSE_BY

  {

   Equity=0,               // Equity

   Points=1,               // Points (1.00045-1.00055=10 points)

   Percent_of_balance=2,   // Percent of balance

  };

//--- input parameters

input ushort   InpSignalsFrequency=10;       // Search signals, in seconds (< "10" -> only on a new bar)

input ENUM_CLOSE_BY IntCloseBy=Percent_of_balance;  // Close By: 

input ushort   InpVolumeCloseByLoss    = 3.0;      // The value for "Close By" for Loss

input ushort   InpVolumeCloseByProfit  = 5.0;      // The value for "Close By" for Profit

input bool     InpComment              = true;     // Show comments on the chart

//---

input ulong    InpMagic=194032360; // Magic number

//---

ulong  ExtSlippage         = 10;             // Slippage

bool   ExtNeedCloseAll     = false;          // Need Close All

datetime ExtLastSignals    = 0;              // "0" -> D'1970.01.01 00:00';

//+------------------------------------------------------------------+

//| Expert initialization function                                   |

//+------------------------------------------------------------------+

int OnInit()

  {

//---

   if(!m_symbol.Name(Symbol())) // sets symbol name

      return(INIT_FAILED);

   RefreshRates();

//---

   m_trade.SetExpertMagicNumber(InpMagic);

   m_trade.SetMarginMode();

   m_trade.SetTypeFillingBySymbol(m_symbol.Name());

   m_trade.SetDeviationInPoints(ExtSlippage);

//---

   return(INIT_SUCCEEDED);

  }

//+------------------------------------------------------------------+

//| Expert deinitialization function                                 |

//+------------------------------------------------------------------+

void OnDeinit(const int reason)

  {

//---

   if(InpComment)

      Comment("");

  }

//+------------------------------------------------------------------+

//| Expert tick function                                             |

//+------------------------------------------------------------------+

void OnTick()

  {

   if(ExtNeedCloseAll)

     {

      if(IsPositionExists())

        {

         CloseAllPositions();

         return;

        }

      else

         ExtNeedCloseAll=false;

     }

//---

   if(InpSignalsFrequency>=10) // search for trading signals no more than once every 10 seconds

     {

      datetime time_current=TimeCurrent();

      if(time_current-ExtLastSignals>10)

        {

         SearchTradingSignals();

         ExtLastSignals=time_current;

        }

     }

//---

  }

//+------------------------------------------------------------------+

//| TradeTransaction function                                        |

//+------------------------------------------------------------------+

void OnTradeTransaction(const MqlTradeTransaction &trans,

                        const MqlTradeRequest &request,

                        const MqlTradeResult &result)

  {

//--- 



  }

//+------------------------------------------------------------------+

//| Refreshes the symbol quotes data                                 |

//+------------------------------------------------------------------+

bool RefreshRates(void)

  {

//--- refresh rates

   if(!m_symbol.RefreshRates())

     {

      Print("RefreshRates error");

      return(false);

     }

//--- protection against the return value of "zero"

   if(m_symbol.Ask()==0 || m_symbol.Bid()==0)

      return(false);

//---

   return(true);

  }

//+------------------------------------------------------------------+

//| Search trading signals                                           |

//+------------------------------------------------------------------+

bool SearchTradingSignals(void)

  {

/*

   profit+=m_position.Commission()+m_position.Swap()+m_position.Profit();

   enum ENUM_CLOSE_BY

     {

      Equity=0,   // Equity

      Points=1,   // Points (1.00045-1.00055=10 points)

      Percent=2,  // Percent of balance

     };

*/

   double buys_points=0.0,sells_points=0.0,buys_equity=0.0,sells_equity=0.0;

   for(int i=PositionsTotal()-1;i>=0;i--)

      if(m_position.SelectByIndex(i)) // selects the position by index for further access to its properties

        {

         if(!m_symbol.Name(m_position.Symbol()))

            continue;

         if(m_position.PositionType()==POSITION_TYPE_BUY)

           {

            buys_points+=(m_position.PriceCurrent()-m_position.PriceOpen())/m_symbol.Point();

            buys_equity+=m_position.Commission()+m_position.Swap()+m_position.Profit();

           }

         if(m_position.PositionType()==POSITION_TYPE_SELL)

           {

            sells_points+=(m_position.PriceOpen()-m_position.PriceCurrent())/m_symbol.Point();

            sells_equity+=m_position.Commission()+m_position.Swap()+m_position.Profit();

           }

        }

   string text="";

   switch(IntCloseBy)

     {

      case  Equity:

         text=m_account.Currency();

         break;

      case  Points:

         text="points";

         break;

      default:

         text="%";

         break;

     }

   if(InpComment)

      Comment(

              "Close By: ",EnumToString(IntCloseBy),"\n",

              "--- Value Loss: ",IntegerToString(InpVolumeCloseByLoss),text,"\n",

              "--- Value Profit: ",IntegerToString(InpVolumeCloseByProfit),text,"\n",

              "BUY's: ","\n",

              "--- Points: ",DoubleToString(buys_points,0),"\n",

              "--- Equity: ",DoubleToString(buys_equity*100.0/m_account.Equity(),2),"%\n",

              "SELL's: ","\n",

              "--- Points: ",DoubleToString(sells_points,0),"\n",

              "--- Equity: ",DoubleToString(sells_equity*100.0/m_account.Equity(),2),"%\n",

              "Equity: ",DoubleToString(m_account.Equity(),2)," ",m_account.Currency(),"%\n",

              "Percent of balance: ",DoubleToString(m_account.Equity()*100.0/m_account.Balance(),2),"%\n");

   double res=0.0;

   switch(IntCloseBy)

     {

      case  Equity:

         if(Equity<=InpVolumeCloseByLoss || Equity>=InpVolumeCloseByProfit)

         ExtNeedCloseAll=true;

         break;

      case  Points:

         if(buys_points+sells_points==0.0)

         break;

         if(buys_points+sells_points<0.0 && MathAbs(buys_points+sells_points)>=InpVolumeCloseByLoss)

            ExtNeedCloseAll=true;

         else if(buys_points+sells_points>0.0 && buys_points+sells_points>=InpVolumeCloseByProfit)

                                                                           ExtNeedCloseAll=true;

         break;

      default:

         res=m_account.Equity()*100.0/m_account.Balance();

         if(res<=InpVolumeCloseByLoss || res>=InpVolumeCloseByProfit+100.0)

            ExtNeedCloseAll=true;

         break;

     }

//---

   return(true);

  }

//+------------------------------------------------------------------+

//| Is position exists                                               |

//+------------------------------------------------------------------+

bool IsPositionExists(void)

  {

   for(int i=PositionsTotal()-1;i>=0;i--)

      if(m_position.SelectByIndex(i)) // selects the position by index for further access to its properties

         return(true);

//---

   return(false);

  }

//+------------------------------------------------------------------+

//| Close all positions                                              |

//+------------------------------------------------------------------+

void CloseAllPositions(void)

  {

   for(int i=PositionsTotal()-1;i>=0;i--) // returns the number of current positions

      if(m_position.SelectByIndex(i))     // selects the position by index for further access to its properties

         m_trade.PositionClose(m_position.Ticket()); // close a position by the specified symbol

  }

//+------------------------------------------------------------------+