Tipos de Operações de Negociação (trade, transações, negociações)

A negociação realiza-se usando a função OrderSend()e enviando ordens não só para abrir posições, mas também para colocar, modificar e excluir ordens pendentes. Cada ordem de negociação contem uma indicação do tipo de operação solicitada. As operações de negociação são descritas na enumeração ENUM_TRADE_REQUEST_ACTIONS.

ENUM_TRADE_REQUEST_ACTIONS

Identificador

Descrição

TRADE_ACTION_DEAL

Coloca uma ordem de negociação para a transação ser executada imediatamente usando os parâmetros especificados (ordem de mercado)

TRADE_ACTION_PENDING

Coloca uma ordem de negociação para a transação ser executada sob certas condições (ordem pendente)

TRADE_ACTION_SLTP

Modifica valores de Stop-Loss e Take-Profit numa posição aberta

TRADE_ACTION_MODIFY

Modifca os parâmetros de uma ordem colocada anteriormente

TRADE_ACTION_REMOVE

Exclui uma ordem pendente colocada anteriormente

TRADE_ACTION_CLOSE_BY

Fechar a posição oposta

 

Exemplo de operação de negociação TRADE_ACTION_DEAL para abrir uma posição Buy:

#define EXPERT_MAGIC 123456   // MagicNumber do conselheiro
//+------------------------------------------------------------------+
//| Abertura da posição Buy                                          |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- Atualização e inicialização do pedido e o seu resultado
   MqlTradeRequest request={0};
   MqlTradeResult  result={0};
//--- parâmetros do pedido
   request.action   =TRADE_ACTION_DEAL;                     // tipo de operação de negociação
   request.symbol   =Symbol();                              // símbolo
   request.volume   =0.1;                                   // volume de 0.1 lotes
   request.type     =ORDER_TYPE_BUY;                        // tipo de ordem
   request.price    =SymbolInfoDouble(Symbol(),SYMBOL_ASK); // preço para abertura
   request.deviation=5;                                     // desvio permitido do preço
   request.magic    =EXPERT_MAGIC;                          // MagicNumber da ordem
//--- envio do pedido
   if(!OrderSend(request,result))
      PrintFormat("OrderSend error %d",GetLastError());     // se não for possível enviar o pedido, sairá um código de erro
//--- informação sobre a operação
   PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
  }
//+------------------------------------------------------------------+

 
Exemplo de operação de negociaçãoTRADE_ACTION_DEAL para abertura da posição Sell:

#define EXPERT_MAGIC 123456   // MagicNumber do conselheiro
//+------------------------------------------------------------------+
//| Abertura da posição Sell                                         |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- Declaração e inicialização do pedido e o seu resultado
   MqlTradeRequest request={0};
   MqlTradeResult  result={0};
//--- parâmetros do pedido
   request.action   =TRADE_ACTION_DEAL;                     // tipo de operação de negociação
   request.symbol   =Symbol();                              // símbolo
   request.volume   =0.2;                                   // volume de 0.2 lotes
   request.type     =ORDER_TYPE_SELL;                       // tipo da ordem
   request.price    =SymbolInfoDouble(Symbol(),SYMBOL_BID); // preço para a abertura
   request.deviation=5;                                     // desvio permitido do preço
   request.magic    =EXPERT_MAGIC;                          // MagicNumber da ordem
//--- envio do pedido
   if(!OrderSend(request,result))
      PrintFormat("OrderSend error %d",GetLastError());     // se não for possível enviar o pedido, exibir um código de erro
//--- informação sobre a operação
   PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
  }
//+------------------------------------------------------------------+

 
Exemplo de ordem de negociação TRADE_ACTION_DEAL para fechadura de posições:

#define EXPERT_MAGIC 123456   // MagicNumber do conselheiro
//+------------------------------------------------------------------+
//| Fechadura de todas as posições                                   |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- declaração do pedido e o seu resultado
   MqlTradeRequest request;
   MqlTradeResult  result;
   int total=PositionsTotal(); // número de posições abertas   
//--- iterar todas as posições abertas
   for(int i=total-1; i>=0; i--)
     {
      //--- parâmetros da ordem
      ulong  position_ticket=PositionGetTicket(i);                                      // bilhete da posição
      string position_symbol=PositionGetString(POSITION_SYMBOL);                        // simbolo 
      int    digits=(int)SymbolInfoInteger(position_symbol,SYMBOL_DIGITS);              //número de signos depois da coma
      ulong  magic=PositionGetInteger(POSITION_MAGIC);                                  // MagicNumber da posição
      double volume=PositionGetDouble(POSITION_VOLUME);                                 // volume da posição
      ENUM_POSITION_TYPE type=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);    // tipo de posição
      //--- saída de informação sobre a posição
      PrintFormat("#%I64u %s  %s  %.2f  %s [%I64d]",
                  position_ticket,
                  position_symbol,
                  EnumToString(type),
                  volume,
                  DoubleToString(PositionGetDouble(POSITION_PRICE_OPEN),digits),
                  magic);
      //--- se o MagicNumber coincidir
      if(magic==EXPERT_MAGIC)
        {
         //--- zerar os valores do pedido e os seus resultados
         ZeroMemory(request);
         ZeroMemory(result);
         //--- configuração dos parâmetros da ordem
         request.action   =TRADE_ACTION_DEAL;        // tipo de operação de negociação
         request.position =position_ticket;          // bilhete da posição
         request.symbol   =position_symbol;          // símbolo 
         request.volume   =volume;                   // volume da posição
         request.deviation=5;                        // desvio permitido do preço
         request.magic    =EXPERT_MAGIC;             // MagicNumber da posição
         //--- colocação do preço e tipo de ordem dependendo do tipo de ordem
         if(type==POSITION_TYPE_BUY)
           {
            request.price=SymbolInfoDouble(position_symbol,SYMBOL_BID);
            request.type =ORDER_TYPE_SELL;
           }
         else
           {
            request.price=SymbolInfoDouble(position_symbol,SYMBOL_ASK);
            request.type =ORDER_TYPE_BUY;
           }
         //--- saída de informação sobre o fechamento
         PrintFormat("Close #%I64d %s %s",position_ticket,position_symbol,EnumToString(type));
         //--- envio do pedido
         if(!OrderSend(request,result))
            PrintFormat("OrderSend error %d",GetLastError());  // se não for possível enviar o pedido, exibir um código de erro
         //--- informação sobre a operação 
         PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
         //---
        }
     }
  }
//+------------------------------------------------------------------+

 
Exemplo de operação de negociaçãoTRADE_ACTION_PENDING para colocação de uma ordem pendente:

#property description "Exemplo de colocação de ordens pendentes"
#property script_show_inputs
#define EXPERT_MAGIC 123456                             // MagicNumber do conselheiro
input ENUM_ORDER_TYPE orderType=ORDER_TYPE_BUY_LIMIT;   // tipo da ordem
//+------------------------------------------------------------------+
//| Colocação de ordens pendentes                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//-- declaração e inicialização do pedido e o seu resultado
   MqlTradeRequest request={0};
   MqlTradeResult  result={0};
//--- parâmetros para colocação da ordem pendente
   request.action   =TRADE_ACTION_PENDING;                             // tipo de operação de negociação
   request.symbol   =Symbol();                                         // símbolo
   request.volume   =0.1;                                              // volume de 0.1 lotes
   request.deviation=2;                                                //desvio permitido do preço
   request.magic    =EXPERT_MAGIC;                                     // MagicNumber da ordem
   int offset = 50;                                                    // deslocamento a partir do preço atua para colocação da ordem, em pontos
   double price;                                                       // preço de execução da ordem
   double point=SymbolInfoDouble(_Symbol,SYMBOL_POINT);                // tamanho do ponto
   int digits=SymbolInfoInteger(_Symbol,SYMBOL_DIGITS);                // número de símbolos depois da coma (precisão)
   //--- verificação do tipo de operação
   if(orderType==ORDER_TYPE_BUY_LIMIT)
     {
      request.type     =ORDER_TYPE_BUY_LIMIT;                          // tipo de ordem
      price=SymbolInfoDouble(Symbol(),SYMBOL_ASK)-offset*point;        // preço para abertura 
      request.price    =NormalizeDouble(price,digits);                 // нормализованная цена открытия 
     }
   else if(orderType==ORDER_TYPE_SELL_LIMIT)
     {
      request.type     =ORDER_TYPE_SELL_LIMIT;                          // тип ордера
      price=SymbolInfoDouble(Symbol(),SYMBOL_ASK)+offset*point;         // цена для открытия 
      request.price    =NormalizeDouble(price,digits);                  // preço de abertura normalizado 
     }
   else if(orderType==ORDER_TYPE_BUY_STOP)
     {
      request.type =ORDER_TYPE_BUY_STOP;                                // tipo de ordem
      price        =SymbolInfoDouble(Symbol(),SYMBOL_ASK)+offset*point; // preço de abertura 
      request.price=NormalizeDouble(price,digits);                      // preço de abertura normalizado 
     }
   else if(orderType==ORDER_TYPE_SELL_STOP)
     {
      request.type     =ORDER_TYPE_SELL_STOP;                           // tipo de ordem
      price=SymbolInfoDouble(Symbol(),SYMBOL_ASK)-offset*point;         // preço para abertura 
      request.price    =NormalizeDouble(price,digits);                  // preço de abertura normalizado 
     }
   else Alert("Este exemplo é apenas para colocação de ordens pendentes");   // Se a ordem pendente não for selecionada
//--- enviar a ordem
   if(!OrderSend(request,result))
      PrintFormat("OrderSend error %d",GetLastError());                 // Se não for possível enviar o pedido, exibir um código de erro
//--- informações sobre a operação
   PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
  }
//+------------------------------------------------------------------+

 
Exemplo da operação de negociação TRADE_ACTION_SLTP para alterar o valor Stop-Loss e Take-Profit na posição aberta:

#define EXPERT_MAGIC 123456  // MagicNumber do conselheiro
//+------------------------------------------------------------------+
//| Modificação do Stop-Loss e Take-Profit da posição                |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- declaracão do pedido e o seu resultado
   MqlTradeRequest request;
   MqlTradeResult  result;
   int total=PositionsTotal(); // número de posições abertas   
//--- iterar sobre todas as posições abertas
   for(int i=0; i<total; i++)
     {
      //--- parâmetros da ordem
      ulong  position_ticket=PositionGetTicket(i);// bilhete da posição
      string position_symbol=PositionGetString(POSITION_SYMBOL); // símbolo 
      int    digits=(int)SymbolInfoInteger(position_symbol,SYMBOL_DIGITS); // número de signos depois da coma
      ulong  magic=PositionGetInteger(POSITION_MAGIC); // MagicNumber da posição
      double volume=PositionGetDouble(POSITION_VOLUME);    // volume da posição
      double sl=PositionGetDouble(POSITION_SL);  // Stop Loss da posição
      double tp=PositionGetDouble(POSITION_TP);  // Take-Profit da posição
      ENUM_POSITION_TYPE type=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);  // tipo da posição
      //--- saída de informações sobre a posição
      PrintFormat("#%I64u %s  %s  %.2f  %s  sl: %s  tp: %s  [%I64d]",
                  position_ticket,
                  position_symbol,
                  EnumToString(type),
                  volume,
                  DoubleToString(PositionGetDouble(POSITION_PRICE_OPEN),digits),
                  DoubleToString(sl,digits),
                  DoubleToString(tp,digits),
                  magic);
      //--- se o MagicNumber coincidir, o Stop-Loss e o Take-Profit não estão definidos
      if(magic==EXPERT_MAGIC && sl==0 && tp==0)
        {
         //--- cálculo dos níveis de preços atuais
         double price=PositionGetDouble(POSITION_PRICE_OPEN);
         double bid=SymbolInfoDouble(position_symbol,SYMBOL_BID);
         double ask=SymbolInfoDouble(position_symbol,SYMBOL_ASK);
         int    stop_level=(int)SymbolInfoInteger(position_symbol,SYMBOL_TRADE_STOPS_LEVEL);
         double price_level;
         //--- se o nível de deslocamento mínimo permitido em pontos a partir do preço atual de fechamento não estiver definido
         if(stop_level<=0)
            stop_level=150; // definimos o deslocamento em 150 pontos a partir do preço atual de fechamento
         else
            stop_level+=50; // definimos o nível de deslocamento (SYMBOL_TRADE_STOPS_LEVEL + 50) pontos para a confiabilidade
 
         //--- cálculo e arredondamento dos valores Stop-Loss e Take-Profit
         price_level=stop_level*SymbolInfoDouble(position_symbol,SYMBOL_POINT);
         if(type==POSITION_TYPE_BUY)
           {
            sl=NormalizeDouble(bid-price_level,digits);
            tp=NormalizeDouble(ask+price_level,digits);
           }
         else
           {
            sl=NormalizeDouble(ask+price_level,digits);
            tp=NormalizeDouble(bid-price_level,digits);
           }
         //--- zerar os valores de pedido e o seu resultado
         ZeroMemory(request);
         ZeroMemory(result);
         //--- definição dos parâmetros de operação
         request.action  =TRADE_ACTION_SLTP// tipo de operação de negociação
         request.position=position_ticket;   // bilhete da posição
         request.symbol=position_symbol;     // símbolo 
         request.sl      =sl;                // Stop Loss da posição
         request.tp      =tp;                // Take Profit da posição
         request.magic=EXPERT_MAGIC;         // MagicNumber da posição
         //--- saída de informações sobre a modificação
         PrintFormat("Modify #%I64d %s %s",position_ticket,position_symbol,EnumToString(type));
         //--- envio do pedido
         if(!OrderSend(request,result))
            PrintFormat("OrderSend error %d",GetLastError());  // se não for possível enviar o pedido, exibir o código de erro
         //--- informações sobre a operação   
         PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
        }
     }
  }
//+------------------------------------------------------------------+

 
Exemplo de operação de negociação TRADE_ACTION_MODIFY para modificar os níveis de preços das ordens pendentes:

#define EXPERT_MAGIC 123456 // MagicNumber do conselheiro
//+------------------------------------------------------------------+
//| Modificação de ordens pendentes                                  |
//+------------------------------------------------------------------+
void OnStart()
 {
//-- declaração e inicialização do pedido e o seu resultado
 MqlTradeRequest request={0};
 MqlTradeResult result={0};
 int total=OrdersTotal(); // número de ordens pendentes colocadas
//--- iterar todas as ordens pendentes colocadas
 for(int i=0; i<total; i++)
 {
 //--- parâmetros da ordem
 ulong order_ticket=OrderGetTicket(i); // bilhete da ordem
 string order_symbol=Symbol(); // símbolo
 int digits=(int)SymbolInfoInteger(order_symbol,SYMBOL_DIGITS); // número de signos depois da coma
 ulong magic=OrderGetInteger(ORDER_MAGIC); // MagicNumber da ordem
 double volume=OrderGetDouble(ORDER_VOLUME_CURRENT); // volume atual da ordem
 double sl=OrderGetDouble(ORDER_SL); // Stop Loss atual da ordem
 double tp=OrderGetDouble(ORDER_TP); // Take Profit atual da ordem
 ENUM_ORDER_TYPE type=(ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE); // tipo de ordem
 int offset = 50; // deslocação a partir do preço atual para colocação da ordem, em pontos
 double price; // preço de ativação da ordem
 double point=SymbolInfoDouble(order_symbol,SYMBOL_POINT); // tamanho do ponto
 //--- saída de informações sobre a ordem
 PrintFormat("#%I64u %s %s %.2f %s sl: %s tp: %s [%I64d]",
 order_ticket,
 order_symbol,
 EnumToString(type),
 volume,
 DoubleToString(PositionGetDouble(POSITION_PRICE_OPEN),digits),
 DoubleToString(sl,digits),
 DoubleToString(tp,digits),
 magic);
 //--- se o MagicNumber coincidir, o Stop Loss e o Take Profit nao foram definidos
 if(magic==EXPERT_MAGIC && sl==0 && tp==0)
 {
 request.action=TRADE_ACTION_MODIFY// tipo de operação de negociação
 request.order = OrderGetTicket(i); // bilhete da ordem
 request.symbol =Symbol(); // símbolo
 request.deviation=5; // desvio permitido a partir do preço
 //--- definição do nível de preços Take Profit e Stop Loss da ordem dependendo do seu tipo
 if(type==ORDER_TYPE_BUY_LIMIT)
 {
 price = SymbolInfoDouble(Symbol(),SYMBOL_ASK)-offset*point; 
 request.tp = NormalizeDouble(price+offset*point,digits);
 request.sl = NormalizeDouble(price-offset*point,digits);
 request.price =NormalizeDouble(price,digits); // preço de abertura normalizado
 }
 else if(type==ORDER_TYPE_SELL_LIMIT)
 {
 price = SymbolInfoDouble(Symbol(),SYMBOL_BID)+offset*point; 
 request.tp = NormalizeDouble(price-offset*point,digits);
 request.sl = NormalizeDouble(price+offset*point,digits);
 request.price =NormalizeDouble(price,digits); // preço de abertura normalizado
 }
 else if(type==ORDER_TYPE_BUY_STOP)
 {
 price = SymbolInfoDouble(Symbol(),SYMBOL_BID)+offset*point; 
 request.tp = NormalizeDouble(price+offset*point,digits);
 request.sl = NormalizeDouble(price-offset*point,digits);
 request.price =NormalizeDouble(price,digits); // preço de abertura normalizado
 }
 else if(type==ORDER_TYPE_SELL_STOP)
 {
 price = SymbolInfoDouble(Symbol(),SYMBOL_ASK)-offset*point; 
 request.tp = NormalizeDouble(price-offset*point,digits);
 request.sl = NormalizeDouble(price+offset*point,digits);
 request.price =NormalizeDouble(price,digits); // preço de abertura normalizado
 }
 //--- envio do pedido
 if(!OrderSend(request,result))
 PrintFormat("OrderSend error %d",GetLastError()); // se não foi possível enviar o pedido, exibir o código de erro 
 //--- informações sobre a operação 
 PrintFormat("retcode=%u deal=%I64u order=%I64u",result.retcode,result.deal,result.order);
 //--- zerado dos valores do pedido e o seu resultado
 ZeroMemory(request);
 ZeroMemory(result);
 }
 }
 }
//+------------------------------------------------------------------+

 
Exemplo de operação de negociação TRADE_ACTION_REMOVE para excluir ordens pendentes:

#define EXPERT_MAGIC 123456  // MagicNumber do conselheiro
//+------------------------------------------------------------------+
//| Exclusão de ordens pendentes                                     |
//+------------------------------------------------------------------+
void OnStart()
 {
//-- Declaração e inicialização do pedido e resultado 
 MqlTradeRequest request={0};
 MqlTradeResult result={0};
 int total=OrdersTotal(); // número de ordens pendentes colocadas 
//--- iterar todas as ordens pendentes colocadas 
 for(int i=total-1; i>=0; i--)
 {
 ulong order_ticket=OrderGetTicket(i); // bilhete da ordem
 ulong magic=OrderGetInteger(ORDER_MAGIC); // MagicNumber da ordem 
 //--- se o MagicNumber coincidir
 if(magic==EXPERT_MAGIC)
 {
 //--- zerar os valores do pedido e o resultado
 ZeroMemory(request);
 ZeroMemory(result);
 //--- instalação de parâmetros de operação 
 request.action=TRADE_ACTION_REMOVE// tipo de operação de negociação
 request.order = order_ticket; // bilhete da ordem
 //--- envio do pedido
 if(!OrderSend(request,result))
 PrintFormat("OrderSend error %d",GetLastError()); // Se não for capaz de enviar o pedido, exibir um código de erro 
 //--- informações sobre a operação 
 PrintFormat("retcode=%u deal=%I64u order=%I64u",result.retcode,result.deal,result.order);
 }
 }
 }
//+------------------------------------------------------------------+

 
Exemplo de operação de negociação TRADE_ACTION_CLOSE_BY para fechamento da posição usando a oposta:

#define EXPERT_MAGIC 123456  // MagicNumber do conselheiro
//+------------------------------------------------------------------+
//| Fechamento de todas as posições opostas                          |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- declaração e inicialização do pedido e o seu resultado
   MqlTradeRequest request;
   MqlTradeResult  result;
   int total=PositionsTotal(); // numero de posições abertas   
//--- iterar sobre todas as posições abertas
   for(int i=total-1; i>=0; i--)
     {
      //--- parâmetros da ordem
      ulong  position_ticket=PositionGetTicket(i);                                    // bilhete da posição
      string position_symbol=PositionGetString(POSITION_SYMBOL);                      // símbolo 
      int    digits=(int)SymbolInfoInteger(position_symbol,SYMBOL_DIGITS);            // número de signos depois da coma
      ulong  magic=PositionGetInteger(POSITION_MAGIC);                                // MagicNumber da posição
      double volume=PositionGetDouble(POSITION_VOLUME);                               // volume da posição
      double sl=PositionGetDouble(POSITION_SL);                                       // Stop Loss da posição
      double tp=PositionGetDouble(POSITION_TP);                                       // Take Profit da posição
      ENUM_POSITION_TYPE type=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);  // tipo de posição
      //--- saída de informações sobre a posição
      PrintFormat("#%I64u %s  %s  %.2f  %s  sl: %s  tp: %s  [%I64d]",
                  position_ticket,
                  position_symbol,
                  EnumToString(type),
                  volume,
                  DoubleToString(PositionGetDouble(POSITION_PRICE_OPEN),digits),
                  DoubleToString(sl,digits),
                  DoubleToString(tp,digits),
                  magic);
      //--- se o MagicNumber coincidir
      if(magic==EXPERT_MAGIC)
        {
         for(int j=0; j<i; j++)
           {
            string symbol=PositionGetSymbol(j); // símbolo da posição oposta
            //--- se os símbolos das posições opostas e iniciais coincidirem
            if(symbol==position_symbol && PositionGetInteger(POSITION_MAGIC)==EXPERT_MAGIC)
              {
               //--- o tipo de posição oposta
               ENUM_POSITION_TYPE type_by=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
               //--- saída, se os símbolos das posições opostas e iniciais coincidirem
               if(type==type_by)
                  continue;
               //--- zerar os valores do pedido e o seu resultado
               ZeroMemory(request);
               ZeroMemory(result);
               //--- definição os parâmetros de operação
               request.action=TRADE_ACTION_CLOSE_BY;                         // tipo de operação de negociação
               request.position=position_ticket;                             // bilhete da posição
               request.position_by=PositionGetInteger(POSITION_TICKET);      // bilhete da posição opo~sta
               //request.symbol     =position_symbol;
               request.magic=EXPERT_MAGIC;                                   // MagicNumber da posição
               //--- saída de informações sobre o fechamento pela posição oposta
               PrintFormat("Close #%I64d %s %s by #%I64d",position_ticket,position_symbol,EnumToString(type),request.position_by);
               //--- envio do pedido
               if(!OrderSend(request,result))
                  PrintFormat("OrderSend error %d",GetLastError()); // se não for possível enviar o pedido, sairá um código de erro<b78/>//--- informação sobre a operação
 
               //--- informações sobre a operação   
               PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+