FreelanceSecciones

Need errors to be fixed on my mql5 language mt5 code

MQL5 Indicadores Asesores Expertos Fórex Depuración de robots/indicadores

Tarea técnica

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));
}
)


Han respondido

1
Desarrollador 1
Evaluación
(75)
Proyectos
111
50%
Arbitraje
26
31% / 50%
Caducado
9
8%
Libre
2
Desarrollador 2
Evaluación
(258)
Proyectos
322
30%
Arbitraje
34
26% / 65%
Caducado
10
3%
Trabaja
3
Desarrollador 3
Evaluación
Proyectos
0
0%
Arbitraje
0
Caducado
0
Libre
4
Desarrollador 4
Evaluación
(8)
Proyectos
7
0%
Arbitraje
3
0% / 100%
Caducado
2
29%
Libre
Solicitudes similares
Profitable EA for Gold in sideways and trending both market 30+ USD
I have a EA for XAUUSD which works awesome in sideways and trending market as well, capital requirement is only 2000USd and weekly profit is around 1500-2000 USD. I am using this bot from 3 months and getting continuous good result
My expert needs logic adjustment . Present logic needs correct implementation . 30+ USD
Expert should be able to place trades across all Forex symbols (solution is advised) . xauusd live chart execution error . Deletion and Cleaning the Code (if required) . Live Chart Only
Want to automate my strategy in forex gold 30 - 100 USD
Dear All i am working on strategy in forex market specifically in xausud and i just want someone to make it automatic execution mode as per my requirements with propee risk management my broker is exness and i have an account in MT5
Experienced MT5/MQL5 programmer to build Expert Advisor for trading the EUR/USD using WMAs and TSI. 40 - 60 USD
I am looking for an experienced MT5/MQL5 programmer to build Phase 1 of a larger Expert Advisor project. This first phase is limited to one custom signal only for the EUR/USD. If Phase 1 is completed correctly, additional signals may be added later as separate follow-up projects. The purpose of Phase 1 is to code, test, display, and log this signal accurately using completed M1 bars only. At this stage, I primarily
Tradingview Script to EA 30+ USD
✅ MT4 EA Developer Checklist (For Your Ladder EA) 1️⃣ Indicator Integration EA reads signals from provided custom indicator (.ex4 or .mq4) Detects “Buy Next” / “Sell Next” signals on current candle Works with arrow-based or buffer-based signals 2️⃣ Next Candle Execution EA does not trade on the candle where the signal appears Orders placed only at first tick of the next candle Timeframes supported: M1, M5, M15
Modification of grid EA 30 - 80 USD
Hi to all, I need a modification of an existing grid EA with the following instructions: Add the following optional external inputs to the attached Expert Advisor: input bool TradeModeAgainstTrend ( TMAT ) = true ; input int CounterTrendLotsToStartTMAT = 0.15 ; input double CoefficientForTrendLots = 0.30 ; input double MaxTrendLot = 0.08 ; input bool OneSideTMATOnly = true ; input double CombinedClosureAmount = 10.0
PROFITABLE AI BOTS FOR MT5 AND CTRADER 100 - 200 USD
Hello, i need expert developer that have been develop so many profitable AI bots that work for mt5 and ctrader autonomously if you know you can easily execute this requirement bid for it. NOTE:- YOU MUST COME WITH SAMPLE FOR THE 2 TRADING PLATFORM. While i take a look at your profile and reach out to you thanks
Gold robot 3000+ USD
I really liked this training platform. I want to start a good business with this funding amount."I like crypto trading. Does it provide a demo account that is good for learning?"
Gold robot 3000+ USD
Create a MT4/MT5 Expert Advisor by reverse engineering and analyzing trading history reports 50 - 200 USD
Hello, I am looking for someone who can help me to build a MT4/MT5 forex EA, by analyzing the trading history. You are responsible to find out trading logic behind the EA and Build a new EA that accurately replicates the existing strategy. I need someone who has proven previous experience to build a new EA by reverse engineering. Thanks

Información sobre el proyecto

Presupuesto
30+ USD
Plazo límite de ejecución
de 1 a 2 día(s)