Close at opposite signal Full

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

//|                                Close at opposite signal Full.mq5 |

//|                              Copyright © 2020, Vladimir Karputov |

//|                     https://www.mql5.com/ru/market/product/43516 |

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

#property copyright "Copyright © 2020, Vladimir Karputov"

#property link      "https://www.mql5.com/ru/market/product/43516"

#property version   "1.000"

/*

   barabashkakvn Trading engine 3.112

*/

#include <Trade\PositionInfo.mqh>

#include <Trade\Trade.mqh>

#include <Trade\SymbolInfo.mqh>

//---

CPositionInfo  m_position;                   // object of CPositionInfo class

CTrade         m_trade;                      // object of CTrade class

CSymbolInfo    m_symbol;                     // object of CSymbolInfo class

//---

string   m_symbols_array[];

ulong    m_tickets_array[];

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

//| Expert initialization function                                   |

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

int OnInit()

  {

//---

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

     {

      Print(__FILE__," ",__FUNCTION__,", ERROR: CSymbolInfo.Name");

      return(INIT_FAILED);

     }

   RefreshRates();

//---

   m_trade.SetExpertMagicNumber(0);

   m_trade.SetMarginMode();

   m_trade.SetTypeFillingBySymbol(m_symbol.Name());

   m_trade.SetDeviationInPoints(10);

//---

   return(INIT_SUCCEEDED);

  }

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

//| Expert deinitialization function                                 |

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

void OnDeinit(const int reason)

  {

//---



  }

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

//| Expert tick function                                             |

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

void OnTick()

  {

   int size_symbols_array=ArraySize(m_symbols_array);

   int size_tickets_array=ArraySize(m_tickets_array);

   Comment("Symbols: ",size_symbols_array,",Tickets: ",size_tickets_array);

   if(size_symbols_array>0)

     {

      int count=0;

      ulong ticket=0;

      if(CalculateAllPositions(m_symbols_array[0],count,ticket)>1)

        {

         ArrayResize(m_tickets_array,size_tickets_array+1);

         m_tickets_array[size_tickets_array]=ticket;



         ClosePositions();

         return;

        }

      else

         ArrayRemove(m_symbols_array,0,1);

     }

   else

     {

      if(size_tickets_array>0)

         ArrayFree(m_tickets_array);

     }

//---

  }

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

//| TradeTransaction function                                        |

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

void OnTradeTransaction(const MqlTradeTransaction &trans,

                        const MqlTradeRequest &request,

                        const MqlTradeResult &result)

  {

//--- get transaction type as enumeration value

   ENUM_TRADE_TRANSACTION_TYPE type=trans.type;

//--- if transaction is result of addition of the transaction in history

   if(type==TRADE_TRANSACTION_DEAL_ADD)

     {

      long     deal_type         =-1;

      long     deal_entry        =-1;



      string   deal_symbol       ="";

      if(HistoryDealSelect(trans.deal))

        {

         deal_type         =HistoryDealGetInteger(trans.deal,DEAL_TYPE);

         deal_entry        =HistoryDealGetInteger(trans.deal,DEAL_ENTRY);



         deal_symbol       =HistoryDealGetString(trans.deal,DEAL_SYMBOL);

        }

      else

         return;

      ENUM_DEAL_ENTRY enum_deal_entry=(ENUM_DEAL_ENTRY)deal_entry;



      if(deal_type==DEAL_TYPE_BUY || deal_type==DEAL_TYPE_SELL)

         if(deal_entry==DEAL_ENTRY_IN)

           {

            int size_symbols_array=ArraySize(m_symbols_array);

            ArrayResize(m_symbols_array,size_symbols_array+1);

            m_symbols_array[size_symbols_array]=deal_symbol;

           }

     }

  }

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

//| Refreshes the symbol quotes data                                 |

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

bool RefreshRates()

  {

//--- refresh rates

   if(!m_symbol.RefreshRates())

     {

      Print(__FILE__," ",__FUNCTION__,", ERROR: ","RefreshRates error");

      return(false);

     }

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

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

     {

      Print(__FILE__," ",__FUNCTION__,", ERROR: ","Ask == 0.0 OR Bid == 0.0");

      return(false);

     }

//---

   return(true);

  }

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

//| Check Symbol                                                     |

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

void CheckSymbol(const string symbol)

  {

   int count=0;

   ulong ticket=0;



   if(CalculateAllPositions(symbol,count,ticket)>1)

     {

      int size_tickets_array=ArraySize(m_tickets_array);

      ArrayResize(m_tickets_array,size_tickets_array+1);

      m_tickets_array[size_tickets_array]=ticket;

     }

  }

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

//| Calculate all positions                                          |

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

int CalculateAllPositions(const string symbol,int &count,ulong &old_positions_ticket)

  {

   count                = 0;

   old_positions_ticket = 0;

   datetime time  = TimeCurrent()+86400;

   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_position.Symbol()==symbol)

           {

            count++;

            if(m_position.Time()<time)

              {

               time=m_position.Time();

               old_positions_ticket=m_position.Ticket();

              }

           }

//---

   return(count);

  }

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

//| Close positions                                                  |

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

void ClosePositions(void)

  {

   int size_tickets_array=ArraySize(m_tickets_array);

   if(size_tickets_array==0)

      return;

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

     {

      if(m_position.SelectByTicket(m_tickets_array[i])) // selects the position by ticket for further access to its properties

        {

         if(!m_trade.PositionClose(m_tickets_array[i])) // close a position

            Print("Position ",m_position.Ticket()," is not closed");

        }

      else

         ArrayRemove(m_tickets_array,i,1);

     }

  }

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