update

2025-07-04 16:56:12 +02:00
parent b3357f7bb7
commit 10c1d86a0c
27 changed files with 3161 additions and 2040 deletions
@@ -0,0 +1,274 @@
+#include <Trade/Trade.mqh>
+#include <MyLibs/Utils/TimeZones.mqh>
+#include <MyLibs/Utils/MarketDataUtils.mqh>
+
+class CalculatePositionData : public CObject{
+   
+    protected:
+        CTrade         trade;
+        CPositionInfo  position;
+        MarketDataUtils   mdu;
+
+        bool     check_lots(double &lots, string symbol);
+        bool     normalise_price(double price, double &normalizedPrice, string symbol);
+
+    public:
+
+        double  calculate_stoploss(string symbol, double price, int order_side, string _sl_mode, double sl_var, ENUM_TIMEFRAMES atr_period);
+        double  calculate_take_profit(string symbol, double price, double stoploss, int order_side, string mode_tp, double tp_var, ENUM_TIMEFRAMES atr_period);
+        double  calculate_lots(string symbol, double sl_distance, double price, string mode_lot, double lot_var);
+        double  calculate_trading_cost(string symbol, ulong position_ticket);
+};
+
+double CalculatePositionData::calculate_stoploss(string symbol, double price, int order_side, string mode_sl, double sl_var, ENUM_TIMEFRAMES atr_period){
+    // order_side int must be 1 for BUY or 2 for    
+
+    double sl=0;
+
+    if(mode_sl=="NO_STOPLOSS"){
+        sl=0;
+    }
+
+    if(mode_sl=="SL_BREAKEVEN"){
+        // https://www.youtube.com/watch?v=idPulZ3_iR0
+        Alert("Not implemented yet yet");
+    }
+
+    if(mode_sl=="SL_FIXED_PIPS"){
+        // pips/poins = https://www.mql5.com/en/forum/187757
+        double adj_point = mdu.adjusted_point(symbol);
+        
+        if(order_side == 1){
+            sl = price - sl_var * adj_point; 
+            if(!normalise_price(sl,sl,symbol)){return false;}
+        }
+        if(order_side == 2){    
+            sl = price + sl_var * adj_point;
+            if(!normalise_price(sl,sl,symbol)){return false;}
+        }
+    }
+
+    if(mode_sl=="SL_FIXED_PERCENT"){
+        if(order_side == 1){
+            sl = (-1.0 * sl_var * price / 100.00) + price;       
+            if(!normalise_price(sl,sl,symbol)){return false;}
+        }
+        if(order_side == 2){
+            sl = sl_var * price / 100.00 + price;
+            if(!normalise_price(sl,sl,symbol)){return false;}
+        }
+    }
+
+    if(mode_sl=="SL_ATR_MULTIPLE"){
+        
+        int _atr_handle = iATR(symbol,atr_period,14);  
+        double atr[];
+        ArraySetAsSeries(atr,true);        
+        CopyBuffer(_atr_handle,MAIN_LINE,1,1,atr);
+
+        if(order_side == 1){
+            sl =  price - (atr[0] * sl_var);
+            if(!normalise_price(sl,sl,symbol)){return false;}
+
+        }
+        if(order_side == 2){
+            sl = price + (atr[0] * sl_var);
+            if(!normalise_price(sl,sl,symbol)){return false;}
+        }
+    }
+
+    if(mode_sl=="SL_SPECIFIED_VALUE"){
+
+        double adj_point = mdu.adjusted_point(symbol);
+
+        if(order_side == 1){
+
+            double pip_50_sl = price - 10 * adj_point;  
+            if(sl_var >= pip_50_sl){
+                sl = pip_50_sl; 
+            }
+            else sl = sl_var;
+
+            if(!normalise_price(sl,sl,symbol)){return false;}
+        }
+        if(order_side == 2){
+            double pip_50_sl = price + 10 * adj_point;   
+            if(sl_var <= pip_50_sl){
+                sl = pip_50_sl; 
+            }
+            else sl = sl_var;
+
+            sl = sl = sl_var;
+            if(!normalise_price(sl,sl,symbol)){return false;}
+        }
+    }
+
+    return sl;
+}
+
+double CalculatePositionData::calculate_take_profit(string symbol, double price, double stoploss, int order_side, string mode_tp, double _tp_var, ENUM_TIMEFRAMES atr_period){
+    // order_side int must be 1 for BUY or 2 for SELL
+
+    double tp=0;
+
+    if(mode_tp=="NO_TAKE_PROFIT"){
+        tp=0;
+    }
+
+    if(mode_tp=="TP_FIXED_PIPS"){
+
+        double adj_point = mdu.adjusted_point(symbol);
+        if(order_side == 1){
+            tp = price + _tp_var * adj_point;       
+            if(!normalise_price(tp,tp,symbol)){return false;}
+        }
+        if(order_side == 2){
+            tp = price - _tp_var * adj_point;
+            if(!normalise_price(tp,tp,symbol)){return false;}
+        }
+    }
+
+    if(mode_tp=="TP_FIXED_PERCENT"){
+        if(order_side == 1){
+            tp = _tp_var * price / 100.00 + price;       
+            if(!normalise_price(tp,tp,symbol)){return false;}
+        }
+        if(order_side == 2){
+            tp = (-1 * _tp_var * price / 100.00) + price;
+            if(!normalise_price(tp,tp,symbol)){return false;}
+        }
+    }
+
+    if(mode_tp=="TP_ATR_MULTIPLE"){
+
+        int _atr_handle = iATR(symbol,atr_period,14);  
+        double atr[];
+        ArraySetAsSeries(atr,true);        
+        CopyBuffer(_atr_handle,MAIN_LINE,1,1,atr);
+
+        if(order_side == 1){
+            tp = price + (atr[0] * _tp_var);
+            if(!normalise_price(tp,tp,symbol)){return false;}
+        }
+        if(order_side == 2){
+            tp = price - (atr[0] * _tp_var);
+            if(!normalise_price(tp,tp,symbol)){return false;}
+        }
+    }
+
+    if(mode_tp=="TP_SL_MULTIPLE"){
+        if(order_side == 1){
+            double sl_size = price - stoploss;
+            tp = price + (_tp_var * sl_size);
+            if(!normalise_price(tp,tp,symbol)){return false;}
+        }
+        if(order_side == 2){
+            double sl_size = stoploss - price;
+            tp = price - (_tp_var * sl_size);    
+            if(!normalise_price(tp,tp,symbol)){return false;}
+        }
+    }
+
+    if(mode_tp=="TP_SPECIFIED_VALUE"){
+
+        if(_tp_var!=0){
+            double adj_point = mdu.adjusted_point(symbol);
+
+            if(order_side == 1){
+                double pip_limit = price + 10 * adj_point;               
+                if(_tp_var <= pip_limit){
+                    tp = pip_limit; 
+                }
+                else tp = _tp_var;
+
+                if(!normalise_price(tp,tp,symbol)){return false;}
+            }
+            if(order_side == 2){
+                double pip_limit = price - 10 * adj_point;   
+                if(_tp_var >= pip_limit){
+                    tp = pip_limit; 
+                }
+                else tp = _tp_var;
+                tp = tp = _tp_var;
+                if(!normalise_price(tp,tp,symbol)){return false;}
+            }
+        }
+    }
+    return tp;
+
+}
+
+double CalculatePositionData::calculate_lots(string symbol, double sl_distance, double price, string mode_lot, double lot_var){
+
+    double lots = 0;
+    double tick_size  = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
+    double tick_value = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);
+    double volume_step   = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
+
+    double account_value = fmin(fmin(AccountInfoDouble(ACCOUNT_EQUITY),AccountInfoDouble(ACCOUNT_BALANCE)),AccountInfoDouble(ACCOUNT_MARGIN_FREE));
+    double risk_money = account_value * lot_var / 100;
+
+    if(mode_lot=="LOT_MODE_FIXED"){
+        lots = lot_var;
+    }
+
+    if(mode_lot=="LOT_MODE_PCT_RISK"){
+        double money_lot_step = (sl_distance / tick_size) * tick_value * volume_step;
+        lots = MathFloor(risk_money/money_lot_step) * volume_step;
+    }
+
+    if(mode_lot=="LOT_MODE_PCT_ACCOUNT"){   
+        double money_lot_step = (price / tick_size) * tick_value * volume_step;
+        lots = MathFloor(risk_money/money_lot_step) * volume_step;      
+    }
+
+    if(!check_lots(lots, symbol)){return false;}
+    return lots;
+}
+
+bool CalculatePositionData::check_lots(double &lots, string symbol){
+
+    double min  = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MIN);
+    double max  = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
+    double step = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
+
+    if(lots<min){
+        Print("Lot size will be set to minimum allowed volume");
+        lots = min;
+        return true;
+    }
+
+    if(lots>max){
+        Print("Lot size greater than maximum allowed volume. lots:",lots,"max:",max);
+        return false;
+    }
+
+    lots = (int)MathFloor(lots/step) * step;
+    return true;
+}
+
+bool CalculatePositionData::normalise_price(double price, double &normalizedPrice, string symbol){
+    double tickSize;
+    if(!SymbolInfoDouble(symbol,SYMBOL_TRADE_TICK_SIZE,tickSize)){
+        Print("Failed to get tick size");
+        return false;
+    }
+    int symbol_digits  = (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS);
+    normalizedPrice = NormalizeDouble(MathRound(price/tickSize)*tickSize, symbol_digits);
+    return true;
+}
+
+double CalculatePositionData::calculate_trading_cost(string symbol, ulong position_ticket){
+
+   position.SelectByTicket(position_ticket);
+   
+   double swap = PositionGetDouble(POSITION_SWAP);
+   double commission = PositionGetDouble(POSITION_COMMISSION);
+   double tick_size  = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_SIZE);
+   double tick_value = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);
+   double lot_step   = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
+   double lots = PositionGetDouble(POSITION_VOLUME);
+   double trading_cost = -1 * ((commission + swap) / tick_value * tick_size / lots);
+
+   return trading_cost;
+}
@@ -0,0 +1,112 @@
+#include <Trade/Trade.mqh>
+#include <MyLibs/Orders/CalculatePositionData.mqh>
+
+class EntryOrders {
+
+   protected:
+      CTrade trade;
+      CalculatePositionData calc;
+      double stop_loss;
+      double take_profit;
+      int total_open_buy_orders;
+      int total_open_sell_orders;
+      double current_price;
+
+      int count_open_positions(string symbol, int order_side, long magic_number);
+
+   public:
+      bool open_buy_orders(string symbol, bool condition, ENUM_TIMEFRAMES atr_period, string _sl_mode, double sl_var,string _tp_mode, double tp_var, string _lot_mode, double lot_var, long magic_number);
+      bool open_sell_orders(string symbol, bool condition, ENUM_TIMEFRAMES atr_period, string _sl_mode, double sl_var, string _tp_mode, double tp_var, string _lot_mode, double lot_var, long magic_number);
+      bool open_buy_stop_order(string symbol, bool condition, double entry_price, datetime experation,ENUM_TIMEFRAMES atr_period, string _sl_mode, double sl_var, string _tp_mode, double tp_var, string _lot_mode, double lot_var, long magic_number);
+      bool open_sell_stop_order(string symbol, bool condition, double entry_price, datetime experation,ENUM_TIMEFRAMES atr_period, string _sl_mode, double sl_var, string _tp_mode, double tp_var,string _lot_mode, double lot_var, long magic_number);
+};
+
+
+int EntryOrders::count_open_positions(string symbol, int order_side, long magic_number) {
+   int count = 0;
+   for (int i = PositionsTotal() - 1; i >= 0; i--) {
+      ulong ticket = PositionGetTicket(i);
+      if (PositionGetString(POSITION_SYMBOL) == symbol &&
+          PositionGetInteger(POSITION_MAGIC) == magic_number) {
+         if ((order_side == 1 && PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) ||
+             (order_side == 2 && PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)) {
+            count++;
+         }
+      }
+   }
+   return count;
+}
+
+bool EntryOrders::open_buy_orders(string symbol, bool condition, ENUM_TIMEFRAMES atr_period, string _sl_mode,
+                                  double sl_var, string _tp_mode, double tp_var, string _lot_mode, double lot_var,
+                                  long magic_number) {
+   if (condition) {
+      current_price = SymbolInfoDouble(symbol, SYMBOL_ASK);
+      total_open_buy_orders = count_open_positions(symbol, 1, magic_number);
+      if (total_open_buy_orders == 0) {
+         stop_loss = calc.calculate_stoploss(symbol, current_price, 1, _sl_mode, sl_var, atr_period);
+         take_profit = calc.calculate_take_profit(symbol, current_price, stop_loss, 1, _tp_mode, tp_var, atr_period);
+         double sl_distance = current_price - stop_loss;
+         double lots = calc.calculate_lots(symbol, sl_distance, current_price, _lot_mode, lot_var);
+         trade.SetExpertMagicNumber(magic_number);
+         string comment = "Magic Number: " + IntegerToString(magic_number);
+         trade.PositionOpen(symbol, ORDER_TYPE_BUY, lots, current_price, stop_loss, take_profit, comment);
+      }
+   }
+   return true;
+}
+
+bool EntryOrders::open_sell_orders(string symbol, bool condition, ENUM_TIMEFRAMES atr_period, string _sl_mode,
+                                   double sl_var, string _tp_mode, double tp_var, string _lot_mode, double lot_var,
+                                   long magic_number) {
+   if (condition) {
+      current_price = SymbolInfoDouble(symbol, SYMBOL_BID);
+      total_open_sell_orders = count_open_positions(symbol, 2, magic_number);
+      if (total_open_sell_orders == 0) {
+         stop_loss = calc.calculate_stoploss(symbol, current_price, 2, _sl_mode, sl_var, atr_period);
+         take_profit = calc.calculate_take_profit(symbol, current_price, stop_loss, 2, _tp_mode, tp_var, atr_period);
+         double sl_distance = stop_loss - current_price;
+         double lots = calc.calculate_lots(symbol, sl_distance, current_price, _lot_mode, lot_var);
+         trade.SetExpertMagicNumber(magic_number);
+         string comment = "Magic Number: " + IntegerToString(magic_number);
+         trade.PositionOpen(symbol, ORDER_TYPE_SELL, lots, current_price, stop_loss, take_profit, comment);
+      }
+   }
+   return true;
+}
+
+bool EntryOrders::open_buy_stop_order(string symbol, bool condition, double entry_price, datetime experation,
+                                      ENUM_TIMEFRAMES atr_period, string _sl_mode, double sl_var, string _tp_mode,
+                                      double tp_var, string _lot_mode, double lot_var, long magic_number) {
+   if (condition) {
+      total_open_buy_orders = count_open_positions(symbol, 1, magic_number);
+      if (total_open_buy_orders == 0) {
+         stop_loss = calc.calculate_stoploss(symbol, entry_price, 1, _sl_mode, sl_var, atr_period);
+         take_profit = calc.calculate_take_profit(symbol, entry_price, stop_loss, 1, _tp_mode, tp_var, atr_period);
+         double sl_distance = entry_price - stop_loss;
+         double lots = calc.calculate_lots(symbol, sl_distance, entry_price, _lot_mode, lot_var);
+         trade.SetExpertMagicNumber(magic_number);
+         string comment = "Magic Number: " + IntegerToString(magic_number);
+         trade.BuyStop(lots, entry_price, symbol, stop_loss, take_profit, ORDER_TIME_SPECIFIED, experation, comment);
+      }
+   }
+   return true;
+}
+
+bool EntryOrders::open_sell_stop_order(string symbol, bool condition, double entry_price, datetime experation,
+                                       ENUM_TIMEFRAMES atr_period, string _sl_mode, double sl_var, string _tp_mode,
+                                       double tp_var, string _lot_mode, double lot_var, long magic_number) {
+   if (condition) {
+      total_open_sell_orders = count_open_positions(symbol, 2, magic_number);
+      if (total_open_sell_orders == 0) {
+         stop_loss = calc.calculate_stoploss(symbol, entry_price, 2, _sl_mode, sl_var, atr_period);
+         take_profit = calc.calculate_take_profit(symbol, entry_price, stop_loss, 2, _tp_mode, tp_var, atr_period);
+         double sl_distance = stop_loss - entry_price;
+         double lots = calc.calculate_lots(symbol, sl_distance, entry_price, _lot_mode, lot_var);
+         trade.SetExpertMagicNumber(magic_number);
+         string comment = "Magic Number: " + IntegerToString(magic_number);
+         trade.SellStop(lots, entry_price, symbol, stop_loss, take_profit, ORDER_TIME_SPECIFIED, experation, comment);
+      }
+   }
+   return true;
+}
@@ -0,0 +1,153 @@
+#include <Trade/Trade.mqh>
+#include <MyLibs/Utils/TimeZones.mqh>
+#include <MyLibs/Orders/CalculatePositionData.mqh>
+
+class ExitOrders {
+
+   protected:
+      CTrade trade;
+      TimeZones tz;
+      CalculatePositionData cpd;
+
+      ulong posTicket;
+      long position_open_time;
+      long first_allowed_close_time;
+
+   public:
+      bool close_buy_orders(string symbol, bool condition, int close_bars, ENUM_TIMEFRAMES close_bar_period,long magic_number);
+      bool close_sell_orders(string symbol, bool condition, int close_bars, ENUM_TIMEFRAMES close_bar_period,long magic_number);
+      bool daily_timed_exit(string symbol, datetime exit_time, int delay_days, long magic_number);
+      bool daily_timed_profit_exit(string symbol, ENUM_TIMEFRAMES close_bar_period, string exit_time, string cw_tzone, int delay_days, long magic_number);
+      bool first_profitable_close_exit(string symbol, ENUM_TIMEFRAMES close_bar_period, long magic_number);
+};
+
+
+bool ExitOrders::close_buy_orders(string symbol, bool condition, int close_bars, ENUM_TIMEFRAMES close_bar_period,
+                                  long magic_number) {
+
+   for (int i = PositionsTotal() - 1; i >= 0; i--) {
+      posTicket = PositionGetTicket(i);
+
+      if (PositionGetString(POSITION_SYMBOL) == symbol && PositionGetInteger(POSITION_MAGIC) == magic_number) {
+         int time_difference = Bars(symbol, close_bar_period, PositionGetInteger(POSITION_TIME), TimeCurrent()) - 1;
+
+         if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) {
+            if (condition || (close_bars > 0 && time_difference >= close_bars)) {
+               trade.PositionClose(posTicket);
+            }
+         }
+      }
+   }
+   return true;
+}
+
+
+bool ExitOrders::close_sell_orders(string symbol, bool condition, int close_bars, ENUM_TIMEFRAMES close_bar_period,
+                                   long magic_number) {
+
+   for (int i = PositionsTotal() - 1; i >= 0; i--) {
+      posTicket = PositionGetTicket(i);
+
+      if (PositionGetString(POSITION_SYMBOL) == symbol && PositionGetInteger(POSITION_MAGIC) == magic_number) {
+         int time_difference = Bars(symbol, close_bar_period, PositionGetInteger(POSITION_TIME), TimeCurrent()) - 1;
+
+         if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL) {
+            if (condition || (close_bars > 0 && time_difference >= close_bars)) {
+               trade.PositionClose(posTicket);
+            }
+         }
+      }
+   }
+   return true;
+}
+
+
+bool ExitOrders::daily_timed_exit(string symbol, datetime exit_time, int delay_days, long magic_number) {
+
+   for (int i = PositionsTotal() - 1; i >= 0; i--) {
+      posTicket = PositionGetTicket(i);
+      position_open_time = PositionGetInteger(POSITION_TIME);
+
+      if ((int)position_open_time > 0) {
+         first_allowed_close_time = position_open_time + (delay_days * PeriodSeconds(PERIOD_D1));
+
+         if (TimeCurrent() > first_allowed_close_time && TimeCurrent() >= exit_time) {
+            if (PositionGetString(POSITION_SYMBOL) == symbol && PositionGetInteger(POSITION_MAGIC) == magic_number) {
+               trade.PositionClose(posTicket);
+            }
+         }
+      }
+   }
+   return true;
+}
+
+
+bool ExitOrders::daily_timed_profit_exit(string symbol, ENUM_TIMEFRAMES close_bar_period, string exit_time,
+                                         string cw_tzone, int delay_days, long magic_number) {
+
+   for (int i = PositionsTotal() - 1; i >= 0; i--) {
+      posTicket = PositionGetTicket(i);
+      position_open_time = PositionGetInteger(POSITION_TIME);
+
+      if ((int)position_open_time > 0) {
+         first_allowed_close_time = position_open_time + (delay_days * PeriodSeconds(PERIOD_D1));
+
+         if (TimeCurrent() > first_allowed_close_time) {
+            datetime broker_close_time = tz.timezone_conversions(cw_tzone, StringToTime(exit_time), "Broker");
+
+            if (TimeCurrent() >= broker_close_time &&
+                PositionGetString(POSITION_SYMBOL) == symbol &&
+                PositionGetInteger(POSITION_MAGIC) == magic_number) {
+
+               double position_open_price = PositionGetDouble(POSITION_PRICE_OPEN);
+               double spread = SymbolInfoDouble(symbol, SYMBOL_ASK) - SymbolInfoDouble(symbol, SYMBOL_BID);
+               double bar_close = iClose(_Symbol, close_bar_period, 1); // shift 1 because 0 is live candle
+               double trading_cost = cpd.calculate_trading_cost(symbol, posTicket);
+
+               if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY &&
+                   bar_close > (position_open_price + spread + trading_cost)) {
+                  trade.PositionClose(posTicket);
+               }
+
+               if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL &&
+                   bar_close < (position_open_price - spread - trading_cost)) {
+                  trade.PositionClose(posTicket);
+               }
+            }
+         }
+      }
+   }
+   return true;
+}
+
+
+bool ExitOrders::first_profitable_close_exit(string symbol, ENUM_TIMEFRAMES close_bar_period, long magic_number) {
+
+   position_open_time = PositionGetInteger(POSITION_TIME);
+   first_allowed_close_time = position_open_time + PeriodSeconds(close_bar_period);
+
+   if ((int)position_open_time > 0 && TimeCurrent() > first_allowed_close_time) {
+      for (int i = PositionsTotal() - 1; i >= 0; i--) {
+         posTicket = PositionGetTicket(i);
+
+         if (PositionGetString(POSITION_SYMBOL) == symbol && PositionGetInteger(POSITION_MAGIC) == magic_number) {
+            double position_open_price = PositionGetDouble(POSITION_PRICE_OPEN);
+            double spread = SymbolInfoDouble(symbol, SYMBOL_ASK) - SymbolInfoDouble(symbol, SYMBOL_BID);
+            double bar_close = iClose(_Symbol, close_bar_period, 1);
+            double trading_cost = cpd.calculate_trading_cost(symbol, posTicket);
+
+            if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY &&
+                bar_close > (position_open_price + spread + trading_cost)) {
+               trade.PositionClose(posTicket);
+            }
+
+            if (PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL &&
+                bar_close < (position_open_price - spread - trading_cost)) {
+               trade.PositionClose(posTicket);
+            }
+         }
+      }
+   }
+
+   return true;
+}
@@ -0,0 +1,69 @@
+#include <Trade/OrderInfo.mqh>
+#include <Trade/PositionInfo.mqh>
+
+class OrderTracker {
+
+   protected:
+      COrderInfo m_order;
+      CPositionInfo m_position;
+
+   public:
+      int count_open_positions(string symbol, int order_side, long magic_number);
+      int count_all_positions(string symbol, long magic_number);
+      int count_pending_orders(string symbol, ENUM_ORDER_TYPE order_type, long magic);
+};
+
+int OrderTracker::count_open_positions(string symbol, int order_side, long magic_number) {
+   int count = 0;
+
+   for (int i = PositionsTotal() - 1; i >= 0; i--) {
+      ulong ticket = PositionGetTicket(i);
+
+      if (PositionGetString(POSITION_SYMBOL) == symbol &&
+          PositionGetInteger(POSITION_MAGIC) == magic_number) {
+
+         if (order_side == 1 && PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY) {
+            count++;
+         }
+
+         if (order_side == 2 && PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL) {
+            count++;
+         }
+      }
+   }
+
+   return count;
+}
+
+
+int OrderTracker::count_all_positions(string symbol, long magic_number) {
+   int count = 0;
+
+   for (int i = PositionsTotal() - 1; i >= 0; i--) {
+      ulong ticket = PositionGetTicket(i);
+
+      if (PositionGetString(POSITION_SYMBOL) == symbol &&
+          PositionGetInteger(POSITION_MAGIC) == magic_number) {
+         count++;
+      }
+   }
+
+   return count;
+}
+
+
+int OrderTracker::count_pending_orders(string symbol, ENUM_ORDER_TYPE order_type, long magic) {
+   int count = 0;
+
+   for (int i = OrdersTotal() - 1; i >= 0; i--) {
+      if (m_order.SelectByIndex(i)) {
+         if (OrderGetInteger(ORDER_MAGIC) == magic && OrderGetString(ORDER_SYMBOL) == symbol) {
+            if (m_order.OrderType() == order_type) {
+               count++;
+            }
+         }
+      }
+   }
+
+   return count;
+}
@@ -0,0 +1,21 @@
+class StopLogic {
+   public:
+      double sl_specified_value_switch(string sl_mode, double inp_sl_var, double value);
+      double tp_specified_value_switch(string tp_mode, double inp_tp_var, double value);
+};
+
+double StopLogic::sl_specified_value_switch(string sl_mode, double inp_sl_var, double value) {
+   if (sl_mode == "SL_SPECIFIED_VALUE") {
+      return value;
+   } else {
+      return inp_sl_var;
+   }
+}
+
+double StopLogic::tp_specified_value_switch(string tp_mode, double inp_tp_var, double value) {
+   if (tp_mode == "SL_SPECIFIED_VALUE") {
+      return value;
+   } else {
+      return inp_tp_var;
+   }
+}
@@ -0,0 +1,95 @@
+#include <Trade/Trade.mqh>
+
+class TrailingLogic {
+
+   protected:
+      CTrade trade;
+
+   public:
+      void break_even_stop(string symbol, ulong magic_number, int be_trigger_points, int be_puffer);
+      void nnfx_trailing_stop(string symbol, double sl_var, double tp_var, double atr_value, ulong magic_number);
+};
+
+
+void TrailingLogic::break_even_stop(string symbol, ulong magic_number, int be_trigger_points, int be_puffer) {
+   for (int i = PositionsTotal() - 1; i >= 0; i--) {
+      if (PositionGetString(POSITION_SYMBOL) == symbol && PositionGetInteger(POSITION_MAGIC) == magic_number) {
+
+         int symbol_digits = (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS);
+         double symbol_point = SymbolInfoDouble(symbol, SYMBOL_POINT);
+         double ask = NormalizeDouble(SymbolInfoDouble(symbol, SYMBOL_ASK), symbol_digits);
+         double bid = NormalizeDouble(SymbolInfoDouble(symbol, SYMBOL_BID), symbol_digits);
+
+         if (be_trigger_points != 0) {
+            ulong ticket = PositionGetTicket(i);
+            if (PositionSelectByTicket(ticket)) {
+               double position_open_price = PositionGetDouble(POSITION_PRICE_OPEN);
+               double position_volume = PositionGetDouble(POSITION_VOLUME);
+               double position_sl = PositionGetDouble(POSITION_SL);
+               double position_tp = PositionGetDouble(POSITION_TP);
+               ENUM_POSITION_TYPE position_type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
+
+               if (position_type == POSITION_TYPE_BUY &&
+                   bid > position_open_price + be_trigger_points * symbol_point) {
+
+                  double sl = NormalizeDouble(position_open_price + be_puffer * symbol_point, symbol_digits);
+                  if (sl > position_sl) {
+                     trade.PositionModify(ticket, sl, position_tp);
+                     Print("-----------------------------------Stop moved to break even");
+                  }
+               }
+
+               if (position_type == POSITION_TYPE_SELL &&
+                   ask < position_open_price - be_trigger_points * symbol_point) {
+
+                  double sl = NormalizeDouble(position_open_price - be_puffer * symbol_point, symbol_digits);
+                  if (sl < position_sl) {
+                     trade.PositionModify(ticket, sl, position_tp);
+                     Print("-----------------------------------Stop moved to break even");
+                  }
+               }
+            }
+         }
+      }
+   }
+}
+
+
+void TrailingLogic::nnfx_trailing_stop(string symbol, double sl_var, double tp_var, double atr_value, ulong magic_number) {
+
+   for (int i = PositionsTotal() - 1; i >= 0; i--) {
+      ulong ticket = PositionGetTicket(i);
+      if (PositionSelectByTicket(ticket)) {
+         if (PositionGetString(POSITION_SYMBOL) == symbol && PositionGetInteger(POSITION_MAGIC) == magic_number) {
+
+            int symbol_digits = (int)SymbolInfoInteger(symbol, SYMBOL_DIGITS);
+            double symbol_point = SymbolInfoDouble(symbol, SYMBOL_POINT);
+            double ask = NormalizeDouble(SymbolInfoDouble(symbol, SYMBOL_ASK), symbol_digits);
+            double bid = NormalizeDouble(SymbolInfoDouble(symbol, SYMBOL_BID), symbol_digits);
+
+            double position_open_price = PositionGetDouble(POSITION_PRICE_OPEN);
+            double position_sl = PositionGetDouble(POSITION_SL);
+            double position_tp = PositionGetDouble(POSITION_TP);
+            ENUM_POSITION_TYPE position_type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
+
+            if (position_type == POSITION_TYPE_BUY &&
+                bid > position_open_price + (atr_value * tp_var)) {
+
+               double sl = NormalizeDouble(bid - (atr_value * sl_var), symbol_digits);
+               if (sl > (position_sl + (atr_value * 0.5))) {
+                  trade.PositionModify(ticket, sl, position_tp);
+               }
+            }
+
+            if (position_type == POSITION_TYPE_SELL &&
+                ask < position_open_price - (atr_value * tp_var)) {
+
+               double sl = NormalizeDouble(ask + (atr_value * sl_var), symbol_digits);
+               if (sl < (position_sl + (atr_value * 0.5))) {
+                  trade.PositionModify(ticket, sl, position_tp);
+               }
+            }
+         }
+      }
+   }
+}