local_hedging_bot_copier_in_mt5/client/localHedgingClientCopierMt5.mq5

//+------------------------------------------------------------------+
//|                                  localHedgingClientCopierMt5.mq5 |
//|                                  Copyright 2025, MetaQuotes Ltd. |
//|                                  https://www.mqldevelopment.com/ |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mqldevelopment.com/"
#property version   "1.00"
#define orderCount 2000
#define count1 50
#define testCounter 50
#define MaxOrders 20000
#define daysOfTradesToAdd 20
#include <Trade\Trade.mqh>
CTrade trade;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+

struct historyTradesClientSide
  {
   ulong             ticket;
   ulong             magic;
                     historyTradesClientSide()
     {
      ticket = -1;
      magic  = 0;
     }
  };
historyTradesClientSide historyTradeStore[MaxOrders];

struct order
  {
   ulong             ticket;
   double            price;
   datetime          opentime;
   string            symbol;
   int               ordertype;
   double            lots;
   double            stoploss;
   double            takeprofit;
   double            accountBalance;
   int               contractSize;
   string            comments;
   int               magicNo;
                     order()
     {
      ticket =-1;
     }
  };

struct clientOrder
  {
   ulong             ticket;
   double            price;
   datetime          opentime;
   string            symbol;
   int               ordertype;
   double            lots;
   double            stoploss;
   double            takeprofit;
   ulong             magic;
   string            comments;
   double            masterLot;
                     clientOrder()
     {
      ticket=-1;
      price=-1;
      symbol=Symbol();
      ordertype=-1;
      lots=0;
      masterLot=0;
      stoploss=0;
      takeprofit=0;
      magic=0;
      comments="";
     }
  };
clientOrder cod[orderCount];

struct masterOrder
  {
   datetime          opentime;
   string            symbol;
   ulong             ordertype;
   double            price;
   double            lots;
   double            stoploss;
   double            takeprofit;
   ulong             ticket;

   int               magic;
   double            accountBalance;
   int               contractSize;
   string            comment;


                     masterOrder()
     {
      ticket=-1;
      price=-1;
      symbol=Symbol();
      ordertype=-1;
      lots=0;
      stoploss=0;
      takeprofit=0;
     }
  };
masterOrder mod1[orderCount];

enum lot_option
  {
   fix, //Fixed Lot
   mul, //Multiplied Lot
   Balance, // Balance Base Multiplier
   slaveLotCal,
  };
enum tradeCopy_type
  {
   buy,//Buy Only
   sell,//Sell Only
   buySell,//Buy and Sell
  };
enum operation_code
  {
   Master,  //Master
   Client,   //Client
  };

sinput       string                  string_0                  = "<><><><><><> General SETTINGS <><><><><><>";   //__
input        int                     slip                     = 5;               // Master Order Variation in Pips
input        int                     sec                      = 10;              // Master Order Expired After Seconds
input        tradeCopy_type          tradeType                = buySell;         // Trades To Copy
input        lot_option              lotoption                = fix;             // Lot Option
input        double                  mult                     = 1.0;             // Multiplier (for Client)
input        double                  fixed                    = 0.1;             // Fixed Lot (for Client)
input        double                  Bmult                    = 1;               // Balance Multiplier (for Client)
input        double                  recoveryAmount           = 3000;            // Recovery Amount (for Client Lot)
input        double                  maxDd                    = 8000;            // Max DrawDown (for Client Lot)
input        string                  suffix                   = "";              // Suffix
input        string                  symbolExclude            = "";              // Symbol to Exclude
input        string                  prefix                   = "";              // Prefix

// Heart Beat
sinput       string                  string_1                  = "<><><><><><> HeartBeat Setting <><><><><><>";   //__
input        string                  clientServer             = "";              // Master Server
input        string                  mappingSymbol            = "GOLD,XAUUSD;bitcoin,BTCUSD"; // Mapping Pairs Inp,Out;Inp,Out
input        string                  localApiKey              = "U2FsdGVkX18vBY4H1uzQiZwuh8B++8VBtCGJ3yGr2XPII0qCodmfuhjssKu5oug1J4e97bkwPtDQLi4py1OODQ=="; // Local API Key
input        string                  localHB_req_link         = "http://localhost/api/slastConnected"; // Request Link For LastConnected

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
//Global Variable
int gmtDifference = 0;
int filehandle;
// Heart Beat
long lastFileSize=0;
datetime lastModified=0;
bool       contractChk   = true;//Contract Checking
bool doReversal = true; // Reverse Trades
bool fileLastEmpty=false;
long accountNumber=AccountInfoInteger(ACCOUNT_LOGIN);
int counter=0,testCounterVar=0;
order order_array[];
datetime lastModified1=0;
long lastFileSize1=0;
bool fileHandlerIssue=false;
operation_code mode1=Client;  //Working code
int OnInit()
  {
//---
   accountNumber=AccountInfoInteger(ACCOUNT_LOGIN);
   EventSetMillisecondTimer(20);
   if(!ObjectFind(0,"mode") || ObjectGetString(0,"mode",OBJPROP_TEXT,0)!=EnumToString(mode1)+" Account")
     {
      ObjectDelete(0,"mode");
      ObjectCreate(0,"mode",OBJ_LABEL,0,0,0);
      ObjectSetInteger(0,"mode",OBJPROP_XDISTANCE,10);
      ObjectSetInteger(0,"mode",OBJPROP_YDISTANCE,25);
      ObjectSetInteger(0,"mode",OBJPROP_CORNER,CORNER_RIGHT_UPPER);
      ObjectSetInteger(0,"mode",OBJPROP_ANCHOR,ANCHOR_RIGHT_UPPER);
      ObjectSetInteger(0,"mode",OBJPROP_COLOR,clrLightBlue);
      ObjectSetString(0,"mode",OBJPROP_TEXT,EnumToString(mode1)+" Account");
      ObjectSetInteger(0,"mode",OBJPROP_FONTSIZE,14);
     }
   gmtDifference = (int)TimeCurrent() - (int)TimeGMT();
   Print("GMT Difference(sec): ",gmtDifference);
   mapHistory();
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   EventKillTimer();
   ObjectsDeleteAll(0,0,-1);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---

  }
//+------------------------------------------------------------------+
void OnTimer()
  {
   gmtDifference = (int)TimeCurrent() - (int)TimeGMT();
   read_history_file();

   readData();
   writeDataClientCof();
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void writeDataClientCof()
  {
   int fileHandleClientCof;

   if(PositionsTotal()==0 && OrdersTotal()==0 && !fileLastEmpty && TerminalInfoInteger(TERMINAL_CONNECTED))
     {
      fileHandleClientCof = FileOpen("COF_client.csv", FILE_WRITE|FILE_CSV|FILE_COMMON);
      if(fileHandleClientCof != INVALID_HANDLE)
        {
         Print("Writing file to empty");
         FileWrite(fileHandleClientCof, "");
         FileClose(fileHandleClientCof);
         fileLastEmpty = true;
         emptyStruct();
        }
      else
        {
         Print(" Client Cof File handler issue:", GetLastError());
        }
     }
   else
     {
      bool updationReq = checkOrderUpdate();
      if(updationReq || fileHandlerIssue)
        {
         Print(" ------------------------------- Client Cof Start ------------------------------------------ ");
         fileHandleClientCof = FileOpen("COF_client.csv", FILE_WRITE|FILE_CSV|FILE_COMMON);
         if(fileHandleClientCof != INVALID_HANDLE)
           {
            fileHandlerIssue = false;

            for(int i = PositionsTotal()-1; i >= 0; i--)
              {
               ulong ticket = PositionGetTicket(i);
               if(PositionSelectByTicket(ticket))
                 {
                  //if(((useMinimumLot && (PositionGetDouble(POSITION_VOLUME) > minimumLot)) || !useMinimumLot) &&
                  //   ((useMaximumLot && (PositionGetDouble(POSITION_VOLUME) < maximumLot)) || !useMaximumLot))
                    {
                     string time   = TimeToString(PositionGetInteger(POSITION_TIME)-gmtDifference, TIME_DATE|TIME_SECONDS);
                     string symbol = PositionGetString(POSITION_SYMBOL);
                     double digits = getDoubleSymbolInfo(symbol,"digits");

                     if(suffix != "")
                        symbol = StringSubstr(symbol, 0, StringFind(symbol, suffix, 0));
                     if(prefix != "")
                        StringReplace(symbol, prefix, "");

                     long   orderType = PositionGetInteger(POSITION_TYPE);
                     double takeProfit = PositionGetDouble(POSITION_TP);
                     double stopLoss   = PositionGetDouble(POSITION_SL);

                     if(doReversal)
                       {
                        if(orderType == POSITION_TYPE_BUY)
                           orderType = POSITION_TYPE_SELL;
                        else
                           if(orderType == POSITION_TYPE_SELL)
                              orderType = POSITION_TYPE_BUY;

                        takeProfit = PositionGetDouble(POSITION_SL);
                        stopLoss   = PositionGetDouble(POSITION_TP);
                       }

                     string OrderToWrite =
                        time + "," +
                        symbol + "," +
                        IntegerToString(orderType) + "," +
                        DoubleToString(PositionGetDouble(POSITION_PRICE_OPEN),(int)digits) + "," +
                        DoubleToString(PositionGetDouble(POSITION_VOLUME),2) + "," +
                        DoubleToString(stopLoss,(int)digits) + "," +
                        DoubleToString(takeProfit,(int)digits) + "," +
                        IntegerToString(PositionGetInteger(POSITION_TICKET)) + "," +
                        IntegerToString(PositionGetInteger(POSITION_MAGIC)) + "," +
                        (string)AccountInfoDouble(ACCOUNT_BALANCE) + "," +
                        (string)SymbolInfoDouble(PositionGetString(POSITION_SYMBOL), SYMBOL_TRADE_CONTRACT_SIZE) +
                        PositionGetString(POSITION_COMMENT) + "\r\n";

                     FileWrite(fileHandleClientCof, OrderToWrite);
                    }
                 }
              }

            for(int i = OrdersTotal()-1; i >= 0; i--)
              {
               ulong ticket = OrderGetTicket(i);
               if(OrderSelect(ticket))
                 {
                  //if(((useMinimumLot && (OrderGetDouble(ORDER_VOLUME_CURRENT) > minimumLot)) || !useMinimumLot) &&
                  //   ((useMaximumLot && (OrderGetDouble(ORDER_VOLUME_CURRENT) < maximumLot)) || !useMaximumLot))
                    {
                     string time   = TimeToString(OrderGetInteger(ORDER_TIME_SETUP)-gmtDifference, TIME_DATE|TIME_SECONDS);
                     string symbol = OrderGetString(ORDER_SYMBOL);
                     double digits = getDoubleSymbolInfo(symbol,"digits");

                     if(suffix != "")
                        symbol = StringSubstr(symbol, 0, StringFind(symbol, suffix, 0));
                     if(prefix != "")
                        StringReplace(symbol, prefix, "");

                     long   orderType = OrderGetInteger(ORDER_TYPE);
                     double takeProfit = OrderGetDouble(ORDER_TP);
                     double stopLoss   = OrderGetDouble(ORDER_SL);

                     if(doReversal)
                       {
                        if(orderType == ORDER_TYPE_BUY_STOP)
                           orderType = ORDER_TYPE_SELL_LIMIT;
                        else
                           if(orderType == ORDER_TYPE_SELL_STOP)
                              orderType = ORDER_TYPE_BUY_LIMIT;
                           else
                              if(orderType == ORDER_TYPE_BUY_LIMIT)
                                 orderType = ORDER_TYPE_SELL_STOP;
                              else
                                 if(orderType == ORDER_TYPE_SELL_LIMIT)
                                    orderType = ORDER_TYPE_BUY_STOP;

                        takeProfit = OrderGetDouble(ORDER_SL);
                        stopLoss   = OrderGetDouble(ORDER_TP);
                       }

                     string OrderToWrite =
                        time + "," +
                        symbol + "," +
                        IntegerToString(orderType) + "," +
                        DoubleToString(OrderGetDouble(ORDER_PRICE_OPEN),(int)digits) + "," +
                        DoubleToString(OrderGetDouble(ORDER_VOLUME_CURRENT),2) + "," +
                        DoubleToString(stopLoss,(int)digits) + "," +
                        DoubleToString(takeProfit,(int)digits) + "," +
                        IntegerToString(OrderGetInteger(ORDER_TICKET)) + "," +
                        IntegerToString(OrderGetInteger(ORDER_MAGIC)) + "," +
                        (string)AccountInfoDouble(ACCOUNT_BALANCE) + "," +
                        (string)SymbolInfoDouble(OrderGetString(ORDER_SYMBOL), SYMBOL_TRADE_CONTRACT_SIZE) +
                        OrderGetString(ORDER_COMMENT) + "\r\n";

                     Print("Client Cof Writing Pending Order Block.");
                     FileWrite(fileHandleClientCof, OrderToWrite);
                    }
                 }
              }

            FileClose(fileHandleClientCof);
            fileLastEmpty = false;
            Print("Client Cof File Updated:", TimeCurrent());
           }
         else
           {
            Print("Client Cof File Handle Issue:", GetLastError());
           }
         Print(" ------------------------------- Client Cof End ------------------------------------------ ");
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool checkOrderUpdate()
  {
   bool updationRequired=false,currCheck=false;
   for(int i = PositionsTotal()-1 ; i >= 0 ; i--)
     {
      ulong ticket = PositionGetTicket(i);
      if(PositionSelectByTicket(ticket))
        {
         int orderIndex=-1;
         bool alreadyAdded=isOrderThere(ticket, orderIndex);
         if(!alreadyAdded)
           {
            currCheck=false;
            currCheck=addOrderMaster(ticket, "Market");
            if(!updationRequired)
               updationRequired=currCheck;
           }
         else
           {
            if(orderIndex!=-1)
              {
               currCheck=false;
               currCheck=IsOrderChanged(PositionGetInteger(POSITION_TICKET),orderIndex, "Market");
               if(!updationRequired)
                 {
                  updationRequired=currCheck;
                 }
              }
           }
        }
     }


   for(int i = OrdersTotal()-1 ; i >= 0 ; i--)
     {
      ulong ticket = OrderGetTicket(i);
      if(OrderSelect(ticket))
        {
         if(OrderGetInteger(ORDER_TYPE) != ORDER_TYPE_BUY && OrderGetInteger(ORDER_TYPE) != ORDER_TYPE_SELL && OrderGetInteger(ORDER_TYPE) != ORDER_TYPE_CLOSE_BY)
           {
            int orderIndex=-1;
            bool alreadyAdded=isOrderThere(ticket, orderIndex);
            if(!alreadyAdded)
              {
               Print("Inside pending Adding to master order: ",ticket," type: ",OrderGetInteger(ORDER_TYPE)," ",OrdersTotal()," ",ORDER_TYPE_CLOSE_BY);
               currCheck=false;
               currCheck=addOrderMaster(ticket, "Pending");
               if(!updationRequired)
                  updationRequired=currCheck;
              }
            else
              {
               if(orderIndex!=-1)
                 {
                  currCheck=false;

                  currCheck=IsOrderChanged(OrderGetInteger(ORDER_TICKET), orderIndex, "Pending");
                  if(!updationRequired)
                    {
                     updationRequired=currCheck;
                    }
                 }
              }
           }
        }
     }

   for(int i=0; i<ArraySize(mod1); i++)
     {
      bool isPresent=false;
      if(mod1[i].ticket !=-1)
        {
         for(int j = PositionsTotal()-1; j>=0; j--)
           {
            ulong ticket = PositionGetTicket(j);
            if(PositionSelectByTicket(ticket))
              {
               if(ticket==mod1[i].ticket)
                 {
                  isPresent=true;
                  break;
                 }
              }
           }
         // Pending Order
         for(int j = OrdersTotal()-1; j>=0; j--)
           {
            ulong ticket = OrderGetTicket(j);
            if(OrderSelect(ticket))
              {
               if(ticket==mod1[i].ticket)
                 {
                  isPresent=true;
                  break;
                 }
              }
           }

         if(!isPresent)
           {
            Print("Ticket is closed so removed from struct: ",mod1[i].ticket);
            mod1[i].ticket=-1;
            mod1[i].price=-1;
            mod1[i].symbol="";
            mod1[i].ordertype=-1;
            mod1[i].lots=0;
            mod1[i].stoploss=0;
            mod1[i].takeprofit=0;
            currCheck=true;
            //currCheck=clearStructIndex(mod1[i].ticket);
            if(!updationRequired)
               updationRequired=currCheck;
           }
        }
     }
   return updationRequired;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool IsOrderChanged(ulong orderTicket, int index, string calledBy)
  {
   if(mod1[index].ticket!=-1)
     {
      if(calledBy == "Market")
        {

         if(PositionSelectByTicket(orderTicket))
           {
            //Digits
            double digits=getDoubleSymbolInfo(PositionGetString(POSITION_SYMBOL),"digits");

            double tp=NormalizeDouble(PositionGetDouble(POSITION_TP), (int)digits),
                   sl=NormalizeDouble(PositionGetDouble(POSITION_SL),(int)digits),
                   lot=NormalizeDouble(PositionGetDouble(POSITION_VOLUME),2);

            if(mod1[index].takeprofit!=tp || mod1[index].stoploss != sl || mod1[index].lots!=lot || mod1[index].ordertype!=PositionGetInteger(POSITION_TYPE) || mod1[index].price != PositionGetDouble(POSITION_PRICE_OPEN))
              {
               Print(" Inside IsOrderChanged() ",mod1[index].lots," lot: ",lot," calledBy: ",calledBy," mod1 ticket ",mod1[index].ticket," orderTicket: ",orderTicket);
               // Time
               datetime time = (datetime)(PositionGetInteger(POSITION_TIME) - gmtDifference);
               mod1[index].opentime=time;
               mod1[index].lots=lot;
               mod1[index].stoploss=sl;
               mod1[index].takeprofit=tp;
               mod1[index].comment=PositionGetString(POSITION_COMMENT);
               mod1[index].ordertype=PositionGetInteger(POSITION_TYPE);
               mod1[index].price=PositionGetDouble(POSITION_PRICE_OPEN);
               return true;
              }

           }
        }
      if(calledBy == "Pending")
        {
         if(OrderSelect(orderTicket))
           {
            double digits=getDoubleSymbolInfo(OrderGetString(ORDER_SYMBOL),"digits");

            double tp=NormalizeDouble(OrderGetDouble(ORDER_TP), (int)digits),
                   sl=NormalizeDouble(OrderGetDouble(ORDER_SL),(int)digits),
                   lot=NormalizeDouble(OrderGetDouble(ORDER_VOLUME_CURRENT),2);

            if(mod1[index].takeprofit!=tp || mod1[index].stoploss != sl || mod1[index].lots!=lot || mod1[index].ordertype!=OrderGetInteger(ORDER_TYPE) || mod1[index].price != OrderGetDouble(ORDER_PRICE_OPEN))
              {
               //time
               datetime time = (datetime)(OrderGetDouble(ORDER_PRICE_OPEN) - gmtDifference);
               mod1[index].opentime=time;
               mod1[index].lots=lot;
               mod1[index].stoploss=sl;
               mod1[index].takeprofit=tp;
               mod1[index].comment=OrderGetString(ORDER_COMMENT);
               mod1[index].ordertype=OrderGetInteger(ORDER_TYPE);
               mod1[index].price=OrderGetDouble(ORDER_PRICE_OPEN);
               return true;
              }
           }
        }
     }
   return false;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool addOrderMaster(ulong ticket, string calledBy)
  {
   for(int i=0; i<ArraySize(mod1); i++)
     {
      if(mod1[i].ticket==-1)
        {

         if(calledBy == "Market")
           {
            //ulong ticket = PositionGetTicket(orderTicket);
            if(PositionSelectByTicket(ticket))
              {
               //Symbol Updation
               string symbol=PositionGetString(POSITION_SYMBOL);
               if(suffix!="")
                  symbol = StringSubstr(symbol,0,StringFind(PositionGetString(POSITION_SYMBOL),suffix,0));
               if(prefix!="")
                  StringReplace(symbol,prefix,"");

               //Digits
               double digits=getDoubleSymbolInfo(PositionGetString(POSITION_SYMBOL),"digits");

               //time
               datetime time = (datetime)(PositionGetInteger(POSITION_TIME)-gmtDifference);

               mod1[i].opentime=time;
               mod1[i].symbol=symbol;
               mod1[i].ordertype=PositionGetInteger(POSITION_TYPE);
               mod1[i].price=NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN),(int)digits);
               mod1[i].lots=NormalizeDouble(PositionGetDouble(POSITION_VOLUME),2);
               mod1[i].stoploss=NormalizeDouble(PositionGetDouble(POSITION_SL),(int)digits);
               mod1[i].takeprofit=NormalizeDouble(PositionGetDouble(POSITION_TP),(int)digits);
               mod1[i].ticket=PositionGetInteger(POSITION_TICKET);
               mod1[i].magic=(int)PositionGetInteger(POSITION_MAGIC);
               mod1[i].comment=PositionGetString(POSITION_COMMENT);
               Print("Ticket:",PositionGetInteger(POSITION_TICKET)," stored in index:",i);
               return true;
              }
           }
         if(calledBy == "Pending")
           {
            if(OrderSelect(ticket))
              {
               string symbol = OrderGetString(ORDER_SYMBOL);
               if(suffix!="")
                  symbol = StringSubstr(symbol,0,StringFind(OrderGetString(ORDER_SYMBOL),suffix,0));
               if(prefix!="")
                  StringReplace(symbol,prefix,"");

               //Digits
               double digits=getDoubleSymbolInfo(OrderGetString(ORDER_SYMBOL),"digits");

               //time
               datetime time = (datetime)(OrderGetInteger(ORDER_TIME_SETUP) - gmtDifference);

               mod1[i].opentime=time;
               mod1[i].symbol=symbol;
               mod1[i].ordertype=OrderGetInteger(ORDER_TYPE);
               mod1[i].price=NormalizeDouble(OrderGetDouble(ORDER_PRICE_OPEN),(int)digits);
               mod1[i].lots=NormalizeDouble(OrderGetDouble(ORDER_VOLUME_CURRENT),2);
               mod1[i].stoploss=NormalizeDouble(OrderGetDouble(ORDER_SL),(int)digits);
               mod1[i].takeprofit=NormalizeDouble(OrderGetDouble(ORDER_TP),(int)digits);
               mod1[i].ticket=OrderGetInteger(ORDER_TICKET);
               mod1[i].magic=(int)OrderGetInteger(ORDER_MAGIC);
               mod1[i].comment=OrderGetString(ORDER_COMMENT);
               Print("Ticket: ",OrderGetInteger(ORDER_TICKET)," stored in index by pending order:",i);
               return true;
              }
           }
        }
     }
   return false;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void readData()
  {
   if(EnumToString(mode1)=="Client")
     {
      filehandle=FileOpen("COF.csv",FILE_SHARE_READ|FILE_CSV|FILE_COMMON|FILE_READ|FILE_ANSI|FILE_TXT|FILE_COMMON);
      if(filehandle!=INVALID_HANDLE)
        {

         datetime lastFileModified=(datetime)FileGetInteger(filehandle,FILE_MODIFY_DATE);
         long fileSize=FileGetInteger(filehandle,FILE_SIZE);
         int a= 0;
         if(lastModified==lastFileModified && fileSize==lastFileSize) // lastModified==lastFileModified && fileSize==lastFileSize
           {
            FileClose(filehandle);
            if(counter>=count1 && TerminalInfoInteger(TERMINAL_CONNECTED))
              {
               if(testCounterVar==testCounter)
                 {
                  testCounterVar=0;
                 }
               adminHeartBeat();
               counter=0;

              }
            counter++;
            testCounterVar++;
           }
         else
           {
            clearOrderArray();
            while(!FileIsEnding(filehandle))
              {
               string OrderToRead = FileReadString(filehandle);
               string Order_specs [];
               StringSplit(OrderToRead,StringGetCharacter(",",0),Order_specs);
               Print("Array Size: ", ArraySize(Order_specs));
               if(ArraySize(Order_specs) == 11 || ArraySize(Order_specs) == 12)
                 {
                  string symbol = getSymbol(Order_specs[1]);//prefix+Order_specs[1]+suffix;
                  int orderType=StringToInteger(Order_specs[2]);
                  if(StringFind(symbol,symbolExclude,0) < 0  &&
                     (((orderType==POSITION_TYPE_BUY||orderType==ORDER_TYPE_BUY_STOP ||orderType==ORDER_TYPE_SELL_STOP)&& (tradeType==0||tradeType==2)) ||
                      ((orderType==POSITION_TYPE_SELL||orderType==ORDER_TYPE_BUY_LIMIT ||orderType==ORDER_TYPE_SELL_LIMIT)&& (tradeType==1||tradeType==2)))
                    )
                    {
                     order_array[ArraySize(order_array)-1].symbol = symbol;
                     order_array[ArraySize(order_array)-1].opentime = StringToTime(Order_specs[0]);
                     order_array[ArraySize(order_array)-1].price = StringToDouble(Order_specs[3]);
                     order_array[ArraySize(order_array)-1].ordertype = StringToInteger(Order_specs[2]);
                     order_array[ArraySize(order_array)-1].lots = StringToDouble(Order_specs[4]);
                     order_array[ArraySize(order_array)-1].stoploss = StringToDouble(Order_specs[5]);
                     order_array[ArraySize(order_array)-1].takeprofit = StringToDouble(Order_specs[6]);
                     order_array[ArraySize(order_array)-1].ticket = StringToInteger(Order_specs[7]);
                     //Saving master order ticket to order magic number
                     order_array[ArraySize(order_array)-1].magicNo = StringToInteger(Order_specs[7]);
                     order_array[ArraySize(order_array)-1].accountBalance=StringToDouble(Order_specs[9]);
                     order_array[ArraySize(order_array)-1].contractSize=StringToInteger(Order_specs[10]);

                     if(ArraySize(Order_specs) == 12)
                        order_array[ArraySize(order_array)-1].comments=Order_specs[11];
                     else
                        order_array[ArraySize(order_array)-1].comments="";

                     if(ArraySize(Order_specs) == 12)
                       {
                        StringReplace(Order_specs[11],"from #","");
                        StringReplace(Order_specs[11]," ","");

                        Print(" Order_specs[11] ",Order_specs[11]," order_array[ArraySize(order_array)-1].ticket ",order_array[ArraySize(order_array)-1].ticket);

                        for(int l=0; l<orderCount; l++)
                          {
                           if(cod[l].magic == int(Order_specs[11]))
                             {
                              cod[l].magic = order_array[ArraySize(order_array)-1].ticket;
                             }
                          }
                       }


                     Print(" Symbol: ",order_array[ArraySize(order_array)-1].symbol,"Open Price: ",order_array[ArraySize(order_array)-1].price," Lot: ",  order_array[ArraySize(order_array)-1].lots,"OPen time: ",order_array[ArraySize(order_array)-1].opentime);
                     ArrayResize(order_array,ArraySize(order_array)+1);
                     addToMarketWatch(symbol);
                    }
                 }
              }

            lastModified=lastFileModified;
            lastFileSize=fileSize;
            FileClose(filehandle);
           }
         int arraySize=ArraySize(order_array);
         if(ArraySize(order_array) == 1) //
           {
            if(PositionsTotal() > 0)
              {
               for(int i=PositionsTotal()-1; i>=0; i--)
                 {
                  ulong ticket = PositionGetTicket(i);
                  if(PositionSelectByTicket(ticket))
                    {
                     if(history_ticket_present(PositionGetInteger(POSITION_MAGIC)))
                        if(!trade.PositionClose(ticket))
                          {
                           Print(" Order Close Error on No Master Trade: "+IntegerToString(GetLastError()));
                          }
                        else
                           Print(" ------------- Order Close by empty array ------------------ ");
                    }
                 }
              }
            if(OrdersTotal() > 0)
              {
               for(int i=OrdersTotal()-1; i>=0; i--)
                 {
                  ulong ticket = OrderGetTicket(i);
                  if(OrderSelect(ticket))
                    {
                     if(history_ticket_present(OrderGetInteger(ORDER_MAGIC)))
                        if(!trade.OrderDelete(ticket))
                          {
                           Print(" Error in Deleting Pending Order (Empty Array) : "+IntegerToString(GetLastError()));
                          }
                        else
                           Print("Order Close by empty array (Empty Array)");
                    }
                 }
              }
            deleteAllArray();
           }
         else
           {
            for(int i=0; i<ArraySize(order_array); i++)
              {
               //Print(" ------------------------------------------  Ticket: ", order_array[ArraySize(order_array)-1].ticket, " Magic Number: ", order_array[ArraySize(order_array)-1].magicNo, " Array Size: ", ArraySize(order_array), " Index: ", i);
               int trade_taken = 2;
               int partialCloseOrderPosition=-1;
               for(int j=0; j<orderCount; j++)
                 {
                  //if(OrderSelect(cod[j].ticket,SELECT_BY_POS))
                  if(cod[j].ticket!=-1)
                    {
                     if(cod[j].magic==order_array[i].ticket)
                       {
                        trade_taken = 0;
                       }
                     if(cod[j].magic==order_array[i].ticket)
                       {
                        if(cod[j].masterLot != order_array[i].lots)
                          {
                           Print(" Cod Lot Size: ", cod[j].masterLot, " Order Array Lot: ", order_array[i].lots);
                           Print("Order is partial close:",cod[j].magic);
                           trade_taken=1;
                           partialCloseOrderPosition=j;
                          }
                       }
                    }
                 }
               if(order_array[i].ticket != -1)
                 {
                  if(trade_taken==1)
                    {
                     //current order need to close partially
                     if(partialCloseOrderPosition!=-1)
                       {
                        bool isOrderClose=false;
                        if(cod[partialCloseOrderPosition].masterLot <= 0)
                          {
                           Print("Error: Invalid masterLot for partial close");
                           continue;
                          }
                        //if(OrderSelect(partialCloseOrderPosition,SELECT_BY_TICKET))
                          {
                           Print("Master lot: ",order_array[i].lots," last save lot: ",cod[partialCloseOrderPosition].masterLot);
                           double lotClosePer = NormalizeDouble(100 - (order_array[i].lots/cod[partialCloseOrderPosition].masterLot*100),2);
                           Print("Order in master is closed in percentage: ",lotClosePer," last client lot: ",cod[partialCloseOrderPosition].lots);
                           double closeLot=NormalizeDouble(lotClosePer/100 *cod[partialCloseOrderPosition].lots,2);
                           Print("Close lot in client: ",closeLot);
                           if(!trade.PositionClosePartial(cod[partialCloseOrderPosition].ticket,closeLot))
                             {
                              Print("Partial order did not close:",cod[partialCloseOrderPosition].ticket);
                             }
                           else
                             {
                              isOrderClose=true;
                              cod[partialCloseOrderPosition].lots=cod[partialCloseOrderPosition].lots-closeLot; //PositionGetDouble(POSITION_VOLUME);
                              cod[partialCloseOrderPosition].masterLot = order_array[i].lots;
                             }
                          }
                       }
                    }
                  else
                     if(trade_taken == 2)
                       {
                        int diff1=((int)TimeCurrent()-(int)order_array[i].opentime)-gmtDifference;// ,diff2=TimeSeconds(TimeCurrent()-order_array[i].opentime);
                        if(diff1 <= sec)
                          {
                           Print("Symbol: ",order_array[i].opentime,"  ",diff1," <= ",sec);
                           trade.SetExpertMagicNumber(IntegerToString(order_array[i].ticket));
                           trade.SetDeviationInPoints(10);
                           trade.SetTypeFilling(ORDER_FILLING_IOC);
                           trade.LogLevel(LOG_LEVEL_ALL);
                           trade.SetAsyncMode(false);
                           if(order_array[i].ordertype == ORDER_TYPE_BUY)
                             {
                              double tempSlip=MathAbs(order_array[i].price- SymbolInfoDouble(order_array[i].symbol,SYMBOL_ASK))/SymbolInfoDouble(order_array[i].symbol,SYMBOL_POINT);
                              if((MathAbs(order_array[i].price-SymbolInfoDouble(order_array[i].symbol,SYMBOL_ASK))/SymbolInfoDouble(order_array[i].symbol,SYMBOL_POINT)) <= slip*10)
                                {
                                 double lotsize = getLotSize(order_array[i].symbol, order_array[i].accountBalance, order_array[i].lots, order_array[i].contractSize);
                                 double Stoploss=0.0;
                                 double ask=NormalizeDouble(SymbolInfoDouble(order_array[i].symbol,SYMBOL_ASK),(int)SymbolInfoInteger(order_array[i].symbol,SYMBOL_DIGITS));

                                 if(trade.PositionOpen(order_array[i].symbol,ORDER_TYPE_BUY,lotsize,ask,order_array[i].stoploss,order_array[i].takeprofit,""))
                                   {
                                    if(addOrderMaster(trade.ResultOrder(),order_array[i].ticket,order_array[i].lots, "Market"))
                                      {
                                       Print(" Buy Order Ticket:",trade.ResultOrder()," Stored!!!");
                                      }
                                    else
                                      {
                                       //Print("Order Ticket is not stotred: ",trade.ResultOrder()," Error is: ", GetLastError());
                                      }
                                   }
                                 else
                                   {

                                    Print("Copy Buy Order Send Error: "+IntegerToString(GetLastError()));
                                   }
                                }
                             }
                           if(order_array[i].ordertype == ORDER_TYPE_SELL)
                             {
                              if((MathAbs(order_array[i].price-SymbolInfoDouble(order_array[i].symbol,SYMBOL_BID))/SymbolInfoDouble(order_array[i].symbol,SYMBOL_POINT)) <= slip*10)
                                {
                                 double lotsize = getLotSize(order_array[i].symbol, order_array[i].accountBalance, order_array[i].lots, order_array[i].contractSize);
                                 double Stoploss=0.0;

                                 double bid=NormalizeDouble(SymbolInfoDouble(order_array[i].symbol,SYMBOL_BID),(int)SymbolInfoInteger(order_array[i].symbol,SYMBOL_DIGITS));

                                 if(trade.PositionOpen(order_array[i].symbol,ORDER_TYPE_SELL,lotsize,bid,order_array[i].stoploss,order_array[i].takeprofit,""))
                                   {
                                    if(addOrderMaster(trade.ResultOrder(),order_array[i].ticket,order_array[i].lots, "Market"))
                                      {
                                       Print(" Sell Order Ticket:",trade.ResultOrder()," Stored!!!");
                                      }
                                   }
                                 else
                                   {
                                    Print("Copy Buy Order Send Error: "+IntegerToString(GetLastError()));
                                   }
                                }
                             }
                           if(order_array[i].ordertype == ORDER_TYPE_BUY_STOP)
                             {
                              // Not Checking Slippage
                              double lotsize = getLotSize(order_array[i].symbol, order_array[i].accountBalance, order_array[i].lots, order_array[i].contractSize);

                              if(trade.BuyStop(lotsize, order_array[i].price, order_array[i].symbol, order_array[i].stoploss, order_array[i].takeprofit, 0, 0, ""))
                                {
                                 if(addOrderMaster(trade.ResultOrder(),order_array[i].ticket,order_array[i].lots, "Pending"))
                                   {
                                    Print("Order Ticket Buy Stop:",trade.ResultOrder()," Stored!!!");
                                   }
                                }
                              else
                                {
                                 Print("Error in Order Buy Stop Order: "+Symbol()+"  ",GetLastError());
                                }
                             }

                           if(order_array[i].ordertype == ORDER_TYPE_SELL_STOP)
                             {
                              double lotsize = getLotSize(order_array[i].symbol, order_array[i].accountBalance, order_array[i].lots, order_array[i].contractSize);

                              if(trade.SellStop(lotsize, order_array[i].price, order_array[i].symbol, order_array[i].stoploss, order_array[i].takeprofit, 0, 0, ""))
                                {
                                 if(addOrderMaster(trade.ResultOrder(),order_array[i].ticket,order_array[i].lots, "Pending"))
                                   {
                                    Print("Order Ticket Sell Stop:",trade.ResultOrder()," Stored!!!");
                                   }
                                }
                              else
                                {
                                 Print("Error in Order Sell Stop Order: "+Symbol()+"  ",GetLastError());
                                }
                             }

                           if(order_array[i].ordertype == ORDER_TYPE_BUY_LIMIT)
                             {
                              double lotsize = getLotSize(order_array[i].symbol, order_array[i].accountBalance, order_array[i].lots, order_array[i].contractSize);

                              if(trade.BuyLimit(lotsize, order_array[i].price, order_array[i].symbol, order_array[i].stoploss, order_array[i].takeprofit, 0, 0, ""))
                                {
                                 if(addOrderMaster(trade.ResultOrder(),order_array[i].ticket,order_array[i].lots, "Pending"))
                                   {
                                    Print("Order Ticket Buy Limit:",trade.ResultOrder()," Stored!!!");
                                   }
                                }
                              else
                                {
                                 Print("Error in Order Buy Limit: "+Symbol()+"  ",GetLastError());
                                }
                             }

                           if(order_array[i].ordertype == ORDER_TYPE_SELL_LIMIT)
                             {
                              double lotsize = getLotSize(order_array[i].symbol, order_array[i].accountBalance, order_array[i].lots, order_array[i].contractSize);

                              if(trade.SellLimit(lotsize, order_array[i].price, order_array[i].symbol, order_array[i].stoploss, order_array[i].takeprofit, 0, 0, ""))
                                {
                                 if(addOrderMaster(trade.ResultOrder(),order_array[i].ticket,order_array[i].lots, "Pending"))
                                   {
                                    Print("Order Ticket Sell Limit: ",trade.ResultOrder()," Stored!!! ", " Tp: ", order_array[i].takeprofit, " Sl: ", order_array[i].stoploss);
                                   }
                                }
                              else
                                {
                                 Print("Error in Order Sell Limit: "+Symbol()+"  ",GetLastError());
                                }
                             }
                          }
                       }
                 }
              }

            for(int i=0; i<orderCount; i++)
              {
               bool trade_close = true;
               if(PositionSelectByTicket(cod[i].ticket))
                 {
                  for(int j=0; j<ArraySize(order_array); j++)
                    {
                     if(cod[i].magic == (order_array[j].ticket))
                       {
                        int digitss = getDoubleSymbolInfo(PositionGetString(POSITION_SYMBOL), "digits");
                        trade_close = false;
                        // if(PositionGetDouble(POSITION_TP)!=order_array[j].takeprofit || PositionGetDouble(POSITION_SL)!=order_array[j].stoploss)
                        if(NormalizeDouble(cod[i].takeprofit, digitss) != order_array[j].takeprofit || NormalizeDouble(cod[i].stoploss, digitss) != order_array[j].stoploss)
                          {
                           if(trade.PositionModify(PositionGetInteger(POSITION_TICKET),order_array[j].stoploss,order_array[j].takeprofit))
                             {
                              Print("Order modified ticket:",PositionGetInteger(POSITION_TICKET));
                              cod[i].takeprofit=order_array[j].takeprofit;
                              cod[i].stoploss=order_array[j].stoploss;
                             }
                           else
                             {
                              Print("Order not modified error:",GetLastError());
                             }
                          }
                       }
                    }
                  if(trade_close == true)
                    {
                     if(PositionGetInteger(POSITION_TYPE)== ORDER_TYPE_BUY)
                       {
                        if(!trade.PositionClose(PositionGetInteger(POSITION_TICKET)))
                          {
                           Print("Buy Order Close Error on Master Trade Close: "+IntegerToString(GetLastError()));
                          }
                        else
                          {
                           Print("Order close by no master copy of trade");
                           cod[i].ticket=-1;
                          }
                       }
                     if(PositionGetInteger(POSITION_TYPE)== ORDER_TYPE_SELL)
                       {
                        if(!trade.PositionClose(PositionGetInteger(POSITION_TICKET)))
                          {
                           Print("Sell Order Close Error on Master Trade Close: "+IntegerToString(GetLastError()));
                          }
                        else
                          {
                           Print("Order close by no master copy of trade");
                           cod[i].ticket=-1;
                          }
                       }
                    }
                 }

               if(OrderSelect(cod[i].ticket))
                 {
                  for(int j=0; j<ArraySize(order_array); j++)
                    {
                     if(cod[i].magic == (order_array[j].ticket))
                       {

                        trade_close = false;
                        if(OrderGetDouble(ORDER_TP)!=order_array[j].takeprofit || OrderGetDouble(ORDER_SL)!=order_array[j].stoploss || OrderGetDouble(ORDER_PRICE_OPEN)!=order_array[j].price)
                          {
                           if(trade.OrderModify(OrderGetInteger(ORDER_TICKET),order_array[j].price,order_array[j].stoploss,order_array[j].takeprofit, 0, 0, 0))
                             {
                              Print("Pending Order modified ticket:",PositionGetInteger(POSITION_TICKET));
                              cod[i].takeprofit=order_array[j].takeprofit;
                              cod[i].stoploss=order_array[j].stoploss;
                              cod[i].price = order_array[j].price;
                             }
                           else
                             {
                              Print("Order not modified error:",GetLastError());
                             }
                          }
                       }
                    }
                  if(trade_close == true)
                    {
                     if(OrderGetInteger(ORDER_TYPE)== ORDER_TYPE_BUY_STOP || OrderGetInteger(ORDER_TYPE)== ORDER_TYPE_SELL_STOP || OrderGetInteger(ORDER_TYPE)== ORDER_TYPE_BUY_LIMIT || OrderGetInteger(ORDER_TYPE)== ORDER_TYPE_SELL_LIMIT)
                       {
                        if(!trade.OrderDelete(OrderGetInteger(ORDER_TICKET)))
                          {
                           Print("Error in Deleting Pending Order: "+IntegerToString(GetLastError()));
                          }
                        else
                          {
                           Print("Pending Order Deleted. Ticket is: ", cod[i].ticket);
                           cod[i].ticket=-1;
                          }
                       }
                    }
                 }

              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void print()
  {
   for(int i=0; i<orderCount; i++)
     {
      if(cod[i].ticket!=-1)
        {
         Print("Ticket : ",cod[i].ticket," OPen price: ",cod[i].price, " Type: ",cod[i].ordertype);
        }

     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool isOrderThere(ulong ticket,int &index)
  {
   for(int i=0; i<ArraySize(mod1); i++)
     {
      if(ticket != -1)
        {
         if(mod1[i].ticket==ticket)
           {
            index=i;
            return true;
           }
        }
     }
   return false;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void emptyStruct()
  {
   for(int i = 0 ; i < orderCount ; i++)
     {
      if(mod1[i].ticket != -1)
        {
         mod1[i].ticket=-1;
         mod1[i].price=-1;
         mod1[i].symbol="";
         mod1[i].ordertype=-1;
         mod1[i].lots=0;
         mod1[i].stoploss=0;
         mod1[i].takeprofit=0;
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void deleteAllArray()
  {
   for(int i=0; i<orderCount; i++)
     {
      if(cod[i].ticket!=-1)
        {
         cod[i].ticket=-1;
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool addOrderMaster(ulong ticket,ulong magic,double lot, string calledBy)
  {
   Print("in addOrderMaster: ", ticket);
   bool notFoundPosition=false;//Use to look in to the order loop in case order isn't converted
   if(OrderSelect(ticket))
     {
      Print("Inside order selection:");
      Print("Order State:",(ENUM_ORDER_STATE)OrderGetInteger(ORDER_STATE));
      Print("Order Time done:",(datetime)OrderGetInteger(ORDER_TIME_DONE));
      Print("Order Type:",(ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE));
     }
   else
      if(HistoryOrderSelect(ticket))
        {
         Print("Inside history order selection:");
         Print("Order State:",(ENUM_ORDER_STATE)HistoryOrderGetInteger(ticket,ORDER_STATE));
         Print("Order Time done:",(datetime)HistoryOrderGetInteger(ticket,ORDER_TIME_DONE));
         Print("Order Type:",(ENUM_ORDER_TYPE)HistoryOrderGetInteger(ticket,ORDER_TYPE));
        }
      else
        {
         PrintFormat("OrderSelect(%I64u) failed. Error %d", ticket, GetLastError());
        }
   for(int i=0; i<orderCount; i++)
     {
      if(cod[i].ticket==-1)
        {

         if(calledBy == "Market")
           {
            if(PositionSelectByTicket(ticket))
              {
               cod[i].ticket=PositionGetInteger(POSITION_TICKET);
               cod[i].price=PositionGetDouble(POSITION_PRICE_OPEN);
               cod[i].symbol=PositionGetString(POSITION_SYMBOL);
               cod[i].ordertype=PositionGetInteger(POSITION_TYPE);
               cod[i].lots=PositionGetDouble(POSITION_VOLUME);
               cod[i].stoploss=PositionGetDouble(POSITION_SL);
               cod[i].takeprofit=PositionGetDouble(POSITION_TP);
               cod[i].magic=PositionGetInteger(POSITION_MAGIC);
               cod[i].comments=PositionGetString(POSITION_COMMENT);
               cod[i].masterLot = lot;
               Print("Ticket stored in master:",PositionGetInteger(POSITION_TICKET)," stored in index:",i);
               return true;
              }
            else
              {
               Print("Ticket:",ticket," not found in the position list");
               notFoundPosition=true;
              }

           }
         if(calledBy == "Pending" || notFoundPosition)
           {
            if(OrderSelect(ticket))
              {
               cod[i].ticket=OrderGetInteger(ORDER_TICKET);
               cod[i].price=OrderGetDouble(ORDER_PRICE_OPEN);
               cod[i].symbol=OrderGetString(ORDER_SYMBOL);
               cod[i].ordertype=OrderGetInteger(ORDER_TYPE);
               cod[i].lots=OrderGetDouble(ORDER_VOLUME_CURRENT);
               cod[i].stoploss=OrderGetDouble(ORDER_SL);
               cod[i].takeprofit=OrderGetDouble(ORDER_TP);
               cod[i].magic=OrderGetInteger(ORDER_MAGIC);
               cod[i].comments=OrderGetString(ORDER_COMMENT);
               cod[i].masterLot = lot;
               Print("Pending Order Ticket in master:",OrderGetInteger(ORDER_TICKET)," stored in index:",i);
               return true;
              }
            else
              {
               Print("Ticket:",ticket," not found in the order list");
              }
           }
        }
     }

   return false;
  }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double getDoubleSymbolInfo(string symbol,string info)
  {
   long digits=8;
//Symbol without the suffix and prefix
   string updatedSymbol=symbol;
   if(suffix!="")
      updatedSymbol = StringSubstr(updatedSymbol,0,StringFind(updatedSymbol,suffix,0));
   if(prefix!="")
      StringReplace(updatedSymbol,prefix,"");

//Digits calculation could be used in other calculations
   digits = SymbolInfoInteger(symbol,SYMBOL_DIGITS);
   if(digits==0)
     {
      digits=SymbolInfoInteger(updatedSymbol,SYMBOL_DIGITS);
      if(digits==0)
         digits=8;
     }

   if(info=="digits")
     {
      return (double)digits;
     }
   else
      if(info=="point" || info=="points")
        {
         double points=SymbolInfoDouble(symbol, SYMBOL_POINT);
         if(points==0)
           {
            points=SymbolInfoDouble(updatedSymbol,SYMBOL_POINT);
            if(points==0)
               points=0.00001;


           }
         return points;
        }
      else
         if(info=="ask")
           {
            double ask = SymbolInfoDouble(symbol, SYMBOL_ASK);
            if(ask==0)
              {
               ask=SymbolInfoDouble(updatedSymbol,SYMBOL_ASK);
               if(ask==0)
                  ask=0.00001;
              }
            return NormalizeDouble(ask,(int)digits);
           }
         else
            if(info=="bid")
              {
               double bid=SymbolInfoDouble(symbol, SYMBOL_BID);
               if(bid==0)
                 {
                  bid=SymbolInfoDouble(updatedSymbol,SYMBOL_BID);
                  if(bid==0)
                     bid=0.00001;
                 }
               return NormalizeDouble(bid,(int)digits);
              }
            else
               if(info=="contract"||info=="contractSize")
                 {
                  double contract=SymbolInfoDouble(symbol,SYMBOL_TRADE_CONTRACT_SIZE);
                  if(contract==0)
                    {
                     contract=SymbolInfoDouble(updatedSymbol,SYMBOL_TRADE_CONTRACT_SIZE);
                    }
                  return contract;
                 }
               else
                  if(info=="lotStep")
                    {
                     double step=SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
                     if(step==0)
                       {
                        step=SymbolInfoDouble(updatedSymbol,SYMBOL_VOLUME_STEP);

                       }
                     return step;
                    }
                  else
                     if(info=="minLot")
                       {
                        double minLot=SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
                        if(minLot==0)
                          {
                           minLot = SymbolInfoDouble(updatedSymbol, SYMBOL_VOLUME_MIN);

                          }
                        return minLot;
                       }
                     else
                        if(info=="maxLot")
                          {
                           double maxLot=SymbolInfoDouble(symbol,SYMBOL_VOLUME_MAX);
                           if(maxLot==0)
                             {
                              maxLot=SymbolInfoDouble(updatedSymbol,SYMBOL_VOLUME_MAX);

                             }
                           return maxLot;
                          }

   return 0;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
string getSymbol(string symbol)
  {
   if(mappingSymbol!="")
     {
      string symbollist[];
      StringSplit(mappingSymbol,';',symbollist);
      for(int i=0; i<ArraySize(symbollist); i++)
        {
         string symbolPairs[];
         StringSplit(symbollist[i],',',symbolPairs);
         if(ArraySize(symbolPairs)==2)
           {
            if(symbol==symbolPairs[0])
               return symbolPairs[1];
           }
        }
     }
   else
     {
      return prefix+symbol+suffix;
     }

   return prefix+symbol+suffix;

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double getLotSize(string symbol,double masterAccountBalance,double masterLot,int masterContractSize)
  {
   double lotsize = fixed;
   Print("------> Symbol:",symbol," master Account balance:",masterAccountBalance," master lot:",masterLot," master Contract:",masterContractSize);

   if(lotoption == mul)
     {
      lotsize = NormalizeDouble(masterLot*mult,2);
     }
   else
      if(lotoption == Balance)
        {
         lotsize=((AccountInfoDouble(ACCOUNT_BALANCE)/masterAccountBalance)*masterLot)*Bmult;
        }
      else
         if(lotoption == slaveLotCal)
           {
            lotsize = masterLot * (maxDd / recoveryAmount);
           }


   Print("Before Lot Size: ",lotsize);

   if(contractChk)
     {
      int clientContractSize=getDoubleSymbolInfo(symbol,"contract");
      Print("Client Contract size:",clientContractSize);

      if(masterContractSize!=0 && clientContractSize!=0)
        {
         lotsize=((masterContractSize*1.0)/clientContractSize)*lotsize;
        }
     }

   int roundDigit=0;
   double step=getDoubleSymbolInfo(symbol, "lotStep");

   while(step<1)
     {
      roundDigit++;
      step=step*10;
     }
   Print("Round Digits:",roundDigit);
   lotsize = NormalizeDouble(lotsize,roundDigit);


   if(lotsize<getDoubleSymbolInfo(symbol,"minLot"))
      lotsize=getDoubleSymbolInfo(symbol,"minLot");
   else
      if(lotsize>getDoubleSymbolInfo(symbol,"maxLot"))
         lotsize=getDoubleSymbolInfo(symbol,"maxLot");

   Print("Lot Size: ",lotsize);

   return lotsize;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void adminHeartBeat()
  {

   string headers = "apikey:"+localApiKey+"\r\naccept: */* \r\nContent-Type: application/json\r\nUser-Agent: MetaTraderApi";

   string url =localHB_req_link;// Request_link+(string)accountNumber;

   bool isPost;
   int timeout = 100000;
   string lastConnected=TimeToString(TimeCurrent());

   StringReplace(lastConnected,".","-");
   StringReplace(lastConnected," ","T");
   string gmtTime=TimeToString(TimeGMT());

   string jsonData="{\"sLogin\":\""+(string)accountNumber+"\",\"sServer\":\""+clientServer+"\",\"sVersion\":\"5\" ,\"sLastConnected\":\""+gmtTime+"\"}";//\",\"url\":"+"\""+url+"\""+headers+"}";

   uchar data[];
   StringToCharArray(jsonData, data, 0, StringLen(jsonData));

// Print("Making the heart beat request to the local host");

   POST_function(url,headers,timeout,data,isPost);

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool POST_function(string url, string headers, int timeout, uchar &data[], bool &IsPost)
  {
   ResetLastError();              // clear previous error
   static int lastErrorPrinted = 0;
   uchar result[];                // use uchar for WebRequest result
   string resultHeaders;

   int res = WebRequest("POST", url, headers, timeout, data, result, resultHeaders);

   if(res == 200 || res == 201)
     {
      Print("***Request success. HTTP response code POST: ", res);
      string result_string = CharArrayToString(result);
      Print("content POST: ", result_string);
      lastErrorPrinted = 0;       // reset remembered error on success
      IsPost = true;
      return true;
     }
   else
     {
      int err = GetLastError();   // read the error once
      // only print when there's a real error and it's different from last time
      if(err != 0 && err != lastErrorPrinted)
        {
         Print("Get last error: ", err);
         Print("***Request failed. HTTP response code: ", res);
         string result_string = CharArrayToString(result);
         Print("content: ", result_string);
         lastErrorPrinted = err;  // remember this error so we don't spam it
        }
      IsPost = false;
      return false;
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void clearOrderArray()
  {
//Resize to one
   ArrayResize(order_array,1);
//Clear all data
   order_array[0].symbol = "";
   order_array[0].opentime = 0;
   order_array[0].price = 0;
   order_array[0].ordertype = 0;
   order_array[0].lots = 0;
   order_array[0].stoploss = 0;
   order_array[0].takeprofit = 0;
   order_array[0].ticket = -1;
   order_array[0].magicNo = 0;
   order_array[0].accountBalance=0;
   order_array[0].contractSize=0;
   order_array[0].comments="";

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void mapHistory()
  {
   for(int i=0; i<PositionsTotal(); i++)
     {
      ulong ticket = PositionGetTicket(i);
      if(PositionSelectByTicket(ticket))
        {
         if(PositionGetInteger(POSITION_MAGIC) > 999)
           {
            addOrderMaster(PositionGetInteger(POSITION_TICKET), PositionGetInteger(POSITION_MAGIC), PositionGetDouble(POSITION_VOLUME), "Market");
           }
        }
     }

   for(int i=0; i<OrdersTotal(); i++)
     {
      ulong ticket = OrderGetTicket(i);
      if(OrderSelect(ticket))
        {
         if(OrderGetInteger(ORDER_MAGIC) > 999)
           {
            addOrderMaster(OrderGetInteger(ORDER_TICKET), OrderGetInteger(ORDER_MAGIC), OrderGetDouble(ORDER_VOLUME_CURRENT), "Pending");
           }
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool addToMarketWatch(string symbol)
  {
   Print("Symbol:",symbol);
   bool result=SymbolSelect(symbol,true);
   if(result)
     {
      Print("Successfully added the symbol or already there:", symbol);
      return true;
     }
   else
     {
      Print("Error in adding symbol:",symbol);
     }
   return false;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void read_history_file()
  {
   string file_name = "history_trades.csv";
   if(!FileIsExist(file_name, FILE_COMMON))
     {
      Print("File not found: ", file_name);
      return;
     }

   int h = FileOpen(file_name, FILE_SHARE_READ|FILE_CSV|FILE_COMMON|FILE_READ|FILE_ANSI|FILE_TXT|FILE_COMMON);
   if(h == INVALID_HANDLE)
     {
      Print("Error opening file: ", file_name, " Err:", GetLastError());
      return;
     }

   datetime lastFileModified=(datetime)FileGetInteger(h,FILE_MODIFY_DATE);
   long fileSize=FileGetInteger(h,FILE_SIZE);

   if(lastModified1==lastFileModified && fileSize==lastFileSize1)
     {
      FileClose(h);
      return;
     }
   else
     {

      ulong fileTickets[];
      ArrayResize(fileTickets, 0);
      while(!FileIsEnding(h))
        {
         string line = FileReadString(h);
         // split by comma
         string parts[];
         int count = StringSplit(line,',', parts);
         if(count >= 2)
           {
            // convert to integers
            ulong ticket = StringToInteger(parts[0]);
            ulong magic  = StringToInteger(parts[1]);
            int newSize = ArraySize(fileTickets) + 1;
            ArrayResize(fileTickets, newSize);
            fileTickets[newSize - 1] = ticket;
            if(!history_ticket_present(ticket))
               add_history_ticket(ticket, magic);
           }
         else
           {
            // Print("Skipped malformed line while reading ", file_name, " : ", line);
           }
        }

      FileClose(h);
      lastModified1=lastFileModified;
      lastFileSize1=fileSize;

      for(int i = 0; i < MaxOrders; i++)
        {
         ulong tk = historyTradeStore[i].ticket;
         if(tk == -1)
            continue;

         bool found = false;

         for(int j = 0; j < ArraySize(fileTickets); j++)
           {
            if(fileTickets[j] == tk)
              {
               found = true;
               break;
              }
           }

         if(!found)
           {
            Print("Removing ticket not found in file: ", tk, " index=", i);
            historyTradeStore[i].ticket = -1;
            historyTradeStore[i].magic  = 0;
           }
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void add_history_ticket(ulong ticket, ulong magicIs)
  {
   for(int i = 0; i < MaxOrders; i++)
     {
      if(historyTradeStore[i].ticket == -1)
        {
         historyTradeStore[i].ticket = ticket;
         historyTradeStore[i].magic  = magicIs;
         Print(" -------- add_history_ticket() Added ticket: ", ticket, " Magic: ", magicIs, " ---------------------------- ");
         return;
        }
     }
   Print("historyTradeStore full, cannot add ticket: ", ticket);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool history_ticket_present(ulong ticket)
  {
   for(int i = 0 ; i < MaxOrders ; i++)
     {
      if(historyTradeStore[i].ticket == ticket)
         return true;
     }
   return false;
  }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+