Ticket: 5131 Trade Placing and File Fetching Data Store

vol_hedge_strategy_mt5.mq5

@@ -0,0 +1,452 @@
+//+------------------------------------------------------------------+
+//|                                       vol_hedge_strategy_mt5.mq5 |
+//|                                  Copyright 2025, MQL Development |
+//|                                  https://www.mqldevelopment.com/ |
+//+------------------------------------------------------------------+
+#property copyright "Copyright 2025, MQL Development"
+#property link      "https://www.mqldevelopment.com/"
+#property version   "1.00"
+#define MaxOrders 100
+#include <Trade\Trade.mqh>
+CTrade  trade;
+//+------------------------------------------------------------------+
+//| Expert initialization function                                   |
+//+------------------------------------------------------------------+
+
+struct new_trade_store
+  {
+   ulong             buy_ticket;     // Buy Ticket
+   ulong             sell_ticket;    // Sell Ticket
+   string            symbol;         // Symbol
+   double            price;          // Price
+   double            stop_loss;      // StopLoss
+   double            take_profit;    // TakeProfit
+   datetime          start_time;     // Start time
+   datetime          end_time;       // End Time
+
+                     new_trade_store()
+     {
+      buy_ticket = -1;
+      sell_ticket = -1;
+     }
+
+  };
+new_trade_store newTradeStore[MaxOrders];
+
+enum lotcalculator
+  {
+   fix, //Fixed Lot Size
+   rsk, //Risk Percentage
+   dollar, // Risk in Dollars
+  };
+
+sinput       string                  string_0                   = "<><><><><><> General SETTINGS <><><><><><>";   //__
+input        int                     magic_no                   = 333;             // Magic no
+
+input        string                  string_1                   = "<><><><><><> Lot Management<><><><><><>";   //__
+input        lotcalculator           lot_calculator             = fix;             // Lot Size Option
+input        double                  lot_amount                 = 0.1;             // Lot Size
+input        double                  risk                       = 0.5;             // Risk in Percentage %
+input        double                  dollars                    = 10;              // Risk in GBP
+
+input        string                  string_2                   = "<><><><><><> Time Filter Setting <><><><><><> ";//_
+input        bool                    enableTimeSession          = false;           // Enable Time Session
+input        string                  start_time                 = "01:00";         // Start Session
+input        string                  end_time                   = "23:59";         // End Session
+
+// Global Variables
+static double tickCurrentBid = 0;
+double tickPreviousBid = 0;
+static double tickCurrentAsk = 0;
+double tickPreviousAsk = 0;
+datetime startSessionTime, endSessionTime;
+//+------------------------------------------------------------------+
+//|                                                                  |
+//+------------------------------------------------------------------+
+int OnInit()
+  {
+//---
+   Print(" OnInIt. ");
+
+   trade.SetExpertMagicNumber(magic_no);
+   trade.SetDeviationInPoints(10);
+   trade.SetTypeFilling(ORDER_FILLING_IOC);
+   trade.LogLevel(LOG_LEVEL_ALL);
+   trade.SetAsyncMode(false);
+
+   int filehandle = FileOpen("vol_hedge_data.csv", FILE_READ | FILE_CSV | FILE_COMMON | FILE_ANSI);
+   if(filehandle != INVALID_HANDLE)
+     {
+      Print(" Valid Handler. ");
+      while(!FileIsEnding(filehandle))
+        {
+         string orderToRead = FileReadString(filehandle);
+         string orderData[];
+         //Print("Data: ", OrderToRead);
+         StringSplit(orderToRead, StringGetCharacter(",",0), orderData);
+         Print("Array Size: ", ArraySize(orderData));
+         Print(" Order is: ", orderToRead);
+         for(int i = 0 ; i < ArraySize(orderData) ; i++)
+           {
+            Print(" Order Data: ", orderData[i], " i: ", i);
+           }
+
+         if(ArraySize(orderData) >= 6)
+           {
+            if(orderData[0] == Symbol())
+              {
+               // store into local variables first (trim if needed)
+               ulong  buy_ticket_local  = (ulong)-1; // keep -1 as per your convention
+               ulong  sell_ticket_local = (ulong)-1;
+               string symbol_local      = orderData[0];
+               double price_local       = StringToDouble(orderData[1]);
+               double sl_local          = StringToDouble(orderData[2]);
+               double tp_local          = StringToDouble(orderData[3]);
+               // if your CSV has extra fields (tp2,tp3, etc.) parse here as needed
+               datetime start_local     = StringToTime(orderData[4]);
+               datetime end_local       = StringToTime(orderData[5]);
+
+               // OPTIONAL: only add when price == 0:
+               // if(MathAbs(price_local) > 1e-9) { Print("Skipped: price != 0"); continue; }
+
+               // call the single-responsibility function that writes into struct array
+               addToNewTradeStore(buy_ticket_local, sell_ticket_local,
+                                  symbol_local, price_local,
+                                  sl_local, tp_local,
+                                  start_local, end_local);
+              }
+           }
+        }
+      FileClose(filehandle);
+     }
+   else
+     {
+      Print(" InValid Handler. Error: ", GetLastError());
+     }
+
+   timeFilter(true,start_time, end_time, startSessionTime, endSessionTime);
+   Print(" Session Start  = ", startSessionTime,  " Asian  Session End = ", endSessionTime);
+//---
+   return(INIT_SUCCEEDED);
+  }
+//+------------------------------------------------------------------+
+//| Expert deinitialization function                                 |
+//+------------------------------------------------------------------+
+void OnDeinit(const int reason)
+  {
+//---
+
+  }
+//+------------------------------------------------------------------+
+//| Expert tick function                                             |
+//+------------------------------------------------------------------+
+void OnTick()
+  {
+//---
+   double Bid = SymbolInfoDouble(Symbol(), SYMBOL_BID);
+   double Ask = SymbolInfoDouble(Symbol(), SYMBOL_ASK);
+
+   if(tickPreviousBid == 0 && tickCurrentBid == 0)
+     {
+      tickPreviousBid = Bid;
+      tickCurrentBid  = Bid;
+     }
+   else
+     {
+      tickPreviousBid = tickCurrentBid;
+      tickCurrentBid  = Bid;
+     }
+
+   if(tickPreviousAsk == 0 && tickCurrentAsk == 0)
+     {
+      tickPreviousAsk = Ask;
+      tickCurrentAsk  = Ask;
+     }
+   else
+     {
+      tickPreviousAsk = tickCurrentAsk;
+      tickCurrentAsk  = Ask;
+     }
+
+// Print(" Time is: ", TimeCurrent());
+   timeFilter(false,start_time, end_time, startSessionTime, endSessionTime);
+   Comment(" Session Start  = ", startSessionTime,  " Asian  Session End = ", endSessionTime);
+   if((!enableTimeSession) || (enableTimeSession && TimeCurrent() >= startSessionTime && TimeCurrent() <= endSessionTime))
+     {
+      tradePlacingCheck();
+     }
+  }
+//+------------------------------------------------------------------+
+//+------------------------------------------------------------------+
+//|                                                                  |
+//+------------------------------------------------------------------+
+void addToNewTradeStore(ulong r_buy_ticket, ulong r_sell_ticket,
+                        string r_symbol, double r_price,
+                        double r_stop_loss, double r_take_profit,
+                        datetime r_start_time, datetime r_end_time)
+  {
+   for(int i = 0; i < MaxOrders; i++)
+     {
+      // treat slot as empty when both tickets are -1 (same convention as constructor)
+      if(newTradeStore[i].buy_ticket == -1 && newTradeStore[i].sell_ticket == -1)
+        {
+         newTradeStore[i].buy_ticket  = r_buy_ticket;
+         newTradeStore[i].sell_ticket = r_sell_ticket;
+         newTradeStore[i].symbol      = r_symbol;
+         newTradeStore[i].price       = r_price;
+         newTradeStore[i].stop_loss   = r_stop_loss;
+         newTradeStore[i].take_profit = r_take_profit;
+         newTradeStore[i].start_time  = r_start_time;
+         newTradeStore[i].end_time    = r_end_time;
+
+         Print("Stored -> idx: ", i,
+               " | sym: ", newTradeStore[i].symbol,
+               " | price: ", DoubleToString(newTradeStore[i].price, Digits()),
+               " | sl: ", DoubleToString(newTradeStore[i].stop_loss, Digits()),
+               " | tp: ", DoubleToString(newTradeStore[i].take_profit, Digits()),
+               " | start: ", TimeToString(newTradeStore[i].start_time, TIME_DATE|TIME_SECONDS),
+               " | end: ", TimeToString(newTradeStore[i].end_time, TIME_DATE|TIME_SECONDS));
+         break;
+        }
+     }
+  }
+//+------------------------------------------------------------------+
+//|                                                                  |
+//+------------------------------------------------------------------+
+void tradePlacingCheck()
+  {
+   for(int i = 0; i < MaxOrders; i++)
+     {
+      if(newTradeStore[i].buy_ticket == -1 && newTradeStore[i].sell_ticket == -1)
+        {
+         if(newTradeStore[i].price > 0)
+           {
+            double levelPriceIs = newTradeStore[i].price;
+            if((tickPreviousBid > levelPriceIs && tickCurrentBid < levelPriceIs) ||
+               (tickPreviousBid < levelPriceIs && tickCurrentBid > levelPriceIs))
+              {
+               ulong buyTicket = placeBuyTrade(newTradeStore[i].stop_loss, newTradeStore[i].take_profit);
+               ulong sellTicket = 0; // placeSellTrade(newTradeStore[i].stop_loss, newTradeStore[i].take_profit);
+
+               newTradeStore[i].buy_ticket = buyTicket;
+               newTradeStore[i].sell_ticket = sellTicket;
+              }
+           }
+        }
+     }
+  }
+//+------------------------------------------------------------------+
+//|                                                                  |
+//+------------------------------------------------------------------+
+ulong placeBuyTrade(double stoploss, double takeprofit)
+  {
+
+   double buySL = 0, buyTp=0;
+//openPrice = SymbolInfoDouble(Symbol(),SYMBOL_ASK);
+   double Ask = SymbolInfoDouble(Symbol(),SYMBOL_ASK);
+   double Bid = SymbolInfoDouble(Symbol(),SYMBOL_BID);
+
+   if(stoploss != 0)
+     {
+      buySL = Ask - (stoploss * Point());
+     }
+   if(takeprofit != 0)
+     {
+      buyTp = Ask + (takeprofit * Point());
+     }
+
+   double distance = MathAbs((Ask - buySL) / Point());
+   if(trade.PositionOpen(Symbol(),ORDER_TYPE_BUY,getLot(distance),Ask,buySL,buyTp,"Buy Trade Placed"))
+     {
+      Print("Buy Trade Placed: ",trade.ResultOrder());
+      return trade.ResultOrder();
+     }
+   else
+     {
+      Print("Error in placing Buy: "+Symbol()+"  ",GetLastError());
+      return -1;
+     }
+   return -1;
+  }
+//+------------------------------------------------------------------+
+//|                                                                  |
+//+------------------------------------------------------------------+
+ulong placeSellTrade(double stoploss, double takeprofit)
+  {
+
+   double sellSL = 0, sellTp = 0;
+   double Ask = SymbolInfoDouble(Symbol(),SYMBOL_ASK);
+   double Bid = SymbolInfoDouble(Symbol(),SYMBOL_BID);
+
+   if(stoploss != 0)
+     {
+      sellSL = Bid + (stoploss * Point());
+     }
+   if(takeprofit != 0)
+     {
+      sellTp = Bid - (takeprofit * Point());
+     }
+   double distance = MathAbs((Bid - sellSL) / Point());
+   if(trade.PositionOpen(Symbol(),ORDER_TYPE_SELL,getLot(distance),Bid,sellSL,sellTp,"Sell Trade Placed"))
+     {
+      Print("Sell Trade PLaced: ",trade.ResultOrder());
+      return trade.ResultOrder();
+     }
+   else
+     {
+      Print("Error in placing Sell: "+Symbol()+"  ",GetLastError());
+      return -1;
+     }
+   return -1;
+  }
+//+------------------------------------------------------------------+
+//|                                                                  |
+//+------------------------------------------------------------------+
+double getLot(double stop_loss)
+  {
+   Print("Tick Value: ",SymbolInfoDouble(Symbol(),SYMBOL_TRADE_TICK_VALUE));
+   Print("Tick Size: ",SymbolInfoDouble(Symbol(),SYMBOL_TRADE_TICK_SIZE));
+   double modeTickV=SymbolInfoDouble(Symbol(),SYMBOL_TRADE_TICK_VALUE)
+                    ,modeTickS=SymbolInfoDouble(Symbol(),SYMBOL_TRADE_TICK_SIZE);
+// Print("Pip value: ", NormalizeDouble(((SymbolInfoDouble(Symbol(),SYMBOL_TRADE_TICK_VALUE)/(SymbolInfoDouble(Symbol(),SYMBOL_TRADE_TICK_SIZE)/Point))*10),2));
+   double pipvalue = NormalizeDouble(((SymbolInfoDouble(Symbol(),SYMBOL_TRADE_TICK_VALUE)/(SymbolInfoDouble(Symbol(),SYMBOL_TRADE_TICK_SIZE)/Point()))*10),2);
+// pipvalue=NormalizeDouble((modeTickV/modeTickS/Point()),)
+// pipvalue=
+   pipvalue = pipvalue / 10;
+   double lotSize = lot_amount;
+   if(lot_calculator == rsk || lot_calculator == dollar) //calculating risk
+     {
+      double riskamount = 0;
+      if(lot_calculator == rsk)
+        {
+         riskamount = (risk/100)*AccountInfoDouble(ACCOUNT_BALANCE);
+        }
+      if(lot_calculator == dollar)
+        {
+         riskamount = dollars;
+        }
+      double pipvalue_required=riskamount/stop_loss;
+      lotSize = pipvalue_required/pipvalue;
+      //sl=riskamount/pipValuelot
+      int roundDigit=0;
+      double step=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_STEP);
+
+      while(step<1)
+        {
+         roundDigit++;
+         step=step*10;
+        }
+      Print("Round Digits:",roundDigit);
+      lotSize = NormalizeDouble(lotSize,roundDigit);
+      //
+     }
+   Print("Lot Size: ",lotSize);
+
+   if(lotSize > SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MAX))
+     {
+      lotSize=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MAX);
+     }
+   else
+      if(lotSize<SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN))
+        {
+         lotSize=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN);
+        }
+
+//---
+   return lotSize;
+  }
+//+------------------------------------------------------------------+
+//|                                                                  |
+//+------------------------------------------------------------------+
+void timeFilter(bool onInit,string startTime,string endTime,datetime & sessionStart,datetime & sessionEnd)
+  {
+   int newYorkStartHour = 0, newYorkStartMin = 0, newYorkEndHour = 0, newYorkEndMin = 0;
+
+   datetime newYorkStartTrading,newYorkEndTrading;
+
+   string time[];
+   StringSplit(startTime,':',time);
+   newYorkStartHour = (int)StringToInteger(time[0]);
+   newYorkStartMin  = (int)StringToInteger(time[1]);
+
+   EventSetMillisecondTimer(500);
+   time[0] = "";
+   time[1] = "";
+   StringSplit(endTime,':',time);
+   newYorkEndHour = (int)StringToInteger(time[0]);
+   newYorkEndMin  = (int)StringToInteger(time[1]);
+
+// Print(" Start Time Hour: ",newYorkStartHour,"  Start Time Min: ",newYorkStartMin);
+// Print(" End Time Hour: ",newYorkEndHour,"  End Time Min: ",newYorkEndMin);
+
+
+   datetime startDateTime;
+   MqlDateTime st;
+   TimeCurrent(st); // get current date
+   st.hour   = newYorkStartHour;
+   st.min    = newYorkStartMin;
+   st.sec    = 0;
+   startDateTime = StructToTime(st);
+
+
+   datetime endDateTime;
+   MqlDateTime et;
+   TimeCurrent(et); // get current date
+   et.hour   = newYorkEndHour;
+   et.min    = newYorkEndMin;
+   et.sec    = 0;
+   endDateTime = StructToTime(et);
+
+
+   MqlDateTime sdate,edate;
+   datetime start_Time = 0, end_Time = 0;
+   if(startDateTime > endDateTime)
+     {
+      if(onInit)
+        {
+         start_Time = iTime(Symbol(),PERIOD_D1,1);
+         end_Time = iTime(Symbol(),PERIOD_D1,0);
+        }
+      else
+        {
+         start_Time = sessionStart;
+         end_Time = sessionEnd;
+         if(TimeCurrent() >= sessionEnd && sessionEnd != 0)
+           {
+            start_Time = iTime(Symbol(),PERIOD_D1,0);
+            end_Time = start_Time + 86400;
+           }
+        }
+     }
+   else
+     {
+      start_Time = iTime(Symbol(),PERIOD_D1,0);
+      end_Time = iTime(Symbol(),PERIOD_D1,0);
+     }
+
+   if(TimeToStruct(end_Time,edate))
+     {
+      edate.hour = newYorkEndHour;
+      edate.min  = newYorkEndMin;
+      edate.sec  = 0;
+     }
+   else
+      Print("Error in Converting Time: ",GetLastError());
+   newYorkEndTrading = StructToTime(edate);
+
+   if(TimeToStruct(start_Time,sdate))
+     {
+      sdate.hour = newYorkStartHour;
+      sdate.min  = newYorkStartMin;
+      sdate.sec  = 0;
+     }
+   else
+      Print("Error in Converting Time: ",GetLastError());
+   newYorkStartTrading = StructToTime(sdate);
+
+   sessionStart = newYorkStartTrading;
+   sessionEnd   = newYorkEndTrading;
+  }
+//+------------------------------------------------------------------+
+//|                                                                  |
+//+------------------------------------------------------------------+