Tumbler toy

Author: Copyright © 2020, Vladimir Karputov
Price Data Components
Series array that contains tick volumes of each bar
Orders Execution
Checks for the total of open orders
Miscellaneous
It issuies visual alerts to the screen
0 Views
0 Downloads
0 Favorites
Tumbler toy 
ÿþ//+------------------------------------------------------------------+

//|                                                  Tumbler toy.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.114

*/

#include <Trade\PositionInfo.mqh>

#include <Trade\Trade.mqh>

#include <Trade\SymbolInfo.mqh>

#include <Trade\AccountInfo.mqh>

#include <Trade\OrderInfo.mqh>

//---

CPositionInfo  m_position;                   // object of CPositionInfo class

CTrade         m_trade;                      // object of CTrade class

CSymbolInfo    m_symbol;                     // object of CSymbolInfo class

CAccountInfo   m_account;                    // object of CAccountInfo class

COrderInfo     m_order;                      // object of COrderInfo class

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

//| Enum Lor or Risk                                                 |

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

enum ENUM_LOT_OR_RISK

  {

   lots_min=0, // Lots Min

   lot=1,      // Constant lot

   risk=2,     // Risk in percent for a deal

  };

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

//| Enum Pending Type                                                |

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

enum ENUM_PENDING_TYPE

  {

   stop=0,     // Buy stop Sell stop

   limit=1,    // Buy limit Sell limit

  };

//--- input parameters

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

input ushort   InpNumberMinLots     = 1;           // The number of minimum lots (for start lot)

input double   InpProfitTarget      = 3;           // Profit target

input double   InpLossTarget        = -9;          // Loss target

input double   InpMaxLot            = 5;           // Maximum lot

input double   InpMaxPositions      = 15;          // Maximum number of positions

//---

input ushort   InpPendingExpiration = 0;           // Pending: Expiration, in minutes ('0' -> OFF)

input ushort   InpPendingIndent     = 10;          // Pending: Indent, in pips (1.00045-1.00055=1 pips)

input ushort   InpMaxSpread         = 12;          // Pending: Maximum spread, in points (1.00045-1.00055=10 points)

input ENUM_PENDING_TYPE InpPendingType=stop;       // Pending: Type

input ushort   InpPendingStopLoss   = 30;          // Pending: Stop Loss, in pips (1.00045-1.00055=1 pips)

input double   InpPendingIncreaseRatio=1.8;        // Pending: Overturn Lot increase ratio

//---

input bool     InpTimeControl       = true;        // Use time control

input uchar    InpStartHour         = 09;          // Start Hour

input uchar    InpStartMinute       = 59;          // Start Minute

input uchar    InpEndHour           = 15;          // End Hour

input uchar    InpEndMinute         = 01;          // End Minute

input bool     InpPrintLog          = false;       // Print log

input ulong    InpDeviation         = 10;          // Deviation, in points (1.00045-1.00055=10 points)

input ulong    InpMagic             = 247378656;   // Magic number

//---

double   m_pending_indent           = 0.0;      // Pending: Indent         -> double

double   m_max_spread               = 0.0;      // Pending: Maximum spread -> double

double   m_pending_sl               = 0.0;      // Pending: Stop Loss      -> double



double   m_adjusted_point;                      // point value adjusted for 3 or 5 points

bool     m_need_close_all           = false;    // close all positions

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

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

bool     m_need_delete_all          = false;    // delete all pending orders

bool     m_waiting_pending_order    = false;    // waiting for a pending order

//--- ***,

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

//| Structurt Pending                                                |

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

struct STRUCT_PENDING

  {

   ENUM_ORDER_TYPE   pending_type;           // pending order type

   double            volume;                 // pending order volume

   double            price;                  // pending order price

   double            indent;                 // pending indent, in pips * m_adjusted_point

   long              expiration;             // expiration (extra time)

   //--- Constructor

                     STRUCT_PENDING()

     {

      pending_type               = WRONG_VALUE;

      volume                     = 0.0;

      price                      = 0.0;

      indent                     = 0.0;

      expiration                 = 0;

     }

  };

STRUCT_PENDING SPending[];

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

//| Expert initialization function                                   |

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

int OnInit()

  {

//---

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

     {

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

      return(INIT_FAILED);

     }

   RefreshRates();

//---

   if(InpPendingExpiration>0)

     {

      int exp_type=(int)SYMBOL_EXPIRATION_SPECIFIED;

      int expiration=(int)m_symbol.TradeTimeFlags();

      if((expiration&exp_type)!=exp_type)

        {

         string err_text=(TerminalInfoString(TERMINAL_LANGUAGE)=="Russian")?

                         "0 A8<2>;5 "+m_symbol.Name()+" =5;L7O 7040BL !@>: 8AB5G5=8O 4;O >B;>65==>3> >@45@0!":

                         "On the symbol "+m_symbol.Name()+" you can not set the expiration date for a pending order!";

         //--- when testing, we will only output to the log about incorrect input parameters

         if(MQLInfoInteger(MQL_TESTER))

           {

            Print(__FILE__," ",__FUNCTION__,", ERROR: ",err_text);

            return(INIT_FAILED);

           }

         else // if the Expert Advisor is run on the chart, tell the user about the error

           {

            Alert(__FILE__," ",__FUNCTION__,", ERROR: ",err_text);

            return(INIT_PARAMETERS_INCORRECT);

           }

        }

     }

//---

   m_trade.SetExpertMagicNumber(InpMagic);

   m_trade.SetMarginMode();

   m_trade.SetTypeFillingBySymbol(m_symbol.Name());

   m_trade.SetDeviationInPoints(InpDeviation);

//--- tuning for 3 or 5 digits

   int digits_adjust=1;

   if(m_symbol.Digits()==3 || m_symbol.Digits()==5)

      digits_adjust=10;

   m_adjusted_point=m_symbol.Point()*digits_adjust;



   m_pending_indent        = InpPendingIndent         * m_adjusted_point;

   m_max_spread            = InpMaxSpread             * m_symbol.Point();

   m_pending_sl            = InpPendingStopLoss       * m_adjusted_point;

//---

   return(INIT_SUCCEEDED);

  }

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

//| Expert deinitialization function                                 |

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

void OnDeinit(const int reason)

  {

//---



  }

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

//| Expert tick function                                             |

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

void OnTick()

  {

   if(m_need_close_all)

     {

      if(IsPositionExists())

        {

         double level;

         if(FreezeStopsLevels(level))

           {

            CloseAllPositions(level);

            return;

           }

         else

            return;

        }

      else

         m_need_close_all=false;

     }

//---

   if(m_need_delete_all)

     {

      if(IsPendingOrdersExists())

        {

         double level;

         if(FreezeStopsLevels(level))

           {

            DeleteAllPendingOrders(level);

            return;

           }

         else

            return;

        }

      else

         m_need_delete_all=false;

     }

//---

   double profit=ProfitAllPositions();

   if(profit<=InpLossTarget || profit>=InpProfitTarget)

     {

      m_need_close_all=true;

      m_need_delete_all=true;

      return;

     }

//---

   int size_need_pending=ArraySize(SPending);

   if(size_need_pending>0)

     {

      if(!m_waiting_pending_order)

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

           {

            double level;

            double adjusted_point=0;

            if(FreezeStopsLevels(level))

              {

               m_waiting_pending_order=true;

               PlaceOrders(i,level);

              }

           }

      return;

     }

//---

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

     {

      datetime time_current=TimeCurrent();

      if(time_current-m_last_signal>10)

        {

         //--- search for trading signals

         if(!RefreshRates())

           {

            m_prev_bars=0;

            return;

           }

         if(!SearchTradingSignals())

           {

            m_prev_bars=0;

            return;

           }

         m_last_signal=time_current;

        }

     }

//--- we work only at the time of the birth of new bar

   datetime time_0=iTime(m_symbol.Name(),Period(),0);

   if(time_0==m_prev_bars)

      return;

   m_prev_bars=time_0;

   if(InpSignalsFrequency<10) // search for trading signals only at the time of the birth of new bar

     {

      if(!RefreshRates())

        {

         m_prev_bars=0;

         return;

        }

      //--- search for trading signals

      if(!SearchTradingSignals())

        {

         m_prev_bars=0;

         return;

        }

     }

//---

  }

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

//| 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_ticket       =0;

      long     deal_order        =0;

      long     deal_time         =0;

      long     deal_time_msc     =0;

      long     deal_type         =-1;

      long     deal_entry        =-1;

      long     deal_magic        =0;

      long     deal_reason       =-1;

      long     deal_position_id  =0;

      double   deal_volume       =0.0;

      double   deal_price        =0.0;

      double   deal_commission   =0.0;

      double   deal_swap         =0.0;

      double   deal_profit       =0.0;

      string   deal_symbol       ="";

      string   deal_comment      ="";

      string   deal_external_id  ="";

      if(HistoryDealSelect(trans.deal))

        {

         deal_ticket       =HistoryDealGetInteger(trans.deal,DEAL_TICKET);

         deal_order        =HistoryDealGetInteger(trans.deal,DEAL_ORDER);

         deal_time         =HistoryDealGetInteger(trans.deal,DEAL_TIME);

         deal_time_msc     =HistoryDealGetInteger(trans.deal,DEAL_TIME_MSC);

         deal_type         =HistoryDealGetInteger(trans.deal,DEAL_TYPE);

         deal_entry        =HistoryDealGetInteger(trans.deal,DEAL_ENTRY);

         deal_magic        =HistoryDealGetInteger(trans.deal,DEAL_MAGIC);

         deal_reason       =HistoryDealGetInteger(trans.deal,DEAL_REASON);

         deal_position_id  =HistoryDealGetInteger(trans.deal,DEAL_POSITION_ID);



         deal_volume       =HistoryDealGetDouble(trans.deal,DEAL_VOLUME);

         deal_price        =HistoryDealGetDouble(trans.deal,DEAL_PRICE);

         deal_commission   =HistoryDealGetDouble(trans.deal,DEAL_COMMISSION);

         deal_swap         =HistoryDealGetDouble(trans.deal,DEAL_SWAP);

         deal_profit       =HistoryDealGetDouble(trans.deal,DEAL_PROFIT);



         deal_symbol       =HistoryDealGetString(trans.deal,DEAL_SYMBOL);

         deal_comment      =HistoryDealGetString(trans.deal,DEAL_COMMENT);

         deal_external_id  =HistoryDealGetString(trans.deal,DEAL_EXTERNAL_ID);

        }

      else

         return;

      ENUM_DEAL_ENTRY enum_deal_entry=(ENUM_DEAL_ENTRY)deal_entry;

      if(deal_symbol==m_symbol.Name() && deal_magic==InpMagic)

        {

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

           {

            if(deal_entry==DEAL_ENTRY_IN || deal_entry==DEAL_ENTRY_INOUT)

              {

               m_need_delete_all=true;

               //---

               double lot=LotCheck(deal_volume*InpPendingIncreaseRatio,m_symbol);

               if(lot==0.0 || lot>InpMaxLot)

                 {

                  m_need_close_all=true;

                  m_need_delete_all=true;

                  return;

                 }

               if(CalculateAllPositions()>=InpMaxPositions)

                 {

                  m_need_close_all=true;

                  m_need_delete_all=true;

                  return;

                 }

               //---

               int size_need_pending=ArraySize(SPending);

               ArrayResize(SPending,size_need_pending+1);



               if(deal_type==DEAL_TYPE_BUY)

                 {

                  if(InpPendingType==stop)

                     SPending[size_need_pending].pending_type=ORDER_TYPE_SELL_STOP;

                  else

                     SPending[size_need_pending].pending_type=ORDER_TYPE_SELL_LIMIT;

                 }

               if(deal_type==DEAL_TYPE_SELL)

                 {

                  if(InpPendingType==stop)

                     SPending[size_need_pending].pending_type=ORDER_TYPE_BUY_STOP;

                  else

                     SPending[size_need_pending].pending_type=ORDER_TYPE_BUY_LIMIT;

                 }



               SPending[size_need_pending].volume=lot;

               SPending[size_need_pending].indent=m_pending_indent;

               if(InpPendingExpiration>0)

                  SPending[size_need_pending].expiration=(long)(InpPendingExpiration*60);

               if(InpPrintLog)

                  Print(__FILE__," ",__FUNCTION__,", OK: ","Signal BUY STOP");

               return;

              }

           }

        }

     }

  }

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

//| Refreshes the symbol quotes data                                 |

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

bool RefreshRates()

  {

//--- refresh rates

   if(!m_symbol.RefreshRates())

     {

      if(InpPrintLog)

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

      return(false);

     }

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

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

     {

      if(InpPrintLog)

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

      return(false);

     }

//---

   return(true);

  }

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

//| Lot Check                                                        |

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

double LotCheck(double lots,CSymbolInfo &symbol)

  {

//--- calculate maximum volume

   double volume=NormalizeDouble(lots,2);

   double stepvol=symbol.LotsStep();

   if(stepvol>0.0)

      volume=stepvol*MathFloor(volume/stepvol);

//---

   double minvol=symbol.LotsMin();

   if(volume<minvol)

      volume=0.0;

//---

   double maxvol=symbol.LotsMax();

   if(volume>maxvol)

      volume=maxvol;

   return(volume);

  }

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

//| Check Freeze and Stops levels                                    |

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

bool FreezeStopsLevels(double &level)

  {

//--- check Freeze and Stops levels

   /*

      Type of order/position  |  Activation price  |  Check

      ------------------------|--------------------|--------------------------------------------

      Buy Limit order         |  Ask               |  Ask-OpenPrice  >= SYMBOL_TRADE_FREEZE_LEVEL

      Buy Stop order          |  Ask               |  OpenPrice-Ask  >= SYMBOL_TRADE_FREEZE_LEVEL

      Sell Limit order        |  Bid               |  OpenPrice-Bid  >= SYMBOL_TRADE_FREEZE_LEVEL

      Sell Stop order         |  Bid               |  Bid-OpenPrice  >= SYMBOL_TRADE_FREEZE_LEVEL

      Buy position            |  Bid               |  TakeProfit-Bid >= SYMBOL_TRADE_FREEZE_LEVEL

                              |                    |  Bid-StopLoss   >= SYMBOL_TRADE_FREEZE_LEVEL

      Sell position           |  Ask               |  Ask-TakeProfit >= SYMBOL_TRADE_FREEZE_LEVEL

                              |                    |  StopLoss-Ask   >= SYMBOL_TRADE_FREEZE_LEVEL



      Buying is done at the Ask price                 |  Selling is done at the Bid price

      ------------------------------------------------|----------------------------------

      TakeProfit        >= Bid                        |  TakeProfit        <= Ask

      StopLoss          <= Bid                        |  StopLoss          >= Ask

      TakeProfit - Bid  >= SYMBOL_TRADE_STOPS_LEVEL   |  Ask - TakeProfit  >= SYMBOL_TRADE_STOPS_LEVEL

      Bid - StopLoss    >= SYMBOL_TRADE_STOPS_LEVEL   |  StopLoss - Ask    >= SYMBOL_TRADE_STOPS_LEVEL

   */

   if(!RefreshRates() || !m_symbol.Refresh())

      return(false);

//--- FreezeLevel -> for pending order and modification

   double freeze_level=m_symbol.FreezeLevel()*m_symbol.Point();

   if(freeze_level==0.0)

      freeze_level=(m_symbol.Ask()-m_symbol.Bid())*3.0;

//--- StopsLevel -> for TakeProfit and StopLoss

   double stop_level=m_symbol.StopsLevel()*m_symbol.Point();

   if(stop_level==0.0)

      stop_level=(m_symbol.Ask()-m_symbol.Bid())*3.0;



   if(freeze_level<=0.0 || stop_level<=0.0)

      return(false);



   level=(freeze_level>stop_level)?freeze_level:stop_level;



   double spread=m_symbol.Spread()*m_symbol.Point()*3.0;

   level=(level>spread)?level:spread;

//---

   return(true);

  }

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

//| Print CTrade result                                              |

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

void PrintResultTrade(CTrade &trade,CSymbolInfo &symbol)

  {

   Print(__FILE__," ",__FUNCTION__,", Symbol: ",symbol.Name()+", "+

         "Code of request result: "+IntegerToString(trade.ResultRetcode())+", "+

         "Code of request result as a string: "+trade.ResultRetcodeDescription());

   Print("Deal ticket: "+IntegerToString(trade.ResultDeal())+", "+

         "Order ticket: "+IntegerToString(trade.ResultOrder())+", "+

         "Order retcode external: "+IntegerToString(trade.ResultRetcodeExternal())+", "+

         "Volume of deal or order: "+DoubleToString(trade.ResultVolume(),2));

   Print("Price, confirmed by broker: "+DoubleToString(trade.ResultPrice(),symbol.Digits())+", "+

         "Current bid price: "+DoubleToString(symbol.Bid(),symbol.Digits())+" (the requote): "+DoubleToString(trade.ResultBid(),symbol.Digits())+", "+

         "Current ask price: "+DoubleToString(symbol.Ask(),symbol.Digits())+" (the requote): "+DoubleToString(trade.ResultAsk(),symbol.Digits()));

   Print("Broker comment: "+trade.ResultComment());

  }

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

//| Calculate all positions                                          |

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

void CalculateAllPositions(int &count_buys,double &volume_buys,double &volume_biggest_buys,

                           int &count_sells,double &volume_sells,double &volume_biggest_sells)

  {

   count_buys  = 0;

   volume_buys   = 0.0;

   volume_biggest_buys  = 0.0;

   count_sells = 0;

   volume_sells  = 0.0;

   volume_biggest_sells = 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_position.Symbol()==m_symbol.Name())

           {

            if(m_position.PositionType()==POSITION_TYPE_BUY)

              {

               count_buys++;

               volume_buys+=m_position.Volume();

               if(m_position.Volume()>volume_biggest_buys)

                  volume_biggest_buys=m_position.Volume();

               continue;

              }

            else

               if(m_position.PositionType()==POSITION_TYPE_SELL)

                 {

                  count_sells++;

                  volume_sells+=m_position.Volume();

                  if(m_position.Volume()>volume_biggest_sells)

                     volume_biggest_sells=m_position.Volume();

                 }

           }

  }

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

//| Search trading signals                                           |

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

bool SearchTradingSignals(void)

  {

   if(!TimeControlHourMinute())

      return(true);

   if(IsPendingOrdersExists())

      return(true);

   if(IsPositionExists())

      return(true);

//---

   int size_need_pending=ArraySize(SPending);

   if(size_need_pending>0)

      return(true);



   ArrayResize(SPending,size_need_pending+2);

   if(InpPendingType==stop)

     {

      SPending[size_need_pending].pending_type=ORDER_TYPE_BUY_STOP;

      SPending[size_need_pending+1].pending_type=ORDER_TYPE_SELL_STOP;

      if(InpPrintLog)

        {

         Print(__FILE__," ",__FUNCTION__,", OK: ","Signal BUY STOP");

         Print(__FILE__," ",__FUNCTION__,", OK: ","Signal SELL STOP");

        }

     }

   else

     {

      SPending[size_need_pending].pending_type=ORDER_TYPE_BUY_LIMIT;

      SPending[size_need_pending+1].pending_type=ORDER_TYPE_SELL_LIMIT;

      if(InpPrintLog)

        {

         Print(__FILE__," ",__FUNCTION__,", OK: ","Signal BUY LIMIT");

         Print(__FILE__," ",__FUNCTION__,", OK: ","Signal SELL LIMIT");

        }

     }



   double lot=LotCheck(InpNumberMinLots*m_symbol.LotsMin(),m_symbol);



   SPending[size_need_pending].volume=lot;

   SPending[size_need_pending].indent=m_pending_indent;

   SPending[size_need_pending+1].volume=lot;

   SPending[size_need_pending+1].indent=m_pending_indent;

   if(InpPendingExpiration>0)

     {

      SPending[size_need_pending].expiration=(long)(InpPendingExpiration*60);

      SPending[size_need_pending+1].expiration=(long)(InpPendingExpiration*60);

     }

//---

   return(true);

  }

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

//| Delete all pending orders                                        |

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

void DeleteAllPendingOrders(const double level)

  {

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

      if(m_order.SelectByIndex(i))     // selects the pending order by index for further access to its properties

         if(m_order.Symbol()==m_symbol.Name() && m_order.Magic()==InpMagic)

           {

            if(m_order.OrderType()==ORDER_TYPE_BUY_LIMIT)

              {

               if(m_symbol.Ask()-m_order.PriceOpen()>=level)

                  if(!m_trade.OrderDelete(m_order.Ticket()))

                     if(InpPrintLog)

                        Print(__FILE__," ",__FUNCTION__,", ERROR: ","CTrade.OrderDelete ",m_order.Ticket());

               continue;

              }

            if(m_order.OrderType()==ORDER_TYPE_BUY_STOP)

              {

               if(m_order.PriceOpen()-m_symbol.Ask()>=level)

                  if(!m_trade.OrderDelete(m_order.Ticket()))

                     if(InpPrintLog)

                        Print(__FILE__," ",__FUNCTION__,", ERROR: ","CTrade.OrderDelete ",m_order.Ticket());

               continue;

              }

            if(m_order.OrderType()==ORDER_TYPE_SELL_LIMIT)

              {

               if(m_order.PriceOpen()-m_symbol.Bid()>=level)

                  if(!m_trade.OrderDelete(m_order.Ticket()))

                     if(InpPrintLog)

                        Print(__FILE__," ",__FUNCTION__,", ERROR: ","CTrade.OrderDelete ",m_order.Ticket());

               continue;

              }

            if(m_order.OrderType()==ORDER_TYPE_SELL_STOP)

              {

               if(m_symbol.Bid()-m_order.PriceOpen()>=level)

                  if(!m_trade.OrderDelete(m_order.Ticket()))

                     if(InpPrintLog)

                        Print(__FILE__," ",__FUNCTION__,", ERROR: ","CTrade.OrderDelete ",m_order.Ticket());

               continue;

              }

           }

  }

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

//| Is pending orders exists                                         |

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

bool IsPendingOrdersExists(void)

  {

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

      if(m_order.SelectByIndex(i))     // selects the pending order by index for further access to its properties

         if(m_order.Symbol()==m_symbol.Name() && m_order.Magic()==InpMagic)

            return(true);

//---

   return(false);

  }

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

//| Place Orders                                                     |

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

void PlaceOrders(const int index,const double level)

  {

//--- check Freeze and Stops levels

   /*

      Type of order/position  |  Activation price  |  Check

      ------------------------|--------------------|--------------------------------------------

      Buy Limit order         |  Ask               |  Ask-OpenPrice  >= SYMBOL_TRADE_FREEZE_LEVEL

      Buy Stop order          |  Ask               |  OpenPrice-Ask  >= SYMBOL_TRADE_FREEZE_LEVEL

      Sell Limit order        |  Bid               |  OpenPrice-Bid  >= SYMBOL_TRADE_FREEZE_LEVEL

      Sell Stop order         |  Bid               |  Bid-OpenPrice  >= SYMBOL_TRADE_FREEZE_LEVEL

      Buy position            |  Bid               |  TakeProfit-Bid >= SYMBOL_TRADE_FREEZE_LEVEL

                              |                    |  Bid-StopLoss   >= SYMBOL_TRADE_FREEZE_LEVEL

      Sell position           |  Ask               |  Ask-TakeProfit >= SYMBOL_TRADE_FREEZE_LEVEL

                              |                    |  StopLoss-Ask   >= SYMBOL_TRADE_FREEZE_LEVEL



      Buying is done at the Ask price                 |  Selling is done at the Bid price

      ------------------------------------------------|----------------------------------

      TakeProfit        >= Bid                        |  TakeProfit        <= Ask

      StopLoss          <= Bid                        |  StopLoss          >= Ask

      TakeProfit - Bid  >= SYMBOL_TRADE_STOPS_LEVEL   |  Ask - TakeProfit  >= SYMBOL_TRADE_STOPS_LEVEL

      Bid - StopLoss    >= SYMBOL_TRADE_STOPS_LEVEL   |  StopLoss - Ask    >= SYMBOL_TRADE_STOPS_LEVEL

   */

   double spread=m_symbol.Ask()-m_symbol.Bid();

   if(spread>m_max_spread)

     {

      m_waiting_pending_order=false;

      if(InpPrintLog)

         Print(__FILE__," ",__FUNCTION__,

               ", ERROR: ","Spread Ask-Bid (",DoubleToString(spread,m_symbol.Digits()),")",

               " > Maximum spread (",DoubleToString(m_max_spread,m_symbol.Digits()),")");

      return;

     }

//--- buy limit

   if(SPending[index].pending_type==ORDER_TYPE_BUY_LIMIT)

     {

      if(SPending[index].price==0.0)

         SPending[index].price=m_symbol.Ask()-m_pending_indent;

      if(m_symbol.Ask()-SPending[index].price<level) // check price

         SPending[index].price=m_symbol.Ask()-level;



      PendingOrder(index);

      ArrayRemove(SPending,index,1);

      m_waiting_pending_order=false;

      return;

     }

//--- sell limit

   if(SPending[index].pending_type==ORDER_TYPE_SELL_LIMIT)

     {

      if(SPending[index].price==0.0)

         SPending[index].price=m_symbol.Bid()+m_pending_indent;

      if(SPending[index].price-m_symbol.Bid()<level) // check price

         SPending[index].price=m_symbol.Bid()+level;



      PendingOrder(index);

      ArrayRemove(SPending,index,1);

      m_waiting_pending_order=false;

      return;

     }

//--- buy stop

   if(SPending[index].pending_type==ORDER_TYPE_BUY_STOP)

     {

      if(SPending[index].price==0.0)

         SPending[index].price=m_symbol.Ask()+m_pending_indent;

      if(SPending[index].price-m_symbol.Ask()<level) // check price

         SPending[index].price=m_symbol.Ask()+level;



      PendingOrder(index);

      ArrayRemove(SPending,index,1);

      m_waiting_pending_order=false;

      return;

     }

//--- sell stop

   if(SPending[index].pending_type==ORDER_TYPE_SELL_STOP)

     {

      if(SPending[index].price==0.0)

         SPending[index].price=m_symbol.Bid()-m_pending_indent;

      if(m_symbol.Bid()-SPending[index].price<level) // check price

         SPending[index].price=m_symbol.Bid()-level;



      PendingOrder(index);

      ArrayRemove(SPending,index,1);

      m_waiting_pending_order=false;

      return;

     }

  }

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

//| Pending order                                                    |

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

bool PendingOrder(const int index)

  {

   double sl=0.0;

   double tp=0.0;

//--- check volume before OrderSend to avoid "not enough money" error (CTrade)

   ENUM_ORDER_TYPE check_order_type=-1;

   switch(SPending[index].pending_type)

     {

      case  ORDER_TYPE_BUY:

         check_order_type=ORDER_TYPE_BUY;

         break;

      case ORDER_TYPE_SELL:

         check_order_type=ORDER_TYPE_SELL;

         break;

      case ORDER_TYPE_BUY_LIMIT:

         check_order_type=ORDER_TYPE_BUY;

         break;

      case ORDER_TYPE_SELL_LIMIT:

         check_order_type=ORDER_TYPE_SELL;

         break;

      case ORDER_TYPE_BUY_STOP:

         check_order_type=ORDER_TYPE_BUY;

         break;

      case ORDER_TYPE_SELL_STOP:

         check_order_type=ORDER_TYPE_SELL;

         break;

      default:

         return(false);

         break;

     }

//---

   if(SPending[index].volume==0.0)

      return(false);

   double long_lot=SPending[index].volume;

   double short_lot=SPending[index].volume;

//--- check volume before OrderSend to avoid "not enough money" error (CTrade)

   double check_price=0;

   double check_lot=0;

   if(check_order_type==ORDER_TYPE_BUY)

     {

      check_price=m_symbol.Ask();

      check_lot=long_lot;

     }

   else

     {

      check_price=m_symbol.Bid();

      check_lot=short_lot;

     }

//---

   if(m_symbol.LotsLimit()>0.0)

     {

      double volume_buys        = 0.0;

      double volume_sells       = 0.0;

      double volume_buy_limits  = 0.0;

      double volume_sell_limits = 0.0;

      double volume_buy_stops   = 0.0;

      double volume_sell_stops  = 0.0;

      CalculateAllVolumes(volume_buys,volume_sells,

                          volume_buy_limits,volume_sell_limits,

                          volume_buy_stops,volume_sell_stops);

      if(volume_buys+volume_sells+

         volume_buy_limits+volume_sell_limits+

         volume_buy_stops+volume_sell_stops+check_lot>m_symbol.LotsLimit())

        {

         if(InpPrintLog)

            Print(__FILE__," ",__FUNCTION__,", ERROR: ","#0 ,",EnumToString(SPending[index].pending_type),", ",

                  "Volume Buy's (",DoubleToString(volume_buys,2),")",

                  "Volume Sell's (",DoubleToString(volume_sells,2),")",

                  "Volume Buy limit's (",DoubleToString(volume_buy_limits,2),")",

                  "Volume Sell limit's (",DoubleToString(volume_sell_limits,2),")",

                  "Volume Buy stops's (",DoubleToString(volume_buy_stops,2),")",

                  "Volume Sell stops's (",DoubleToString(volume_sell_stops,2),")",

                  "Check lot (",DoubleToString(check_lot,2),")",

                  " > Lots Limit (",DoubleToString(m_symbol.LotsLimit(),2),")");

         return(false);

        }

     }

//--- check maximal number of allowed pending orders

   int account_limit_orders=m_account.LimitOrders();

   if(account_limit_orders>0)

     {

      int all_pending_orders=CalculateAllPendingOrders();

      /*

            there is 8,  and there will be  9 > restriction 10 -> OK

            there is 9,  and there will be 10 > restriction 10 -> OK

            there is 10, and there will be 11 > restriction 10 -> ERROR

      */

      if(all_pending_orders+1>account_limit_orders)

         return(false);

     }

//--- check volume before OrderSend to avoid "not enough money" error (CTrade)

   double free_margin_check=m_account.FreeMarginCheck(m_symbol.Name(),

                            check_order_type,check_lot,check_price);

   double margin_check=m_account.MarginCheck(m_symbol.Name(),

                       check_order_type,check_lot,SPending[index].price);

   if(free_margin_check>margin_check)

     {

      bool result=false;

      if(SPending[index].expiration>0)

        {

         datetime time_expiration=TimeCurrent()+(datetime)SPending[index].expiration;

         result=m_trade.OrderOpen(m_symbol.Name(),

                                  SPending[index].pending_type,check_lot,0.0,

                                  m_symbol.NormalizePrice(SPending[index].price),

                                  m_symbol.NormalizePrice(sl),

                                  m_symbol.NormalizePrice(tp),

                                  ORDER_TIME_SPECIFIED,

                                  time_expiration);

        }

      else

        {

         result=m_trade.OrderOpen(m_symbol.Name(),

                                  SPending[index].pending_type,check_lot,0.0,

                                  m_symbol.NormalizePrice(SPending[index].price),

                                  m_symbol.NormalizePrice(sl),

                                  m_symbol.NormalizePrice(tp));

        }



      if(result)

        {

         if(m_trade.ResultOrder()==0)

           {

            if(InpPrintLog)

               Print(__FILE__," ",__FUNCTION__,", ERROR: ","#1 ",EnumToString(SPending[index].pending_type)," -> false. Result Retcode: ",m_trade.ResultRetcode(),

                     ", description of result: ",m_trade.ResultRetcodeDescription());

            if(InpPrintLog)

               PrintResultTrade(m_trade,m_symbol);

            return(false);

           }

         else

           {

            if(InpPrintLog)

               Print(__FILE__," ",__FUNCTION__,", OK: ","#2 ",EnumToString(SPending[index].pending_type)," -> true. Result Retcode: ",m_trade.ResultRetcode(),

                     ", description of result: ",m_trade.ResultRetcodeDescription());

            if(InpPrintLog)

               PrintResultTrade(m_trade,m_symbol);

            return(true);

           }

        }

      else

        {

         if(InpPrintLog)

            Print(__FILE__," ",__FUNCTION__,", ERROR: ","#3 ",EnumToString(SPending[index].pending_type)," -> false. Result Retcode: ",m_trade.ResultRetcode(),

                  ", description of result: ",m_trade.ResultRetcodeDescription());

         if(InpPrintLog)

            PrintResultTrade(m_trade,m_symbol);

         return(false);

        }

     }

   else

     {

      if(InpPrintLog)

         Print(__FILE__," ",__FUNCTION__,", ERROR: CAccountInfo.FreeMarginCheck returned the value ",DoubleToString(free_margin_check,2));

      return(false);

     }

//---

   return(false);

  }

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

//| Calculate all volumes                                            |

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

void CalculateAllVolumes(double &volumne_buys,double &volumne_sells,

                         double &volumne_buy_limits,double &volumne_sell_limits,

                         double &volumne_buy_stops,double &volumne_sell_stops)

  {

   volumne_buys         = 0.0;

   volumne_sells        = 0.0;

   volumne_buy_limits   = 0.0;

   volumne_sell_limits  = 0.0;

   volumne_buy_stops    = 0.0;

   volumne_sell_stops   = 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_position.Symbol()==m_symbol.Name())

           {

            if(m_position.PositionType()==POSITION_TYPE_BUY)

               volumne_buys+=m_position.Volume();

            else

               if(m_position.PositionType()==POSITION_TYPE_SELL)

                  volumne_sells+=m_position.Volume();

           }



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

      if(m_order.SelectByIndex(i)) // selects the pending order by index for further access to its properties

         if(m_order.Symbol()==m_symbol.Name())

           {

            if(m_order.OrderType()==ORDER_TYPE_BUY_LIMIT)

               volumne_buy_limits+=m_order.VolumeInitial();

            else

               if(m_order.OrderType()==ORDER_TYPE_SELL_LIMIT)

                  volumne_sell_limits+=m_order.VolumeInitial();

               else

                  if(m_order.OrderType()==ORDER_TYPE_BUY_STOP)

                     volumne_buy_stops+=m_order.VolumeInitial();

                  else

                     if(m_order.OrderType()==ORDER_TYPE_SELL_STOP)

                        volumne_sell_stops+=m_order.VolumeInitial();

           }

  }

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

//| 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

         if(m_position.Symbol()==m_symbol.Name() && m_position.Magic()==InpMagic)

            return(true);

//---

   return(false);

  }

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

//| Close all positions                                              |

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

void CloseAllPositions(const double level)

  {

   /*

      Buying is done at the Ask price                 |  Selling is done at the Bid price

      ------------------------------------------------|----------------------------------

      TakeProfit        >= Bid                        |  TakeProfit        <= Ask

      StopLoss          <= Bid                        |  StopLoss          >= Ask

      TakeProfit - Bid  >= SYMBOL_TRADE_STOPS_LEVEL   |  Ask - TakeProfit  >= SYMBOL_TRADE_STOPS_LEVEL

      Bid - StopLoss    >= SYMBOL_TRADE_STOPS_LEVEL   |  StopLoss - Ask    >= SYMBOL_TRADE_STOPS_LEVEL

   */

   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

         if(m_position.Symbol()==m_symbol.Name() && m_position.Magic()==InpMagic)

           {

            if(m_position.PositionType()==POSITION_TYPE_BUY)

              {

               bool take_profit_level=(m_position.TakeProfit()!=0.0 && m_position.TakeProfit()-m_position.PriceCurrent()>=level) || m_position.TakeProfit()==0.0;

               bool stop_loss_level=(m_position.StopLoss()!=0.0 && m_position.PriceCurrent()-m_position.StopLoss()>=level) || m_position.StopLoss()==0.0;

               if(take_profit_level && stop_loss_level)

                  if(!m_trade.PositionClose(m_position.Ticket())) // close a position by the specified m_symbol

                     if(InpPrintLog)

                        Print(__FILE__," ",__FUNCTION__,", ERROR: ","CTrade.PositionClose ",m_position.Ticket());

              }

            if(m_position.PositionType()==POSITION_TYPE_SELL)

              {

               bool take_profit_level=(m_position.TakeProfit()!=0.0 && m_position.PriceCurrent()-m_position.TakeProfit()>=level) || m_position.TakeProfit()==0.0;

               bool stop_loss_level=(m_position.StopLoss()!=0.0 && m_position.StopLoss()-m_position.PriceCurrent()>=level) || m_position.StopLoss()==0.0;

               if(take_profit_level && stop_loss_level)

                  if(!m_trade.PositionClose(m_position.Ticket())) // close a position by the specified m_symbol

                     if(InpPrintLog)

                        Print(__FILE__," ",__FUNCTION__,", ERROR: ","CTrade.PositionClose ",m_position.Ticket());

              }

           }

  }

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

//| Calculate all pending orders                                     |

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

int CalculateAllPendingOrders(void)

  {

   int count=0;



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

      if(m_order.SelectByIndex(i))     // selects the pending order by index for further access to its properties

         count++;

//---

   return(count);

  }

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

//| TimeControl                                                      |

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

bool TimeControlHourMinute(void)

  {

   if(!InpTimeControl)

      return(true);

   MqlDateTime STimeCurrent;

   datetime time_current=TimeCurrent();

   if(time_current==D'1970.01.01 00:00')

      return(false);

   TimeToStruct(time_current,STimeCurrent);

   if((InpStartHour*60*60+InpStartMinute*60)<(InpEndHour*60*60+InpEndMinute*60)) // intraday time interval

     {

      /*

      Example:

      input uchar    InpStartHour      = 5;        // Start hour

      input uchar    InpEndHour        = 10;       // End hour

      0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15 16 17 18 19 20 21 22 23 0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15

      _  _  _  _  _  +  +  +  +  +  _  _  _  _  _  _  _  _  _  _  _  _  _  _  _  _  _  _  _  +  +  +  +  +  _  _  _  _  _  _

      */

      if((STimeCurrent.hour*60*60+STimeCurrent.min*60>=InpStartHour*60*60+InpStartMinute*60) &&

         (STimeCurrent.hour*60*60+STimeCurrent.min*60<InpEndHour*60*60+InpEndMinute*60))

         return(true);

     }

   else

      if((InpStartHour*60*60+InpStartMinute*60)>(InpEndHour*60*60+InpEndMinute*60)) // time interval with the transition in a day

        {

         /*

         Example:

         input uchar    InpStartHour      = 10;       // Start hour

         input uchar    InpEndHour        = 5;        // End hour

         0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15 16 17 18 19 20 21 22 23 0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15

         _  _  _  _  _  _  _  _  _  _  +  +  +  +  +  +  +  +  +  +  +  +  +  +  +  +  +  +  +  _  _  _  _  _  +  +  +  +  +  +

         */

         if(STimeCurrent.hour*60*60+STimeCurrent.min*60>=InpStartHour*60*60+InpStartMinute*60 ||

            STimeCurrent.hour*60*60+STimeCurrent.min*60<InpEndHour*60*60+InpEndMinute*60)

            return(true);

        }

      else

         return(false);

//---

   return(false);

  }

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

//| Calculate all positions                                          |

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

int CalculateAllPositions()

  {

   int total=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_position.Symbol()==m_symbol.Name() && m_position.Magic()==InpMagic)

            total++;

//---

   return(total);

  }

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

//| Profit all positions                                             |

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

double ProfitAllPositions(void)

  {

   double profit=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_position.Symbol()==m_symbol.Name() && m_position.Magic()==InpMagic)

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

//---

   return(profit);

  }

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

Similar scripts

iMACD Martin 2

iMACD Martin

iStochastic Increase Position Volume

Martingale Oscillator

Dynamic averaging

VIDYA N Bars Borders Martingale

iSAR Pending Stop 2

Close all positions

iADX Grid

MACD Four Colors 2 Martingale

iMACD Max Lot

Comments

Markdown supported. Formatting help

Markdown Formatting Guide

Element Markdown Syntax
Heading # H1
## H2
### H3
Bold **bold text**
Italic *italicized text*
Link [title](https://www.example.com)
Image ![alt text](image.jpg)
Code `code`
Code Block ```
code block
```
Quote > blockquote
Unordered List - Item 1
- Item 2
Ordered List 1. First item
2. Second item
Horizontal Rule ---