MT5Bridge

#ifndef __MQL5__

#ifndef _MQL5_TYPES_
#define _MQL5_TYPES_

#property strict

#define MQL5InfoInteger MQLInfoInteger
#define MQL5InfoString  MQLInfoString

#define MQL5_OPTIMIZATION MQL_OPTIMIZATION
#define MQL5_TESTING MQL_TESTER

#define TRADE_RETCODE_REQUOTE 10004
#define TRADE_RETCODE_REJECT 10006
#define TRADE_RETCODE_CANCEL 10007
#define TRADE_RETCODE_PLACED 10008
#define TRADE_RETCODE_DONE 10009
#define TRADE_RETCODE_DONE_PARTIAL 10010
#define TRADE_RETCODE_ERROR 10011
#define TRADE_RETCODE_TIMEOUT 10012
#define TRADE_RETCODE_INVALID 10013
#define TRADE_RETCODE_INVALID_VOLUME 10014
#define TRADE_RETCODE_INVALID_PRICE 10015
#define TRADE_RETCODE_INVALID_STOPS 10016
#define TRADE_RETCODE_TRADE_DISABLED 10017
#define TRADE_RETCODE_MARKET_CLOSED 10018
#define TRADE_RETCODE_NO_MONEY 10019
#define TRADE_RETCODE_PRICE_CHANGED 10020
#define TRADE_RETCODE_PRICE_OFF 10021
#define TRADE_RETCODE_INVALID_EXPIRATION 10022
#define TRADE_RETCODE_ORDER_CHANGED 10023
#define TRADE_RETCODE_TOO_MANY_REQUESTS 10024
#define TRADE_RETCODE_NO_CHANGES 10025
#define TRADE_RETCODE_SERVER_DISABLES_AT 10026
#define TRADE_RETCODE_CLIENT_DISABLES_AT 10027
#define TRADE_RETCODE_LOCKED 10028
#define TRADE_RETCODE_FROZEN 10029
#define TRADE_RETCODE_INVALID_FILL 10030
#define TRADE_RETCODE_CONNECTION 10031
#define TRADE_RETCODE_ONLY_REAL 10032
#define TRADE_RETCODE_LIMIT_ORDERS 10033
#define TRADE_RETCODE_LIMIT_VOLUME 10034
#define TRADE_RETCODE_INVALID_ORDER 10035
#define TRADE_RETCODE_POSITION_CLOSED 10036
#define TRADE_RETCODE_INVALID_CLOSE_VOLUME 10038
#define TRADE_RETCODE_CLOSE_ORDER_EXIST 10039
#define TRADE_RETCODE_LIMIT_POSITIONS 10040

#define SYMBOL_EXPIRATION_GTC 1
#define SYMBOL_EXPIRATION_DAY 2
#define SYMBOL_EXPIRATION_SPECIFIED 4
#define SYMBOL_EXPIRATION_SPECIFIED_DAY 8

#define SYMBOL_FILLING_FOK 1
#define SYMBOL_FILLING_IOC 2

#define SYMBOL_ORDER_MARKET 1
#define SYMBOL_ORDER_LIMIT  2
#define SYMBOL_ORDER_STOP   4
#define SYMBOL_ORDER_STOP_LIMIT 8
#define SYMBOL_ORDER_SL        16
#define SYMBOL_ORDER_TP        32

enum ENUM_ORDER_TYPE_TIME
  {
   ORDER_TIME_GTC,
   ORDER_TIME_DAY,
   ORDER_TIME_SPECIFIED,
   ORDER_TIME_SPECIFIED_DAY
  };

enum ENUM_ORDER_STATE
  {
   ORDER_STATE_STARTED,
   ORDER_STATE_PLACED,
   ORDER_STATE_CANCELED,
   ORDER_STATE_PARTIAL,
   ORDER_STATE_FILLED,
   ORDER_STATE_REJECTED,
   ORDER_STATE_EXPIRED,
   ORDER_STATE_REQUEST_ADD,
   ORDER_STATE_REQUEST_MODIFY,
   ORDER_STATE_REQUEST_CANCEL
  };

enum ENUM_ORDER_TYPE_FILLING
  {
   ORDER_FILLING_FOK,
   ORDER_FILLING_IOC,
   ORDER_FILLING_RETURN
  };

#define ORDER_TICKET ((ENUM_ORDER_PROPERTY_INTEGER)-1)
#define ORDER_POSITION_ID ((ENUM_ORDER_PROPERTY_INTEGER)-2)
#define ORDER_POSITION_BY_ID ((ENUM_ORDER_PROPERTY_INTEGER)-3)

#define ORDER_EXTERNAL_ID ((ENUM_ORDER_PROPERTY_STRING)-1)

#define ORDER_TYPE_BUY_STOP_LIMIT ((ENUM_ORDER_TYPE)6)
#define ORDER_TYPE_SELL_STOP_LIMIT ((ENUM_ORDER_TYPE)7)
#define ORDER_TYPE_CLOSE_BY ((ENUM_ORDER_TYPE)8)

enum ENUM_POSITION_TYPE
  {
   POSITION_TYPE_BUY=OP_BUY,
   POSITION_TYPE_SELL=OP_SELL,
  };

enum ENUM_POSITION_PROPERTY_INTEGER
  {
   POSITION_TICKET,
   POSITION_TIME,
   POSITION_TIME_MSC,
   POSITION_TIME_UPDATE,
   POSITION_TIME_UPDATE_MSC,
   POSITION_TYPE,
   POSITION_MAGIC,
   POSITION_IDENTIFIER
  };

enum ENUM_POSITION_PROPERTY_DOUBLE
  {
   POSITION_VOLUME,
   POSITION_PRICE_OPEN,
   POSITION_SL,
   POSITION_TP,
   POSITION_PRICE_CURRENT,
   POSITION_COMMISSION,
   POSITION_SWAP,
   POSITION_PROFIT
  };

enum ENUM_POSITION_PROPERTY_STRING
  {
   POSITION_SYMBOL,
   POSITION_COMMENT
  };

enum ENUM_DEAL_ENTRY
  {
   DEAL_ENTRY_IN,//0
   DEAL_ENTRY_OUT,//1
   DEAL_ENTRY_INOUT,
   DEAL_ENTRY_STATE, // ???
   DEAL_ENTRY_OUT_BY
  };

enum ENUM_DEAL_TYPE
  {
   DEAL_TYPE_BUY,
   DEAL_TYPE_SELL,
   DEAL_TYPE_BALANCE,
   DEAL_TYPE_CREDIT,
   DEAL_TYPE_CHARGE,
   DEAL_TYPE_CORRECTION,
   DEAL_TYPE_BONUS,
   DEAL_TYPE_COMMISSION,
   DEAL_TYPE_COMMISSION_DAILY,
   DEAL_TYPE_COMMISSION_MONTHLY,
   DEAL_TYPE_COMMISSION_AGENT_DAILY,
   DEAL_TYPE_COMMISSION_AGENT_MONTHLY,
   DEAL_TYPE_INTEREST,
   DEAL_TYPE_BUY_CANCELED,
   DEAL_TYPE_SELL_CANCELED
  };

enum ENUM_DEAL_PROPERTY_INTEGER
  {
   DEAL_TICKET,
   DEAL_ORDER,
   DEAL_TIME,
   DEAL_TIME_MSC,
   DEAL_TYPE,
   DEAL_ENTRY,
   DEAL_MAGIC,
   DEAL_POSITION_ID
  };

enum ENUM_DEAL_PROPERTY_DOUBLE
  {
   DEAL_VOLUME,
   DEAL_PRICE,
   DEAL_COMMISSION,
   DEAL_SWAP,
   DEAL_PROFIT
  };

enum ENUM_DEAL_PROPERTY_STRING
  {
   DEAL_SYMBOL,
   DEAL_COMMENT
  };

enum ENUM_TRADE_REQUEST_ACTIONS
  {
   TRADE_ACTION_DEAL,
   TRADE_ACTION_PENDING,
   TRADE_ACTION_SLTP,
   TRADE_ACTION_MODIFY,
   TRADE_ACTION_REMOVE,
   TRADE_ACTION_CLOSE_BY
  };

enum ENUM_SYMBOL_CALC_MODE
  {
   SYMBOL_CALC_MODE_FOREX = 0,
   SYMBOL_CALC_MODE_CFD = 1,
   SYMBOL_CALC_MODE_FUTURES = 2,
   SYMBOL_CALC_MODE_CFDINDEX = 3,

   SYMBOL_CALC_MODE_CFDLEVERAGE = -4,
   SYMBOL_CALC_MODE_EXCH_STOCKS = -5,
   SYMBOL_CALC_MODE_EXCH_FUTURES = -6,
   SYMBOL_CALC_MODE_EXCH_FUTURES_FORTS = -7,
   SYMBOL_CALC_MODE_SERV_COLLATERAL = -8
  };

enum ENUM_SYMBOL_SWAP_MODE
  {
   SYMBOL_SWAP_MODE_POINTS = 0,
   SYMBOL_SWAP_MODE_CURRENCY_SYMBOL = 1,
   SYMBOL_SWAP_MODE_INTEREST_CURRENT = 2,
   SYMBOL_SWAP_MODE_CURRENCY_MARGIN = 3,

   SYMBOL_SWAP_MODE_DISABLED = -1,
   SYMBOL_SWAP_MODE_CURRENCY_DEPOSIT = -2,
   SYMBOL_SWAP_MODE_INTEREST_OPEN = -3,
   SYMBOL_SWAP_MODE_REOPEN_CURRENT = -4,
   SYMBOL_SWAP_MODE_REOPEN_BID = -5
  };

enum ENUM_ACCOUNT_MARGIN_MODE
  {
   ACCOUNT_MARGIN_MODE_RETAIL_NETTING, // not supported
   ACCOUNT_MARGIN_MODE_EXCHANGE, // not supported
   ACCOUNT_MARGIN_MODE_RETAIL_HEDGING
  };

bool IsExitTicket(ulong iticket)
  {
   return ((iticket & 0x8000000000000000) != 0);
  }

struct MqlTradeRequest
  {
   ENUM_TRADE_REQUEST_ACTIONS    action;           // Trade operation type
   ulong                         magic;            // Expert Advisor ID (magic number)
   ulong                         order;            // Order ticket
   string                        symbol;           // Trade symbol
   double                        volume;           // Requested volume for a deal in lots
   double                        price;            // Price
   double                        stoplimit;        // StopLimit level of the order
   double                        sl;               // Stop Loss level of the order
   double                        tp;               // Take Profit level of the order
   ulong                         deviation;        // Maximal possible deviation from the requested price
   ENUM_ORDER_TYPE               type;             // Order type
   ENUM_ORDER_TYPE_FILLING       type_filling;     // Order execution type
   ENUM_ORDER_TYPE_TIME          type_time;        // Order expiration type
   datetime                      expiration;       // Order expiration time (for the orders of ORDER_TIME_SPECIFIED type)
   string                        comment;          // Order comment
   ulong                         position;         // Position ticket
   ulong                         position_by;      // The ticket of an opposite position
  };

struct MqlTradeResult
  {
   uint              retcode;          // Operation return code
   ulong             deal;             // Deal ticket, if it is performed
   ulong             order;            // Order ticket, if it is placed
   double            volume;           // Deal volume, confirmed by broker
   double            price;            // Deal price, confirmed by broker
   double            bid;              // Current Bid price
   double            ask;              // Current Ask price
   string            comment;          // Broker comment to operation (by default it is filled by description of trade server return code)
   uint              request_id;       // Request ID set by the terminal during the dispatch
   uint              retcode_external; // Return code of an external trading system
  };

struct MqlTradeCheckResult
  {
   uint              retcode;             // Reply code
   double            balance;             // Balance after the execution of the deal
   double            equity;              // Equity after the execution of the deal
   double            profit;              // Floating profit
   double            margin;              // Margin requirements
   double            margin_free;         // Free margin
   double            margin_level;        // Margin level
   string            comment;             // Comment to the reply code (description of the error)
  };

long historyDeals[], historyOrders[];

bool HistorySelect(datetime from_date, datetime to_date)
  {

   int deals = 0, orders = 0;

   ArrayResize(historyDeals, 0);
   ArrayResize(historyOrders, 0);

   for(int i = 0; i < OrdersTotal(); i++)
     {
      if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
        {
         if((OrderOpenTime() >= from_date && OrderOpenTime() <= to_date)|| (OrderCloseTime()>=from_date && OrderCloseTime() <= to_date))
           {
            if(OrderType() <= OP_SELL) // deal
              {
               if(ArrayResize(historyDeals, deals + 1)!=-1)
                 {
                  historyDeals[deals] = OrderTicket();

                  deals++;
                 }
              }

           }
        }
     }

   for(int i = 0; i < OrdersHistoryTotal(); i++)
     {
      if(OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
        {
         if((OrderOpenTime() >= from_date && OrderOpenTime() <= to_date)|| (OrderCloseTime()>=from_date && OrderCloseTime() <= to_date))
           {
            if(OrderType() <= OP_SELL) // deal
              {
               if(ArrayResize(historyDeals, deals + 1)!=-1)
                 {
                  historyDeals[deals] = OrderTicket();

                  deals++;
                 }
              }

            if(ArrayResize(historyOrders, orders + 1)!=-1)
              {
               historyOrders[orders] = OrderTicket();

               orders++;
              }
           }
        }
     }
   return true;
  }

bool HistorySelectByPosition(ulong iticket)       //выберем все сделки по позиции
  {
   int deals = 0, orders = 0;

   ArrayResize(historyDeals, 0);
   ArrayResize(historyOrders, 0);

   if(!OrderSelect((int)iticket, SELECT_BY_TICKET))
     {
      return false;
     }

   int etype=OrderType();
   long id=OrderTicket();
   long id_position=id;

   int j=0;
   int ifind=0;

   if(etype <= OP_SELL) // deal
     {
      if(ArrayResize(historyDeals, deals + 1)!=-1)
        {
         historyDeals[deals] = id_position;
         deals++;
        }
     }

   if(ArrayResize(historyOrders, orders + 1)!=-1)
     {
      historyOrders[orders] = id_position;
      orders++;
     }

   while(j<OrdersHistoryTotal() && !IsStopped()) //востановим по истории кол-во закрытий и полный лот
     {
      if(!::OrderSelect(j,SELECT_BY_POS,MODE_HISTORY))
        {
         j++;
         continue;
        }

      if(StringCompare(OrderComment(),StringFormat("to #%lld",id),false)==0)
        {
         ifind++;

         if(ArrayResize(historyDeals, deals + 1)!=-1)
           {
            id=OrderTicket();
            historyDeals[deals] = id | 0x8000000000000000;
            deals++;
           }

         if(ArrayResize(historyOrders, orders + 1)!=-1)
           {
            historyOrders[orders] = id | 0x8000000000000000;
            orders++;
           }

         j=0;
         continue;
        }

      j++;
     }

   return true;
  }

int EnumOrderType2Code(int action) // ENUM_ORDER_TYPE
  {

   return (action % 2 == 0) ? OP_BUY : OP_SELL;
  }

ENUM_POSITION_TYPE Order2Position(int type)
  {

   return type == OP_BUY ? POSITION_TYPE_BUY : POSITION_TYPE_SELL;

  }

ENUM_ORDER_STATE OrderState()
  {
   return (ENUM_ORDER_STATE)((OrderType() > 1) ? ORDER_STATE_PLACED : ORDER_STATE_FILLED);
  }

#define OP_BALANCE 6

ENUM_DEAL_TYPE OrderType2DealType(const int type)
  {
   static ENUM_DEAL_TYPE types[] = {DEAL_TYPE_BUY, DEAL_TYPE_SELL, -1, -1, -1, -1, DEAL_TYPE_BALANCE};
   return types[type];
  }

ENUM_ORDER_TYPE OrderType2OrderType(const int type)
  {
   static ENUM_ORDER_TYPE types[] = {ORDER_TYPE_BUY, ORDER_TYPE_SELL, ORDER_TYPE_BUY_LIMIT, ORDER_TYPE_SELL_LIMIT, ORDER_TYPE_BUY_STOP, ORDER_TYPE_SELL_STOP, -1};
   return type<ArraySize(types)?types[type]:(ENUM_ORDER_TYPE)-1; //добавил проверку на размер 10.12.2024 так как вызывало критический сбой на мастере
  }

bool OrderCalcMargin(
   ENUM_ORDER_TYPE       action,
   string                symbol,
   double                volume,
   double                price,
   double               &margin
)
  {
   int cmd = EnumOrderType2Code(action);
   double m = AccountFreeMarginCheck(symbol, cmd, volume);
   if(m <= 0 || GetLastError() == ERR_NOT_ENOUGH_MONEY)
     {
      return false;
     }
   margin = AccountFreeMargin() - m;
   return true;
  }

bool OrderCalcProfit(
   ENUM_ORDER_TYPE       action,
   string                symbol,
   double                volume,
   double                price_open,
   double                price_close,
   double               &profit
)
  {
   int cmd = EnumOrderType2Code(action);
   if(cmd > -1)
     {
      int points = (int)((price_close - price_open) / MarketInfo(symbol, MODE_POINT));
      if(cmd == OP_SELL)
         points = -points;

      profit = points * volume * MarketInfo(symbol, MODE_TICKVALUE) / (MarketInfo(symbol, MODE_TICKSIZE) / MarketInfo(symbol, MODE_POINT));
      return true;
     }
   return false;
  }

bool OrderCheck(const MqlTradeRequest &request, MqlTradeCheckResult &result)
  {
   if(request.volume > MarketInfo(request.symbol, MODE_MAXLOT)
      || request.volume < MarketInfo(request.symbol, MODE_MINLOT)
      || request.volume != MathFloor(request.volume / MarketInfo(request.symbol, MODE_LOTSTEP)) * MarketInfo(request.symbol, MODE_LOTSTEP))
     {
      result.retcode = TRADE_RETCODE_INVALID_VOLUME;
      return false;
     }

   double margin;
   if(!OrderCalcMargin(request.type, request.symbol, request.volume, request.price, margin))
     {
      result.retcode = TRADE_RETCODE_NO_MONEY;
      return false;
     }

   if((request.action == TRADE_ACTION_DEAL || request.action == TRADE_ACTION_PENDING)
      && SymbolInfoInteger(request.symbol, SYMBOL_TRADE_MODE) == SYMBOL_TRADE_EXECUTION_MARKET
      && (request.sl != 0 || request.tp != 0))
     {
      result.retcode = TRADE_RETCODE_INVALID_STOPS;
      return false;
     }

   result.balance = AccountBalance();
   result.equity = AccountEquity();
   result.profit = AccountEquity() - AccountBalance();
   result.margin = margin;
   result.margin_free = AccountFreeMargin();
   result.margin_level = 0;
   result.comment = "";

   return true;
  }

bool OrderSend(MqlTradeRequest &request, MqlTradeResult &result)
  {
   int cmd;

   result.retcode = 0;

   switch(request.type)
     {
      case ORDER_TYPE_BUY:
         cmd = OP_BUY;
         break;
      case ORDER_TYPE_SELL:
         cmd = OP_SELL;
         break;
      case ORDER_TYPE_BUY_LIMIT:
         cmd = OP_BUYLIMIT;
         break;
      case ORDER_TYPE_SELL_LIMIT:
         cmd = OP_SELLLIMIT;
         break;
      case ORDER_TYPE_BUY_STOP:
         cmd = OP_BUYSTOP;
         break;
      case ORDER_TYPE_SELL_STOP:
         cmd = OP_SELLSTOP;
         break;
      default:
         Print("Unsupported request type:", request.type);
         return false;
     }

   ResetLastError();

   color cl=clrNONE;

   if(cmd == OP_BUY)
     {
      cl=clrBlue;
     }
   else
      if(cmd == OP_SELL)
        {
         cl=clrRed;
        }

   if(request.action == TRADE_ACTION_DEAL || request.action == TRADE_ACTION_PENDING)
     {

      if(request.price == 0)
        {
         if(cmd == OP_BUY)
           {
            request.price = MarketInfo(request.symbol, MODE_ASK);
           }
         else
            if(cmd == OP_SELL)
              {
               request.price = MarketInfo(request.symbol, MODE_BID);
              }
        }

      if(request.position > 0)
        {
         if(!OrderClose((int)request.position, request.volume, request.price, (int)request.deviation,clrGold))
           {
            result.retcode = GetLastError();
           }
         else
           {
            result.retcode = TRADE_RETCODE_DONE;
            result.deal = request.position | 0x8000000000000000;
            result.order = request.position | 0x8000000000000000;
            result.volume = request.volume;
            result.price = request.price;
           }
        }
      else
        {
         int ticket = OrderSend(request.symbol, cmd, request.volume, request.price, (int)request.deviation, request.sl, request.tp, request.comment, (int)request.magic, request.expiration,cl);
         if(ticket == -1)
           {
            result.retcode = GetLastError();
           }
         else
           {
            result.retcode = TRADE_RETCODE_DONE;
            result.deal = ticket;
            result.order = ticket;
            result.request_id = ticket;

            if(OrderSelect(ticket, SELECT_BY_TICKET))
              {
               result.volume = OrderLots();
               result.price = OrderOpenPrice() > 0 ? OrderOpenPrice() : request.price;
               result.comment = OrderComment();
               result.ask = MarketInfo(OrderSymbol(), MODE_ASK);
               result.bid = MarketInfo(OrderSymbol(), MODE_BID);
              }
            else
              {
               result.volume = request.volume;
               result.price = request.price;
               result.comment = "";
              }
           }
        }
     }
   else
      if(request.action == TRADE_ACTION_SLTP) // change opened position
        {
         if(OrderSelect((int)request.position, SELECT_BY_TICKET))
           {

            if(

Показано первые 50% кода (символов: 24456)