Fast Pending Orders-v1.1

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

//|                                      Fast Pending Orders.mq5     |

//|                                 Copyright © 2020, behzad.mvr     |

//|                                         Behzad.mvr@gmail.com     |

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



#property script_show_inputs



// Set riskPercent=0 if you want to use riskAmount

enum definePendingType

  {

   BuyStop=1,//Buy Stop

   BuyLimit=2,//Buy Limit

   SellStop=-1,//Sell Stop

   SellLimit=-2,//Sell Limit

   None=0,// Not Defined!

  };

  

input string firstRun="----- Set in First script run -----"; // -----------------------------------

input definePendingType pendingType=0; //Type of Pending Order

input string secondRun="----- Set in Second script run -----"; // -----------------------------------

input double riskPercent=2; //Risk Percent (%)

input double riskAmount=0; //Risk Amount ($)

input int TotalOrders=1; //Number of Pending Orders

input double minLot=0.01;  //Minimum Lot Allowed by Broker to open Orders

int Slipage=0;   //Max order slipage(deviation) (points)

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

//|                                                                  |

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



ulong  magic=0;

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

//|                                                                  |

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

int OnStart()

  {

   if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))

     {

      Alert("Check if automated trading is allowed in the terminal settings.");

      return(0);

     }

   if(riskPercent!=0 && riskAmount!=0)

     {

      Alert("Set one of the risk parameters=0 to other parameter works.");

      return(0);

     }

   if(riskPercent==0 && riskAmount==0)

     {

      Alert("Don't set both of risk parameters = 0");

      return(0);

     }

   int totalOrders=TotalOrders;

   double orderPrice=0,sl=0;

   double lots=0;

   double price=SymbolInfoDouble(Symbol(),SYMBOL_BID);

   double TP=0,SL=0;

   double equity=AccountInfoDouble(ACCOUNT_EQUITY);

   double tick=SymbolInfoDouble(_Symbol,SYMBOL_TRADE_TICK_VALUE);

   double maxLoss=0;

   if(riskPercent!=0)

      maxLoss=(riskPercent/100)*equity;

   else

      if(riskAmount!=0)

         maxLoss=riskAmount;



   ENUM_ORDER_TYPE orderType=-1;



   MqlTradeRequest request;

   MqlTradeResult  result;

   int total=OrdersTotal();



   double volume=0;

   ulong  order_ticket=0;

   int minLotCnt=0;

   for(int i=0; i<total; i++)

     {

      //--- parameters of the order

      order_ticket=OrderGetTicket(i);// ticket of the order

      string order_symbol=OrderGetString(ORDER_SYMBOL); // symbol

      volume=OrderGetDouble(ORDER_VOLUME_CURRENT);    // volume of the order

      if(order_symbol!=_Symbol || volume!=minLot)

         continue;

      minLotCnt++;

      int    digits=(int)SymbolInfoInteger(order_symbol,SYMBOL_DIGITS); // number of decimal places

      magic=OrderGetInteger(ORDER_MAGIC); // MagicNumber of the order

      orderPrice=OrderGetDouble(ORDER_PRICE_OPEN);

      sl=OrderGetDouble(ORDER_SL);  // Stop Loss of the order

      if(sl==0)

        {

         Alert("Please Set the StopLoss!");

         return(0);

        }

      orderType=(ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);  // type of the order

     }

   if(minLotCnt==0 && pendingType==0)

     {

     // Alert("First set a "+DoubleToString(minLot,2)+" pending order for "+_Symbol);

      Alert("Please set Type of Pending Order parameter in inputs window.");

      return(0);

     }

   if(minLotCnt>1)

     {

      Alert("There must be only one "+DoubleToString(minLot,2)+" lot pending order for "+_Symbol);

      return(0);

     }

   if(minLotCnt==1)

     {

      double usedLoss=0;

      if(orderType==ORDER_TYPE_BUY_STOP || orderType==ORDER_TYPE_BUY_LIMIT)

        {

         double ask=SymbolInfoDouble(Symbol(),SYMBOL_ASK);

         usedLoss=minLot*(ask-sl)*tick/_Point;

         for(int k=1; k<=totalOrders; k++)

           {

            if(maxLoss<k*usedLoss)

              {

               totalOrders=k-1;

               Alert("There is only enough risked eguity to split pending order into "+IntegerToString(k-1)+" order.");

               break;

              }

           }

         if(totalOrders==0)

            return(0);

         TP=orderPrice+(orderPrice-sl);

         lots=NormalizeDouble((maxLoss/((orderPrice-sl)*tick/_Point)/totalOrders),2);

         for(int i=0; i<totalOrders; i++)

           {

            sendOrder(orderType,orderPrice,sl,TP,lots,"");

            TP=TP+50*_Point;

           }

        }

      //----

      if(orderType==ORDER_TYPE_SELL_STOP || orderType==ORDER_TYPE_SELL_LIMIT)

        {

         double bid=SymbolInfoDouble(Symbol(),SYMBOL_BID);

         usedLoss=minLot*(bid-sl)*tick/_Point;

         for(int k=1; k<=totalOrders; k++)

           {

            if(maxLoss<k*usedLoss)

              {

               totalOrders=k-1;

               Alert("There is only enough risked eguity to split pending order into "+IntegerToString(k-1)+" order.");

               break;

              }

           }

         if(totalOrders==0)

            return(0);

         TP=orderPrice-(sl-orderPrice);

         lots=NormalizeDouble((maxLoss/((sl-orderPrice)*tick/_Point)/totalOrders),2);

         for(int i=0; i<totalOrders; i++)

           {

            sendOrder(orderType,orderPrice,sl,TP,lots,"");

            TP=TP-50*_Point;

           }

        }

      deletePendingOrder(order_ticket);

     }

   else

      if(minLotCnt==0)

        {

         if(pendingType==1)

           {

            orderPrice=price+200*_Point;

            SL=orderPrice-100*_Point;

            TP=orderPrice+100*_Point;

            lots=minLot;

            sendOrder(ORDER_TYPE_BUY_STOP,orderPrice,SL,TP,lots,"");

           }

         if(pendingType==2)

           {

            orderPrice=price-200*_Point;

            SL=orderPrice-100*_Point;

            TP=orderPrice+100*_Point;

            lots=minLot;

            sendOrder(ORDER_TYPE_BUY_LIMIT,orderPrice,SL,TP,lots,"");

           }

         if(pendingType==-1)

           {

            orderPrice=price-200*_Point;

            SL=orderPrice+100*_Point;

            TP=orderPrice-100*_Point;

            lots=minLot;;

            sendOrder(ORDER_TYPE_SELL_STOP,orderPrice,SL,TP,lots,"");

           }

         if(pendingType==-2)

           {

            orderPrice=price+200*_Point;

            SL=orderPrice+100*_Point;

            TP=orderPrice-100*_Point;

            lots=minLot;;

            sendOrder(ORDER_TYPE_SELL_LIMIT,orderPrice,SL,TP,lots,"");

           }

        }

   return(0);

  }

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



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

//|                                                                  |

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

uint sendOrder(ENUM_ORDER_TYPE orderType,double Price,double SL,double TP,double Volume,string comment)

  {

//--- prepare a request

   MqlTradeRequest request= {0};

   request.action=TRADE_ACTION_PENDING;

   request.type=orderType;

   request.magic=magic;

   request.symbol=_Symbol;

   request.volume=Volume;

   request.sl=NormalizeDouble(SL,_Digits);

   request.tp=NormalizeDouble(TP,_Digits);

   request.deviation=Slipage;

   request.comment=comment;

//  request.type_filling=GetFilling(request.symbol);

   request.price=NormalizeDouble(Price,_Digits);

   request.expiration=TimeCurrent()+PeriodSeconds(PERIOD_CURRENT)*10;

//--- send a trade request

   MqlTradeResult result= {0};

   bool success=OrderSend(request,result);

   if(!success)

     {

      Alert(_Symbol," Error in order send: ",orderType," ",result.retcode," lots= ",Volume," Price= ",Price," SL= ",SL," request.type= ",request.type," TP= ",TP);

     }

//--- return code of the trade server reply

   return result.retcode;

  }

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

//|                                                                  |

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



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

//|                                                                  |

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

void deletePendingOrder(ulong ticket)

  {

//--- declare and initialize the trade request and result of trade request

   MqlTradeRequest request= {0};

   MqlTradeResult  result= {0};

   int total=OrdersTotal(); // total number of placed pending orders

//--- iterate over all placed pending orders

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

     {

      ulong  order_ticket=OrderGetTicket(i);                   // order ticket

      ulong  exmagic=OrderGetInteger(ORDER_MAGIC);

      string order_symbol=OrderGetString(ORDER_SYMBOL);              // MagicNumber of the order

      //--- if the MagicNumber matches

      if(exmagic==magic && order_symbol==Symbol() && (order_ticket==ticket || ticket==0))

        {

         //--- zeroing the request and result values

         ZeroMemory(request);

         ZeroMemory(result);

         //--- setting the operation parameters

         request.action=TRADE_ACTION_REMOVE;                   // type of trade operation

         request.order = order_ticket;                         // order ticket

         //--- send the request

         if(!OrderSend(request,result))

            PrintFormat("deletePOrderSend error %d",GetLastError());  // if unable to send the request, output the error code

         //--- information about the operation

         PrintFormat("deletePretcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);

        }

     }

  }

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