프리랜스섹션

Need errors to be fixed on my mql5 language mt5 code

MQL5 지표 전문가 Forex Trading robot/indicator debugging

명시

this is not the whole code though(//+------------------------------------------------------------------+
//|                                                        Trade.mqh |
//|                             Copyright 2000-2024, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#include <Object.mqh>
#include "OrderInfo.mqh"
#include "HistoryOrderInfo.mqh"
#include "PositionInfo.mqh"
#include "DealInfo.mqh"
#include <Trade\Trade.mqh>

//+------------------------------------------------------------------+
//| enumerations                                                     |
//+------------------------------------------------------------------+
enum ENUM_LOG_LEVELS
{
    LOG_LEVEL_NO = 0,
    LOG_LEVEL_ERRORS = 1,
    LOG_LEVEL_ALL = 2
};

//+------------------------------------------------------------------+
//| Class CTrade.                                                    |
//| Appointment: Class trade operations.                             |
//|              Derives from class CObject.                         |
//+------------------------------------------------------------------+
class CTrade : public CObject
{
protected:
    MqlTradeRequest m_request;              // request data
    MqlTradeResult m_result;                 // result data
    MqlTradeCheckResult m_check_result;      // result check data
    bool m_async_mode;                      // trade mode
    ulong m_magic;                           // expert magic number
    ulong m_deviation;                      // deviation default
    ENUM_ORDER_TYPE_FILLING m_type_filling;
    ENUM_ACCOUNT_MARGIN_MODE m_margin_mode;
    //---
    ENUM_LOG_LEVELS m_log_level;

public:
    CTrade(void);
    ~CTrade(void);
    //--- methods of access to protected data
    void LogLevel(const ENUM_LOG_LEVELS log_level) { m_log_level = log_level; }
    void Request(MqlTradeRequest &m_request) const;
    ENUM_TRADE_REQUEST_ACTIONS RequestAction(void) const { return (m_request.action); }
    string RequestActionDescription(void) const;
    ulong RequestMagic(void) const { return (m_request.magic); }
    ulong RequestOrder(void) const { return (m_request.order); }
    ulong RequestPosition(void) const { return (m_request.position); }
    ulong RequestPositionBy(void) const { return (m_request.position_by); }
    string RequestSymbol(void) const { return (m_request.symbol); }
    double RequestVolume(void) const { return (m_request.volume); }
    double RequestPrice(void) const { return (m_request.price); }
    double RequestStopLimit(void) const { return (m_request.stoplimit); }
    double RequestSL(void) const { return (m_request.sl); }
    double RequestTP(void) const { return (m_request.tp); }
    ulong RequestDeviation(void) const { return (m_request.deviation); }
    ENUM_ORDER_TYPE RequestType(void) const { return (m_request.type); }
    string RequestTypeDescription(void) const;
    ENUM_ORDER_TYPE_FILLING RequestTypeFilling(void) const { return (m_request.type_filling); }
    string RequestTypeFillingDescription(void) const;
    ENUM_ORDER_TYPE_TIME RequestTypeTime(void) const { return (m_request.type_time); }
    string RequestTypeTimeDescription(void) const;
    datetime RequestExpiration(void) const { return (m_request.expiration); }
    string RequestComment(void) const { return (m_request.comment); }
    //---
    void Result(MqlTradeResult &m_result) const;
    uint ResultRetcode(void) const { return (m_result.retcode); }
    string ResultRetcodeDescription(void) const;
    int ResultRetcodeExternal(void) const { return (m_result.retcode_external); }
    ulong ResultDeal(void) const { return (m_result.deal); }
    ulong ResultOrder(void) const { return (m_result.order); }
    double ResultVolume(void) const { return (m_result.volume); }
    double ResultPrice(void) const { return (m_result.price); }
    double ResultBid(void) const { return (m_result.bid); }
    double ResultAsk(void) const { return (m_result.ask); }
    string ResultComment(void) const { return (m_result.comment); }
    //---
    void CheckResult(MqlTradeCheckResult &m_check_result) const;
    uint CheckResultRetcode(void) const { return (m_check_result.retcode); }
    string CheckResultRetcodeDescription(void) const;
    double CheckResultBalance(void) const { return (m_check_result.balance); }
    double CheckResultEquity(void) const { return (m_check_result.equity); }
    double CheckResultProfit(void) const { return (m_check_result.profit); }
    double CheckResultMargin(void) const { return (m_check_result.margin); }
    double CheckResultMarginFree(void) const { return (m_check_result.margin_free); }
    double CheckResultMarginLevel(void) const { return (m_check_result.margin_level); }
    string CheckResultComment(void) const { return (m_check_result.comment); }
    //--- trade methods
    void SetAsyncMode(const bool mode) { m_async_mode = mode; }
    void SetExpertMagicNumber(const ulong magic) { m_magic = magic; }
    void SetDeviationInPoints(const ulong deviation) { m_deviation = deviation; }
    void SetTypeFilling(const ENUM_ORDER_TYPE_FILLING filling) { m_type_filling = filling; }
    bool SetTypeFillingBySymbol(const string symbol);
    void SetMarginMode(void) { m_margin_mode = (ENUM_ACCOUNT_MARGIN_MODE)AccountInfoInteger(ACCOUNT_MARGIN_MODE); }
    //--- methods for working with positions
    bool PositionOpen(const string symbol, const ENUM_ORDER_TYPE order_type, const double volume,
                      const double price, const double sl, const double tp, const string comment = "");
    bool PositionModify(const string symbol, const double sl, const double tp);
    bool PositionModify(const ulong ticket, const double sl, const double tp);
    bool PositionClose(const string symbol, const ulong deviation = ULONG_MAX);
    bool PositionClose(const ulong ticket, const ulong deviation = ULONG_MAX);
    bool PositionCloseBy(const ulong ticket, const ulong ticket_by);
    bool PositionClosePartial(const string symbol, const double volume, const ulong deviation = ULONG_MAX);
    bool PositionClosePartial(const ulong ticket, const double volume, const ulong deviation = ULONG_MAX);
    //--- methods for working with pending orders
    bool OrderOpen(const string symbol, const ENUM_ORDER_TYPE order_type, const double volume,
                   const double limit_price, const double price, const double sl, const double tp,
                   ENUM_ORDER_TYPE_TIME type_time = ORDER_TIME_GTC, const datetime expiration = 0,
                   const string comment = "");
    bool OrderModify(const ulong ticket, const double price, const double sl, const double tp,
                     const ENUM_ORDER_TYPE_TIME type_time, const datetime expiration, const double stoplimit = 0.0);
    bool OrderDelete(const ulong ticket);
    //--- additions methods
    bool Buy(const double volume, const string symbol = NULL, double price = 0.0, const double sl = 0.0, const double tp = 0.0, const string comment = "");
    bool Sell(const double volume, const string symbol = NULL, double price = 0.0, const double sl = 0.0, const double tp = 0.0, const string comment = "");
    bool BuyLimit(const double volume, const double price, const string symbol = NULL, const double sl = 0.0, const double tp = 0.0,
                  const ENUM_ORDER_TYPE_TIME type_time = ORDER_TIME_GTC, const datetime expiration = 0, const string comment = "");
    bool BuyStop(const double volume, const double price, const string symbol = NULL, const double sl = 0.0, const double tp = 0.0,
                 const ENUM_ORDER_TYPE_TIME type_time = ORDER_TIME_GTC, const datetime expiration = 0, const string comment = "");
    bool SellLimit(const double volume, const double price, const string symbol = NULL, const double sl = 0.0, const double tp = 0.0,
                   const ENUM_ORDER_TYPE_TIME type_time = ORDER_TIME_GTC, const datetime expiration = 0, const string comment = "");
    bool SellStop(const double volume, const double price, const string symbol = NULL, const double sl = 0.0, const double tp = 0.0,
                  const ENUM_ORDER_TYPE_TIME type_time = ORDER_TIME_GTC, const datetime expiration = 0, const string comment = "");
    //--- method check
    double CheckVolume(const string symbol, double volume, double price, ENUM_ORDER_TYPE order_type);
    bool OrderCheck(const MqlTradeRequest &m_request, MqlTradeCheckResult &m_check_result);
    bool OrderSend(const MqlTradeRequest &m_request, MqlTradeResult &m_result);
    //--- info methods
    void PrintRequest(void) const;
    void PrintResult(void) const;
    //--- positions
    string FormatPositionType(string &str, const uint type) const;
    //--- orders
    string FormatOrderType(string &str, const uint type) const;
    string FormatOrderStatus(string &str, const uint status) const;
    string FormatOrderTypeTime(string &str, const uint type) const;
   string            FormatOrderPrice(string &str,const double price_order,const double price_trigger,const uint digits) const;
   //--- trade request
   string            FormatRequest(string &str,const MqlTradeRequest &m_request) const;
   string            FormatRequestResult(string &str,const MqlTradeRequest &m_request,const MqlTradeResult &m_result) const;
//--- trade result description
    string GetRetcodeDescription(const int code);
    //--- helpers
    double RoundToStep(double value, const string symbol);
    double GetRisk(double volume, double entry, double sl, string symbol);
protected:
   bool              FillingCheck(const string symbol);
   bool              ExpirationCheck(const string symbol);
   bool              OrderTypeCheck(const string symbol);
   void              ClearStructures(void);
   bool              IsStopped(const string function);
   bool              IsHedging(void) const { return(m_margin_mode==ACCOUNT_MARGIN_MODE_RETAIL_HEDGING); }
   //--- position select depending on netting or hedging
   bool              SelectPosition(const string symbol);
  };
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CTrade::CTrade(void) : m_async_mode(false),
                       m_magic(0),
                       m_deviation(10),
                       m_type_filling(ORDER_FILLING_FOK),
                       m_log_level(LOG_LEVEL_ERRORS)
  {
   SetMarginMode();
//--- initialize protected data
   ClearStructures();
//--- check programm mode
   if(MQL5InfoInteger(MQL5_TESTING))
      m_log_level=LOG_LEVEL_ALL;
   if(MQL5InfoInteger(MQL5_OPTIMIZATION))
      m_log_level=LOG_LEVEL_NO;
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CTrade::~CTrade(void)
  {
  }
// Placeholder function definitions (assuming these return strings and take no parameters)

// Returns a string for the request action
string FormatRequest()
{
   return "Request Action";
}

// Returns a string for the order type
string FormatOrderType() 
{
   return "Order Type";
}

// Returns a string for the order type filling
string FormatOrderTypeFilling()
{
   return "Order Type Filling";
}

// Returns a string for the order type time
string FormatOrderTypeTime()
{
   return "Order Type Time";
}

// Returns a string for the request result
string FormatRequestResult()
{
   return "Request Result";
}

//+------------------------------------------------------------------+ 
//| Get the request structure                                        |
//+------------------------------------------------------------------+
void Request(MqlTradeRequest &m_request)
{
   m_request.action      = m_request.action;
   m_request.magic       = m_request.magic;
   m_request.order       = m_request.order;
   m_request.symbol      = m_request.symbol;
   m_request.volume      = m_request.volume;
   m_request.price       = m_request.price;
   m_request.stoplimit   = m_request.stoplimit;
   m_request.sl          = m_request.sl;
   m_request.tp          = m_request.tp;
   m_request.deviation   = m_request.deviation;
   m_request.type        = m_request.type;
   m_request.type_filling = m_request.type_filling;
   m_request.type_time   = m_request.type_time;
   m_request.expiration  = m_request.expiration;
   m_request.comment     = m_request.comment;
   m_request.position    = m_request.position;
   m_request.position_by = m_request.position_by;
}

//+------------------------------------------------------------------+
//| Get the trade action as string                                   |
//+------------------------------------------------------------------+
string RequestActionDescription(void)
{
   return FormatRequest(); // Calls FormatRequest to get action description
}

//+------------------------------------------------------------------+
//| Get the order type as string                                     |
//+------------------------------------------------------------------+
string RequestTypeDescription(void)
{
   return FormatOrderType(); // Calls FormatOrderType to get type description
}

//+------------------------------------------------------------------+
//| Get the order type filling as string                             |
//+------------------------------------------------------------------+
string RequestTypeFillingDescription(void)
{
   return FormatOrderTypeFilling(); // Calls FormatOrderTypeFilling to get filling description
}

//+------------------------------------------------------------------+
//| Get the order type time as string                                |
//+------------------------------------------------------------------+
string RequestTypeTimeDescription(void)
{
   return FormatOrderTypeTime(); // Calls FormatOrderTypeTime to get time description
}

//+------------------------------------------------------------------+
//| Get the result structure                                         |
//+------------------------------------------------------------------+
void Result(MqlTradeResult &m_result)
{
   m_result.retcode         = m_result.retcode;
   m_result.deal            = m_result.deal;
   m_result.order           = m_result.order;
   m_result.volume          = m_result.volume;
   m_result.price           = m_result.price;
   m_result.bid             = m_result.bid;
   m_result.ask             = m_result.ask;
   m_result.comment         = m_result.comment;
   m_result.request_id      = m_result.request_id;
   m_result.retcode_external = m_result.retcode_external;
}

//+------------------------------------------------------------------+
//| Get the retcode value as string                                  |
//+------------------------------------------------------------------+
string ResultRetcodeDescription(void)
{
   return FormatRequestResult(); // Calls FormatRequestResult to get retcode description
}

//+------------------------------------------------------------------+
//| Get the check result structure                                   |
//+------------------------------------------------------------------+
void CheckResult(MqlTradeCheckResult &m_check_result)
{
   m_check_result.retcode     = m_check_result.retcode;
   m_check_result.balance     = m_check_result.balance;
   m_check_result.equity      = m_check_result.equity;
   m_check_result.profit      = m_check_result.profit;
   m_check_result.margin      = m_check_result.margin;
   m_check_result.margin_free = m_check_result.margin_free;
   m_check_result.margin_level = m_check_result.margin_level;
   m_check_result.comment     = m_check_result.comment;
}

//+------------------------------------------------------------------+
//| Get the check retcode value as string                            |
//+------------------------------------------------------------------+
string CheckResultRetcodeDescription(void)
{
   return FormatRequestResult(); // Calls FormatRequestResult to get check retcode description
}

//+------------------------------------------------------------------+
//| Open position                                                    |
//+------------------------------------------------------------------+
bool CTrade::PositionOpen(const string symbol, const ENUM_ORDER_TYPE order_type, const double volume,
                          const double price, const double sl, const double tp, const string comment)
{
   //--- check stopped
   if (IsStopped(__FUNCTION__))
      return(false);
   //--- clean
   ClearStructures();
   //--- check
   if (order_type != ORDER_TYPE_BUY && order_type != ORDER_TYPE_SELL)
   {
      m_result.retcode = TRADE_RETCODE_INVALID;
      m_result.comment = "Invalid order type";
      return(false);
   }
   //--- setting request
   m_request.action = TRADE_ACTION_DEAL;
   m_request.symbol = symbol;
   m_request.magic = m_magic;
   m_request.volume = volume;
   m_request.type = order_type;
   m_request.price = price;
   m_request.sl = sl;
   m_request.tp = tp;
   m_request.deviation = m_deviation;
   //--- check order type
   if (!OrderTypeCheck(symbol))
      return(false);
   //--- check filling
   if (!FillingCheck(symbol))
      return(false);
   m_request.comment = comment;
   //--- action and return the result
   return(OrderSend(m_request, m_result));
}
//+------------------------------------------------------------------+
//| Modify specified opened position                                 |
//+------------------------------------------------------------------+
bool CTrade::PositionModify(const string symbol, const double sl, const double tp)
{
   //--- check stopped
   if (IsStopped(__FUNCTION__))
      return(false);
   //--- check position existence
   if (!SelectPosition(symbol))
      return(false);
   //--- clean
   ClearStructures();
   //--- setting request
   m_request.action = TRADE_ACTION_SLTP;
   m_request.symbol = symbol;
   m_request.magic = m_magic;
   m_request.sl = sl;
   m_request.tp = tp;
   m_request.position = PositionGetInteger(POSITION_TICKET);
   //--- action and return the result
   return(OrderSend(m_request, m_result));
}
//+------------------------------------------------------------------+
//| Modify specified opened position                                 |
//+------------------------------------------------------------------+
bool CTrade::PositionModify(const ulong ticket, const double sl, const double tp)
{
   //--- check stopped
   if (IsStopped(__FUNCTION__))
      return(false);
   //--- check position existence
   if (!PositionSelectByTicket(ticket))
      return(false);
   //--- clean
   ClearStructures();
   //--- setting request
   m_request.action = TRADE_ACTION_SLTP;
   m_request.position = ticket;
   m_request.symbol = PositionGetString(POSITION_SYMBOL);
   m_request.magic = m_magic;
   m_request.sl = sl;
   m_request.tp = tp;
   //--- action and return the result
   return(OrderSend(m_request, m_result));
}
//+------------------------------------------------------------------+
//| Close specified opened position                                  |
//+------------------------------------------------------------------+
bool CTrade::PositionClose(const string symbol, const ulong deviation)
{
   bool partial_close = false;
   int retry_count = 10;
   uint retcode = TRADE_RETCODE_REJECT;
   //--- check stopped
   if (IsStopped(__FUNCTION__))
      return(false);
   //--- clean
   ClearStructures();
   //--- check filling
   if (!FillingCheck(symbol))
      return(false);
   do
   {
      //--- check
      if (SelectPosition(symbol))
      {
         if ((ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
         {
            //--- prepare request for close BUY position
            m_request.type = ORDER_TYPE_SELL;
            m_request.price = SymbolInfoDouble(symbol, SYMBOL_BID);
         }
         else
         {
            //--- prepare request for close SELL position
            m_request.type = ORDER_TYPE_BUY;
            m_request.price = SymbolInfoDouble(symbol, SYMBOL_ASK);
         }
      }
      else
      {
         //--- position not found
         m_result.retcode = retcode;
         return(false);
      }
      //--- setting request
      m_request.action = TRADE_ACTION_DEAL;
      m_request.symbol = symbol;
      m_request.volume = PositionGetDouble(POSITION_VOLUME);
      m_request.magic = m_magic;
      m_request.deviation = (deviation == ULONG_MAX) ? m_deviation : deviation;
      m_request.position = PositionGetInteger(POSITION_TICKET);
      //--- check volume
      double max_volume = SymbolInfoDouble(symbol, SYMBOL_VOLUME_MAX);
      if (m_request.volume > max_volume)
      {
         m_request.volume = max_volume;
         partial_close = true;
      }
      else
         partial_close = false;
      //--- hedging? just send order
      if (IsHedging())
         return(OrderSend(m_request, m_result));
      //--- order send
      if (!OrderSend(m_request, m_result))
      {
         if (--retry_count != 0)
            continue;
         if (retcode == TRADE_RETCODE_DONE_PARTIAL)
            m_result.retcode = retcode;
         return(false);
      }
      //--- WARNING. If position volume exceeds the maximum volume allowed for deal,
      //--- and when the asynchronous trade mode is on, for safety reasons, position is closed not completely,
      //--- but partially. It is decreased by the maximum volume allowed for deal.
      if (m_async_mode)
         break;
      retcode = TRADE_RETCODE_DONE_PARTIAL;
      if (partial_close)
         Sleep(1000);
   }
   while (partial_close);
   //--- succeed
   return(true);
}

//+------------------------------------------------------------------+
//| Close specified opened position                                  |
//+------------------------------------------------------------------+
bool CTrade::PositionClose(const ulong ticket, const ulong deviation)
{
   //--- check stopped
   if(IsStopped(__FUNCTION__))
      return(false);
   //--- check position existence
   if(!PositionSelectByTicket(ticket))
      return(false);
   string symbol = PositionGetString(POSITION_SYMBOL);
   //--- clean
   ClearStructures();
   //--- check filling
   if(!FillingCheck(symbol))
      return(false);
   //--- check position type
   if((ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
   {
      //--- prepare request for close BUY position
      m_request.type = ORDER_TYPE_SELL;
      m_request.price = SymbolInfoDouble(symbol, SYMBOL_BID);
   }
   else
   {
      //--- prepare request for close SELL position
      m_request.type = ORDER_TYPE_BUY;
      m_request.price = SymbolInfoDouble(symbol, SYMBOL_ASK);
   }
   //--- setting request
   m_request.action = TRADE_ACTION_DEAL;
   m_request.position = ticket;
   m_request.symbol = symbol;
   m_request.volume = PositionGetDouble(POSITION_VOLUME);
   m_request.magic = m_magic;
   m_request.deviation = (deviation == ULONG_MAX) ? m_deviation : deviation;
   //--- close position
   return(OrderSend(m_request, m_result));
}

//+------------------------------------------------------------------+
//| Close one position by other                                      |
//+------------------------------------------------------------------+
bool CTrade::PositionCloseBy(const ulong ticket, const ulong ticket_by)
{
   //--- check stopped
   if(IsStopped(__FUNCTION__))
      return(false);
   //--- check hedging mode
   if(!IsHedging())
      return(false);
   //--- check position existence
   if(!PositionSelectByTicket(ticket))
      return(false);
   string symbol = PositionGetString(POSITION_SYMBOL);
   ENUM_POSITION_TYPE type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
   if(!PositionSelectByTicket(ticket_by))
      return(false);
   string symbol_by = PositionGetString(POSITION_SYMBOL);
   ENUM_POSITION_TYPE type_by = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
   //--- check positions
   if(type == type_by)
      return(false);
   if(symbol != symbol_by)
      return(false);
   //--- clean
   ClearStructures();
   //--- check filling
   if(!FillingCheck(symbol))
      return(false);
   //--- setting request
   m_request.action = TRADE_ACTION_CLOSE_BY;
   m_request.position = ticket;
   m_request.position_by = ticket_by;
   m_request.magic = m_magic;
   //--- close position
   return(OrderSend(m_request, m_result));
}

//+------------------------------------------------------------------+
//| Partial close specified opened position (for hedging mode only)  |
//+------------------------------------------------------------------+
bool CTrade::PositionClosePartial(const string symbol, const double volume, const ulong deviation)
{
   uint retcode = TRADE_RETCODE_REJECT;
   //--- check stopped
   if(IsStopped(__FUNCTION__))
      return(false);
   //--- for hedging mode only
   if(!IsHedging())
      return(false);
   //--- clean
   ClearStructures();
   //--- check filling
   if(!FillingCheck(symbol))
      return(false);
   //--- check position
   if(SelectPosition(symbol))
   {
      if((ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
      {
         //--- prepare request for close BUY position
         m_request.type = ORDER_TYPE_SELL;
         m_request.price = SymbolInfoDouble(symbol, SYMBOL_BID);
      }
      else
      {
         //--- prepare request for close SELL position
         m_request.type = ORDER_TYPE_BUY;
         m_request.price = SymbolInfoDouble(symbol, SYMBOL_ASK);
      }
   }
   else
   {
      //--- position not found
      m_result.retcode = retcode;
      return(false);
   }
   //--- check volume
   double position_volume = PositionGetDouble(POSITION_VOLUME);
   if(position_volume > volume)
      position_volume = volume;
   //--- setting request
   m_request.action = TRADE_ACTION_DEAL;
   m_request.symbol = symbol;
   m_request.volume = position_volume;
   m_request.magic = m_magic;
   m_request.deviation = (deviation == ULONG_MAX) ? m_deviation : deviation;
   m_request.position = PositionGetInteger(POSITION_TICKET);
   //--- hedging? just send order
   return(OrderSend(m_request, m_result));
}

//+------------------------------------------------------------------+
//| Partial close specified opened position (for hedging mode only)  |
//+------------------------------------------------------------------+
bool CTrade::PositionClosePartial(const ulong ticket, const double volume, const ulong deviation)
{
   //--- check stopped
   if(IsStopped(__FUNCTION__))
      return(false);
   //--- for hedging mode only
   if(!IsHedging())
      return(false);
   //--- check position existence
   if(!PositionSelectByTicket(ticket))
      return(false);
   string symbol = PositionGetString(POSITION_SYMBOL);
   //--- clean
   ClearStructures();
   //--- check filling
   if(!FillingCheck(symbol))
      return(false);
   //--- check position type
   if((ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
   {
      //--- prepare request for close BUY position
      m_request.type = ORDER_TYPE_SELL;
      m_request.price = SymbolInfoDouble(symbol, SYMBOL_BID);
   }
   else
   {
      //--- prepare request for close SELL position
      m_request.type = ORDER_TYPE_BUY;
      m_request.price = SymbolInfoDouble(symbol, SYMBOL_ASK);
   }
   //--- check volume
   double position_volume = PositionGetDouble(POSITION_VOLUME);
   if(position_volume > volume)
      position_volume = volume;
   //--- setting request
   m_request.action = TRADE_ACTION_DEAL;
   m_request.position = ticket;
   m_request.symbol = symbol;
   m_request.volume = position_volume;
   m_request.magic = m_magic;
   m_request.deviation = (deviation == ULONG_MAX) ? m_deviation : deviation;
   //--- close position
   return(OrderSend(m_request, m_result));
}
)


응답함

1
개발자 1
등급
(75)
프로젝트
110
51%
중재
25
28% / 52%
기한 초과
9
8%
작업중
2
개발자 2
등급
(250)
프로젝트
313
28%
중재
34
26% / 65%
기한 초과
10
3%
작업중
3
개발자 3
등급
프로젝트
0
0%
중재
0
기한 초과
0
무료
4
개발자 4
등급
(8)
프로젝트
7
0%
중재
3
0% / 100%
기한 초과
2
29%
무료
비슷한 주문
MT5 EA Modification Needed – Replace Current Entry Logic With Breakout Strategy(USDJPY M15) & Add Prop-Firm Risk Controls 60+ USD
Hello, Please read the full specification before applying. This project is NOT about building an EA from scratch. I already have a fully working MT5 Expert Advisor. The EA already includes a dashboard, risk management, and some protection systems, but it needs a few more features . So I need an experienced MQL5 developer to modify my existing MT5 EA by replacing the current entry logic with a new breakout strategy
Editing my existing ATR Trailing Stop Indicator 30+ USD
can you help me with editing the existing ATR Trailing Stop Indicator to include a logic to include additional script, where my ninZaRenko bars when it closes above OR below the dynamic stop line, I will be out of trade. Please remember, in this Indicator, now when the price touches the stop line, I am stopped out .. . I want to edit the script, in lieu of the price touch, I like to update this logic to when the bar
TORUNZ 😎 30+ USD
The robot should use different indicators for a example smart money indicator and market structure structure and break indicators in order for it to enter the market, it should also be able to tell false breakouts is the Bollinger indicator, and if the market is confirmed to be profitable,the robot should rebuy or resell the market according to the predictions made, it should execute the trades if the market reverses
TENGO CODIGO FUENTE DE UN INDICADOR MT4 PASARLO A MT5 30+ USD
APARTE DE PASAR EL CÓDIGO A MT5 QUIERO QUE CONTENGA TODOS LOS DATOS NECESARIOS PARA QUE ESTE NUEVO CÓDIGO SE PUEDA USAR EN LA FÁBRICACIÓN DE UN ROBOT, NO SE MUCHO DE ESTO PERO INVESTIGUE QUE DEBE LEER BUFFERS Y OTRAS COSAS
Cash Flow EA 30+ USD
I want a trading robot with proper risk management and good trading strategies it must make money ,place stop loss below the entry and place a take profit no loss only wins mostly trade major
Busco robot para trading en el oro o forex. 30 - 50 USD
Busco un robot para trading de scalping en oro o forex, el robot debe ser rentable en esos mercados, podemos automatizar mi estrategia basada en medias móviles con estrategia de scalping o bien si él desarollador tiene uno que funcione así y sea rentable podemos ver la opción de un demo o cuenta de lectura para estar seguros de la rentabilidad en el robot
Create a simple EA using to mql5 indicators. 120 - 180 USD
MT4 EA TO TAKE TRADES FROM (A) HYDRA TREND RIDER AND (B) IQ GOLD GANN LEVELS ON MQL5.COM The MT4 version of these two indicators can be found on the mql5.com website with the following links: Hydra Trend Rider: https://www.mql5.com/en/market/product/111010?source=Site +Profile+Seller IQ Gold Gann Levels: https://www.mql5.com/en/market/product/134335?source=Site +Profile+Seller (1) ENTRY (a) Hydra Trend Rider
إنشاء روبوت تداول أوتوماتيكي للذهب XAUUSD باستراتيجية بسيطة 30+ USD
أنا أبحث عن مبرمج محترف لإنشاء روبوت تداول (Expert Advisor) يعمل على منصة MetaTrader 4 أو MetaTrader 5. مواصفات الروبوت: يعمل على زوج XAUUSD (الذهب) يفتح صفقة شراء أو بيع حسب الإشارة يعتمد على مؤشرين: Moving Average RSI عندما يتقاطع الموفينغ أفريج مع الاتجاه ويؤكد مؤشر RSI يتم فتح الصفقة. إدارة المخاطر: تحديد Stop Loss تحديد Take Profit عدم فتح أكثر من صفقة في نفس الوقت إمكانية تغيير الإعدادات بسهولة. مطلوب: كود نظيف
Looking to Purchase a Proven Gold Scalping EA (MT5) 30+ USD
I am looking to purchase an existing and profitable Expert Advisor (EA) designed for Gold (XAUUSD) scalping. This is not a request to develop a new EA . I am only interested in a ready system that is already trading profitably on a live account . Requirements • Designed for Gold / XAUUSD • Compatible with MetaTrader 5 (MT5) • Scalping strategy (preferably M1 or M5) • Verified live trading performance (preferably 6
Pinescript 100+ USD
I’m looking for a Pine Script developer who can reverse engineer the “Swing Only” logic of the Polytrends indicator on TradingView. The goal is to recreate how the swing trends are detected and plotted so it can be used as a custom indicator. If you have experience with TradingView Pine Script and reverse-engineering indicator logic , please reach out

프로젝트 정보

예산
30+ USD
기한
에서 1 로 2 일