MT4 EA converted to a cBot

160 USD  Payment method:  Direct Payment
Closed

I would like the following MT4 code to be converted to a cBot:-

 

//+------------------------------------------------------------------+
//+                           Code generated using FxPro Quant 2.1.4 |
//+------------------------------------------------------------------+
#property strict

#define __STRATEGY_MAGIC 1001000000
#define __SLEEP_AFTER_EXECUTION_FAIL 400


struct InputsStr
  {
   string            _Currency;       // Symbol
   string            _TimeFrame;      // TimeFrame
   string               _Slowing;       // Slowing
   string               _Whole_Number_Input;       // Period
   string               _Grid_Points;       // Grid Points
   string            _SL_Percentage;       // SL Percentage
   string               _RSI_Buy_Limit;         // RSI Buy Limit
   string               _Sell_TP_in_Points;       // Sell TP in Points
   string               _Max_Days;        // Max Days
   string               _Stoc_Buy_Limit;        // Stoc Buy Limit
   string            _Mom_Buy_Limit;       // Mom Buy Limit
   string               _D_Period;         // D Period
   string               _Stoc_Sell_Limit;       // Stoc Sell Limit
   string               _RSI_Sell_Limit;        // RSI Sell Limit
   string            _Mom_Sell_Limit;        // Mom Sell Limit
   string               _Buy_TP_in_Points;        // Buy TP in Points
   string               _Max_Open_Trades;        // Max Open Trades
   string            _Lot_Percentage;       // Lot Percentage
  };
struct Inputs
  {
   string            _Currency;       // Symbol
   string            _TimeFrame;      // TimeFrame
   int               _Slowing;       // Slowing
   int               _Whole_Number_Input;       // Period
   int               _Grid_Points;       // Grid Points
   double            _SL_Percentage;       // SL Percentage
   int               _RSI_Buy_Limit;         // RSI Buy Limit
   int               _Sell_TP_in_Points;       // Sell TP in Points
   int               _Max_Days;        // Max Days
   int               _Stoc_Buy_Limit;        // Stoc Buy Limit
   double            _Mom_Buy_Limit;       // Mom Buy Limit
   int               _D_Period;         // D Period
   int               _Stoc_Sell_Limit;       // Stoc Sell Limit
   int               _RSI_Sell_Limit;        // RSI Sell Limit
   double            _Mom_Sell_Limit;        // Mom Sell Limit
   int               _Buy_TP_in_Points;        // Buy TP in Points
   int               _Max_Open_Trades;        // Max Open Trades
   double            _Lot_Percentage;       // Lot Percentage
  };

//Default Input variables
string _Currency ;
int  _TimeFrame;
int _Slowing;
int _Whole_Number_Input;
int _Grid_Points ;
double _SL_Percentage ;
int _RSI_Buy_Limit ;
int _Sell_TP_in_Points;
int _Max_Days ;
int _Stoc_Buy_Limit ;
double _Mom_Buy_Limit;
int _D_Period;
int _Stoc_Sell_Limit;
int _RSI_Sell_Limit ;
double _Mom_Sell_Limit;
int _Buy_TP_in_Points;
int _Max_Open_Trades ;
double _Lot_Percentage;

//Global declaration
double _Momentum;
double _Stochastic_3;
double _RSI;
bool _Compare_7;
bool _Compare_10;
bool _Compare_1;
bool _Compare_9;
bool _Compare_11;
double _Arithmetic;
bool _Compare_12;
bool _Compare_2;


Inputs inputsAct[] ;
InputsStr inputs[];

// Global Variables
input string _FileName="MRS14.csv" ; // Input File
input int    _GlobalMaxOrders=20;

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int init()
  {
   if(ReadCSVFile())
     {
      if(ArraySize(inputsAct)<=0)
         return INIT_FAILED;
     }
   else
     {
      return INIT_FAILED ;
     }
   return(0);
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {

   for(int i=0; i<ArraySize(inputsAct); i++)
     {
      SetSettings(inputsAct[i]._Currency);
      //Local declaration
      bool _Close_Position_1 = false;
      bool _Sell = false;
      bool _Buy = false;
      bool _Buy_2 = false;
      bool _Sell_2 = false;
      _Momentum = iMomentum(_Currency,_TimeFrame, _Whole_Number_Input, 0, 0);
      _Stochastic_3 = iStochastic(_Currency, _TimeFrame, _Whole_Number_Input, _D_Period, _Slowing, 0, 0, 0, 0);
      _RSI = iRSI(_Currency, _TimeFrame, _Whole_Number_Input,0, 0);

      _Compare_7 = (_RSI > _RSI_Sell_Limit);
      _Compare_10 = (_Momentum > _Mom_Sell_Limit);
      _Compare_1 = (_RSI < _RSI_Buy_Limit);
      _Compare_9 = (_Momentum < _Mom_Buy_Limit);
      _Compare_11 = (Number_of_Open_Trades(1,_Currency) < _Max_Open_Trades);
      _Arithmetic = ((_Grid_Points *
                      (-1)) *
                     (Number_of_Open_Trades(1,_Currency)));
      _Compare_12 = (_Stochastic_3 > _Stoc_Sell_Limit);
      _Compare_2 = (_Stochastic_3 < _Stoc_Buy_Limit);


      if((__OpenTime(1, _Currency) + 24*60*60 * (_Max_Days) < TimeCurrent()))
        {
         _Close_Position_1 = __isOpenedPosition(1, _Currency);
         if(_Close_Position_1)
           {
            int ticket = OrderTicket();
            int type = OrderType();
            double lots = OrderLots();
            string sym = OrderSymbol();
            _Close_Position_1 = OrderClose(ticket, lots, MarketInfo(sym, MODE_BID) + MarketInfo(sym, MODE_SPREAD) * MarketInfo(sym, MODE_POINT) * (type==1 ? 1:0), 0);
           }
        }

      if(GetGlobalOrders()>=_GlobalMaxOrders)
         return 0 ;

      if(((_Compare_7 &&
           (_Compare_12 &&
            !__selectOrderBySymbol(_Currency))) &&
          _Compare_10))
          
         _Sell = Sell(_Currency,1, ((_Lot_Percentage *
                           (AccountFreeMargin())) /
                          (100000)), 0, ((AccountFreeMargin() /
                                          ((100 /
                                            (_SL_Percentage)))) /
                                         (((_Lot_Percentage *
                                            (AccountFreeMargin())) /
                                           (100000)))), 0, _Sell_TP_in_Points, 5, _Max_Open_Trades, 0, "");

      if((((_Compare_2 &&
            !__selectOrderBySymbol(_Currency)) &&
           _Compare_1) &&
          _Compare_9))
          
         _Buy = Buy(_Currency,1, ((_Lot_Percentage *
                         (AccountFreeMargin())) /
                        (100000)), 0, ((AccountFreeMargin() /
                                        ((100 /
                                          (_SL_Percentage)))) /
                                       (((_Lot_Percentage *
                                          (AccountFreeMargin())) /
                                         (100000)))), 0, _Buy_TP_in_Points, 5, _Max_Open_Trades, 0, "");


      if((((((__selectOrderBySymbol(_Currency) &&
              ((_Arithmetic < 0) &&
               (__ProfitPoints(1, _Currency) < _Arithmetic))) &&
             _Compare_11) &&
            _Compare_2) &&
           _Compare_1) &&
          _Compare_9))
          
         _Buy_2 = Buy(_Currency,1, ((_Lot_Percentage *
                           (AccountFreeMargin())) /
                          (100000)), 0, ((AccountFreeMargin() /
                                          ((100 /
                                            (_SL_Percentage)))) /
                                         (((_Lot_Percentage *
                                            (AccountFreeMargin())) /
                                           (100000)))), 0, _Buy_TP_in_Points, 5, _Max_Open_Trades, 0, "");

      if((((((__selectOrderBySymbol(_Currency) &&
              ((_Arithmetic < 0) &&
               (__ProfitPoints(1, _Currency) < _Arithmetic))) &&
             _Compare_11) &&
            _Compare_12) &&
           _Compare_7) &&
          _Compare_10))
         _Sell_2 = Sell(_Currency,1, ((_Lot_Percentage *
                             (AccountFreeMargin())) /
                            (100000)), 0, ((AccountFreeMargin() /
                                            ((100 /
                                              (_SL_Percentage)))) /
                                           (((_Lot_Percentage *
                                              (AccountFreeMargin())) /
                                             (100000)))), 0, _Sell_TP_in_Points, 5, _Max_Open_Trades, 0, "");
     }


   return(0);
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool __selectOrderBySymbol(string symbol)
  {
   for(int i = 0; i < OrdersTotal(); i++)
     {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES) && OrderSymbol() == symbol)
         return(true);
     }
   return(false);
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool __selectOrderByMagic(int magic, string symbol)
  {
   for(int i = 0; i < OrdersTotal(); i++)
     {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES) && OrderMagicNumber() == __STRATEGY_MAGIC + magic && OrderSymbol() == symbol)
         return(true);
     }
   return(false);
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
datetime __OpenTime(int magic, string symbol)
  {
   if(!__selectOrderByMagic(magic, symbol))
      return(0);
   return(OrderOpenTime());
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double __ProfitPoints(int magic, string symbol)
  {
   if(!__selectOrderByMagic(magic, symbol))
      return(0);
   if(OrderType() == OP_BUY)
      return ((MarketInfo(OrderSymbol(),MODE_BID) - OrderOpenPrice())/MarketInfo(OrderSymbol(),MODE_POINT));
   else
      if(OrderType() == OP_SELL)
         return ((OrderOpenPrice() - (MarketInfo(OrderSymbol(),MODE_ASK)))/MarketInfo(OrderSymbol(),MODE_POINT));
   return (0);
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool __isOpenedPosition(int magic, string symbol)
  {
   if(!__selectOrderByMagic(magic, symbol))
      return(false);
   return(OrderType()==OP_BUY || OrderType()==OP_SELL);
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int __Ticket(int magic, string symbol)
  {
   if(!__selectOrderByMagic(magic, symbol))
      return(0);
   return(OrderTicket());
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Number_of_Open_Trades(int MagicIndex, string symbol)
  {
   int res = 0;
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(!OrderSelect(i, SELECT_BY_POS))
         continue;
      if(OrderMagicNumber() != __STRATEGY_MAGIC + MagicIndex || OrderSymbol() != symbol)
         continue;
      res ++;
     }
   return (res);
  }


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool Sell(string symbol ,int MagicIndex, double Lots, int StopLossMethod, double StopLossPoints, int TakeProfitMethod, double TakeProfitPoints, int Slippage, int MaxOpenTrades,
          int MaxFrequencyMins, string TradeComment)
  {
   int digits=(int)MarketInfo(symbol,MODE_DIGITS);
   double points=MarketInfo(symbol,MODE_POINT);
   double bid=MarketInfo(symbol,MODE_BID);
   double ask=MarketInfo(symbol,MODE_ASK);
   
   static double pipSize = 0;
   if(pipSize == 0)
      pipSize = points * (1 + 9 * (digits == 3 || digits == 5));

   double sl = 0, tp = 0;
   double stopLossPoints = 0, takeProfitPoints = 0;

   int numberOfOpenTrades = 0;

   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(!OrderSelect(i, SELECT_BY_POS))
         continue;
      if(OrderMagicNumber() != __STRATEGY_MAGIC + MagicIndex || OrderSymbol() != symbol)
         continue;
      numberOfOpenTrades ++;
     }

   if(MaxOpenTrades > 0 && numberOfOpenTrades >= MaxOpenTrades)
      return(false);

   if(MaxFrequencyMins  > 0)
     {
      int recentSeconds = MaxFrequencyMins * 60;

      for(int i=OrdersTotal()-1; i>=0; i--)
        {
         if(!OrderSelect(i, SELECT_BY_POS))
            continue;
         if(OrderMagicNumber() != __STRATEGY_MAGIC + MagicIndex || OrderSymbol() !=symbol)
            continue;
         if(TimeCurrent() - OrderOpenTime() < recentSeconds)
            return(false);
        }

      int hstTotal=OrdersHistoryTotal();

      for(int i=hstTotal-1; i>=0; i--)
        {
         if(!OrderSelect(i,SELECT_BY_POS,MODE_HISTORY))
            continue;
         if(OrderMagicNumber() != __STRATEGY_MAGIC + MagicIndex || OrderSymbol() != symbol)
            continue;
         if(TimeCurrent() - OrderOpenTime() < recentSeconds)
            return(false);
         break;
        }
     }

   if(Lots < MarketInfo(symbol,MODE_MINLOT))
      return(false);

   if(AccountFreeMarginCheck(symbol, OP_SELL,Lots) <= 0)
     {
      Print("Sell order error: insufficient capital");
      return(false);
     }

   if(StopLossPoints > 0)
     {
      if(StopLossMethod == 0)
        {
         sl = NormalizeDouble(bid + StopLossPoints * points, digits);
         stopLossPoints = StopLossPoints;
        }
      else
         if(StopLossMethod == 1)
           {
            sl = NormalizeDouble(bid + StopLossPoints * pipSize, digits);
            stopLossPoints = StopLossPoints * (1 + 9 * (digits == 3 || digits == 5));
           }
         else
           {
            sl = StopLossPoints;
            stopLossPoints = (sl - bid)/points;
           }
     }

   if(TakeProfitPoints > 0)
     {
      if(TakeProfitMethod == 0)
        {
         tp = NormalizeDouble(bid - TakeProfitPoints * points, digits);
         takeProfitPoints = TakeProfitPoints;
        }
      else
         if(TakeProfitMethod == 1)
           {
            tp = NormalizeDouble(bid - TakeProfitPoints * pipSize, digits);
            takeProfitPoints = TakeProfitPoints * (1 + 9 * (digits == 3 || digits == 5));
           }
         else
           {
            tp = TakeProfitPoints;
            takeProfitPoints = (bid - tp)/Point;
           }
     }

   double stopLevel = MarketInfo(symbol,MODE_STOPLEVEL) + MarketInfo(symbol,MODE_SPREAD);

   if((sl > 0 && stopLossPoints <= stopLevel) || (tp > 0 && takeProfitPoints <= stopLevel))
     {
      Print("Cannot Sell: Stop loss and take profit must be at least "
            + DoubleToStr(MarketInfo(symbol,MODE_STOPLEVEL) + MarketInfo(symbol,MODE_SPREAD),0)
            + " points away from the current price");
      return (false);
     }

   RefreshRates();
   int result = OrderSend(symbol, OP_SELL, Lots, bid, Slippage, sl, tp, "FxProQuant" + "(" + WindowExpertName() + ") " + TradeComment,__STRATEGY_MAGIC + MagicIndex);

   if(result == -1)
     {
      Print("Failed to Sell: " + IntegerToString(GetLastError()));
      Sleep(__SLEEP_AFTER_EXECUTION_FAIL);
      return(false);
     }

   return(true);
  }


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool Buy(string symbol ,int MagicIndex, double Lots, int StopLossMethod, double StopLossPoints, int TakeProfitMethod, double TakeProfitPoints, int Slippage, int MaxOpenTrades,
         int MaxFrequencyMins, string TradeComment)
  {
    int digits=(int)MarketInfo(symbol,MODE_DIGITS);
   double points=MarketInfo(symbol,MODE_POINT);
   double bid=MarketInfo(symbol,MODE_BID);
   double ask=MarketInfo(symbol,MODE_ASK);
   
   static double pipSize = 0;
   if(pipSize == 0)
      pipSize = points * (1 + 9 * (digits == 3 || digits == 5));

   double sl = 0, tp = 0;
   double stopLossPoints = 0, takeProfitPoints = 0;

   int numberOfOpenTrades = 0;

   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(!OrderSelect(i, SELECT_BY_POS))
         continue;
      if(OrderMagicNumber() != __STRATEGY_MAGIC + MagicIndex || OrderSymbol() != symbol)
         continue;
      numberOfOpenTrades ++;
     }

   if(MaxOpenTrades > 0 && numberOfOpenTrades >= MaxOpenTrades)
      return(false);

   if(MaxFrequencyMins  > 0)
     {
      int recentSeconds = MaxFrequencyMins * 60;

      for(int i=OrdersTotal()-1; i>=0; i--)
        {
         if(!OrderSelect(i, SELECT_BY_POS))
            continue;
         if(OrderMagicNumber() != __STRATEGY_MAGIC + MagicIndex || OrderSymbol() != symbol)
            continue;
         if(TimeCurrent() - OrderOpenTime() < recentSeconds)
            return(false);
        }

      int hstTotal=OrdersHistoryTotal();

      for(int i=hstTotal-1; i>=0; i--)
        {
         if(!OrderSelect(i,SELECT_BY_POS,MODE_HISTORY))
            continue;
         if(OrderMagicNumber() != __STRATEGY_MAGIC + MagicIndex || OrderSymbol() !=symbol)
            continue;
         if(TimeCurrent() - OrderOpenTime() < recentSeconds)
            return(false);
         break;
        }
     }

   if(Lots < MarketInfo(symbol,MODE_MINLOT))
      return(false);

   if(AccountFreeMarginCheck(symbol, OP_SELL,Lots) <= 0)
     {
      Print("Buy error: insufficient capital");
      return(false);
     }

   if(StopLossPoints > 0)
     {
      if(StopLossMethod == 0)
        {
         sl = NormalizeDouble(ask - StopLossPoints * points, digits);
         stopLossPoints = StopLossPoints;
        }
      else
         if(StopLossMethod == 1)
           {
            sl = NormalizeDouble(ask - StopLossPoints * pipSize, digits);
            stopLossPoints = StopLossPoints * (1 + 9 * (digits == 3 || digits == 5));
           }
         else
           {
            sl  = StopLossPoints;
            stopLossPoints = (ask - sl)/Point;
           }
     }

   if(TakeProfitPoints > 0)
     {
      if(TakeProfitMethod == 0)
        {
         tp = NormalizeDouble(ask + TakeProfitPoints * points, digits);
         takeProfitPoints = TakeProfitPoints;
        }
      else
         if(TakeProfitMethod == 1)
           {
            tp = NormalizeDouble(ask + TakeProfitPoints * pipSize, digits);
            takeProfitPoints = TakeProfitPoints * (1 + 9 * (digits == 3 || digits == 5));
           }
         else
           {
            tp = TakeProfitPoints;
            takeProfitPoints = (tp - ask)/Point;
           }
     }

   double stopLevel = MarketInfo(symbol,MODE_STOPLEVEL) + MarketInfo(symbol,MODE_SPREAD);

   if((sl > 0 && stopLossPoints <= stopLevel) || (tp > 0 && takeProfitPoints <= stopLevel))
     {
      Print("Cannot Buy: Stop loss and take profit must be at least "
            + DoubleToStr(MarketInfo(symbol,MODE_STOPLEVEL) + MarketInfo(symbol,MODE_SPREAD),0)
            + " points away from the current price");
      return (false);
     }

   RefreshRates();
   int result = OrderSend(symbol, OP_BUY, Lots, ask, Slippage, sl, tp, "FxProQuant" + "(" + WindowExpertName() + ") " + TradeComment, __STRATEGY_MAGIC + MagicIndex);

   if(result == -1)
     {
      Print("Failed to Buy: " + IntegerToString(GetLastError()));
      Sleep(__SLEEP_AFTER_EXECUTION_FAIL);
      return(false);
     }

   return(true);
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool ReadCSVFile()
  {
   if(!FileIsExist(_FileName))
      return false ;

   int handle=FileOpen(_FileName,FILE_CSV|FILE_READ,";") ;
   int line=0;
   if(handle!=INVALID_HANDLE)
     {
      while(!FileIsEnding(handle))
        {
         ArrayResize(inputs,line+1);
         inputs[line]._Currency=FileReadString(handle);
         inputs[line]._TimeFrame=FileReadString(handle);
         inputs[line]._Slowing=FileReadString(handle);
         inputs[line]._Whole_Number_Input=FileReadString(handle);
         inputs[line]._Grid_Points=FileReadString(handle);
         inputs[line]._SL_Percentage=FileReadString(handle);
         inputs[line]._RSI_Buy_Limit=FileReadString(handle);
         inputs[line]._Sell_TP_in_Points=FileReadString(handle);
         inputs[line]._Max_Days=FileReadString(handle);
         inputs[line]._Stoc_Buy_Limit=FileReadString(handle);
         inputs[line]._Mom_Buy_Limit=FileReadString(handle);
         inputs[line]._D_Period=FileReadString(handle);
         inputs[line]._Stoc_Sell_Limit=FileReadString(handle);
         inputs[line]._RSI_Sell_Limit=FileReadString(handle); ;
         inputs[line]._Mom_Sell_Limit=FileReadString(handle);
         inputs[line]._Buy_TP_in_Points=FileReadString(handle);
         inputs[line]._Max_Open_Trades=FileReadString(handle);
         inputs[line]._Lot_Percentage=FileReadString(handle);
         line++ ;
        }
      FileClose(handle);
     }
   else
     {
      return false ;
     }

   ArrayResize(inputsAct,ArraySize(inputs)-1);
   for(int i=0; i<ArraySize(inputsAct); i++)
     {
      inputsAct[i]._Currency=inputs[i+1]._Currency;
      inputsAct[i]._TimeFrame=inputs[i+1]._TimeFrame;
      inputsAct[i]._Slowing=(int)inputs[i+1]._Slowing;
      inputsAct[i]._Whole_Number_Input=(int)inputs[i+1]._Whole_Number_Input;
      inputsAct[i]._Grid_Points=(int)inputs[i+1]._Grid_Points;
      inputsAct[i]._SL_Percentage=StringToDouble(inputs[i+1]._SL_Percentage);
      inputsAct[i]._RSI_Buy_Limit=(int)inputs[i+1]._RSI_Buy_Limit;
      inputsAct[i]._Sell_TP_in_Points=(int)inputs[i+1]._Sell_TP_in_Points;
      inputsAct[i]._Max_Days=(int)inputs[i+1]._Max_Days;
      inputsAct[i]._Stoc_Buy_Limit=(int)inputs[i+1]._Stoc_Buy_Limit;
      inputsAct[i]._Mom_Buy_Limit=StringToDouble(inputs[i+1]._Mom_Buy_Limit);
      inputsAct[i]._D_Period=(int)inputs[i+1]._D_Period;
      inputsAct[i]._Stoc_Sell_Limit=(int)inputs[i+1]._Stoc_Sell_Limit;
      inputsAct[i]._RSI_Sell_Limit=(int)inputs[i+1]._RSI_Sell_Limit;
      inputsAct[i]._Mom_Sell_Limit=StringToDouble(inputs[i+1]._Mom_Sell_Limit);
      inputsAct[i]._Buy_TP_in_Points=(int)inputs[i+1]._Buy_TP_in_Points;
      inputsAct[i]._Max_Open_Trades=(int)inputs[i+1]._Max_Open_Trades;
      inputsAct[i]._Lot_Percentage=StringToDouble(inputs[i+1]._Lot_Percentage) ;
     }
   return true ;
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int StringToTimeFrame(string tf)
  {
   if(tf=="M1")
      return PERIOD_M1 ;
   else
      if(tf=="M5")
         return PERIOD_M5 ;
      else
         if(tf=="M15")
            return PERIOD_M15 ;
         else
            if(tf=="M30")
               return PERIOD_M30 ;
            else
               if(tf=="H1")
                  return PERIOD_H1 ;
               else
                  if(tf=="H4")
                     return PERIOD_H4 ;
                  else
                     if(tf=="D1")
                        return PERIOD_D1 ;
                     else
                        if(tf=="W1")
                           return PERIOD_W1 ;
                        else
                           if(tf=="MN1")
                              return PERIOD_MN1 ;

   return PERIOD_CURRENT ;
  }


//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void SetSettings(string symbol)
  {
   bool found=false ;
   for(int i=0; i<ArraySize(inputsAct); i++)
     {
      if(inputsAct[i]._Currency==symbol)
        {
         _Currency=inputsAct[i]._Currency ;
         _TimeFrame=StringToTimeFrame(inputsAct[i]._TimeFrame);
         _Slowing = inputsAct[i]._Slowing;
         _Whole_Number_Input = inputsAct[i]._Whole_Number_Input;
         _Grid_Points = inputsAct[i]._Grid_Points;
         _SL_Percentage = inputsAct[i]._SL_Percentage;
         _RSI_Buy_Limit = inputsAct[i]._RSI_Buy_Limit;
         _Sell_TP_in_Points = inputsAct[i]._Sell_TP_in_Points;
         _Max_Days = inputsAct[i]._Max_Days;
         _Stoc_Buy_Limit = inputsAct[i]._Stoc_Buy_Limit;
         _Mom_Buy_Limit = inputsAct[i]._Mom_Buy_Limit;
         _D_Period = inputsAct[i]._D_Period;
         _Stoc_Sell_Limit = inputsAct[i]._Stoc_Sell_Limit;
         _RSI_Sell_Limit = inputsAct[i]._RSI_Sell_Limit;
         _Mom_Sell_Limit = inputsAct[i]._Mom_Sell_Limit;
         _Buy_TP_in_Points = inputsAct[i]._Buy_TP_in_Points;
         _Max_Open_Trades = inputsAct[i]._Max_Open_Trades;
         _Lot_Percentage =inputsAct[i]._Lot_Percentage;
         found=true ;
         break ;
        }
      else
        {
         continue ;
        }
     }

   if(!found)
     {
      _Currency=symbol;
      _TimeFrame=PERIOD_CURRENT ; // Trading TimeFrame
      _Slowing = 3;       // Slowing
      _Whole_Number_Input = 10;       // Period
      _Grid_Points = 200;       // Grid Points
      _SL_Percentage = 1;       // SL Percentage
      _RSI_Buy_Limit = 25;         // RSI Buy Limit
      _Sell_TP_in_Points = 300;       // Sell TP in Points
      _Max_Days = 14;        // Max Days
      _Stoc_Buy_Limit = 15;        // Stoc Buy Limit
      _Mom_Buy_Limit = 99.5;       // Mom Buy Limit
      _D_Period = 3;         // D Period
      _Stoc_Sell_Limit = 85;       // Stoc Sell Limit
      _RSI_Sell_Limit = 75;        // RSI Sell Limit
      _Mom_Sell_Limit = 100.5;        // Mom Sell Limit
      _Buy_TP_in_Points = 300;        // Buy TP in Points
      _Max_Open_Trades = 6;        // Max Open Trades
      _Lot_Percentage = 0.5;       // Lot Percentage
     }
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int GetGlobalOrders()
  {
   int cnt=0 ;
   for(int i=0; i<OrdersTotal(); i++)
     {
      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber()==__STRATEGY_MAGIC+1)
         cnt ++;
     }
   return cnt ;
  }
//+------------------------------------------------------------------+
 

I am working on Metatrader 4 and 5 since 5 years ago.

I have experience with Programming more than 10 years.

I have worked on similar projects to what you are looking for.

I will respect and implement your needs from day one.

I set the client priority always on top for my work

If you are not satisfied with my work, you may not pay for it.
 

I want $250 for this job.

my skype id:   stephan_rothe79@outlook.com