La Structure de Demande de Trade (MqlTradeRequest)

struct MqlTradeRequest
  {
   ENUM_TRADE_REQUEST_ACTIONS    action;           // Type de l'opération de trading
   ulong                         magic;            // Identifiant de l'Expert Advisor (numéro magique)
   ulong                         order;            // Ticket de l'ordre
   string                        symbol;           // Symbole de trading
   double                        volume;           // Volume demandé pour une transaction en lots
   double                        price;            // Prix
   double                        stoplimit;        // Niveau du StopLimit de l'ordre
   double                        sl;               // Niveau du Stop Loss pour l'ordre
   double                        tp;               // Niveau du Take Profit pour l'ordre
   ulong                         deviation;        // Déviation maximale possible pour le prix demandé
   ENUM_ORDER_TYPE               type;             // Type de l'ordre
   ENUM_ORDER_TYPE_FILLING       type_filling;     // Type d'exécution de l'ordre
   ENUM_ORDER_TYPE_TIME          type_time;        // Type d'expiration de l'ordre
   datetime                      expiration;       // Date/heure d'expiration de l'ordre (pour les ordres de type ORDER_TIME_SPECIFIED)
   string                        comment;          // Commentaire de l'ordre
   ulong                         position;         // Ticket de la position
   ulong                         position_by;      // Le ticket d'une position opposée
  };

#define EXPERT_MAGIC 123456   // MagicNumber de l'
//+------------------------------------------------------------------+
//| Ouverture d'une position Buy                                     |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- déclare et initialise la demande de trading et le résultat de la demande
   MqlTradeRequest request={};
   MqlTradeResult  result={};
//--- paramètres de la demande
   request.action   =TRADE_ACTION_DEAL;                     // type de l'opération de trading
   request.symbol   =Symbol();                              // symbole
   request.volume   =0.1;                                   // volume de 0.1 lot
   request.type     =ORDER_TYPE_BUY;                        // type de l'ordre
   request.price    =SymbolInfoDouble(Symbol(),SYMBOL_ASK); // prix d'ouverture
   request.deviation=5;                                     // déviation du prix autorisée
   request.magic    =EXPERT_MAGIC;                          // MagicNumber de l'ordre
//--- envoi la demande
   if(!OrderSend(request,result))
      PrintFormat("OrderSend erreur %d",GetLastError());     // en cas d'erreur d'envoi de la demande, affiche le code d'erreur
//--- informations de l'opération
   PrintFormat("retcode=%u  transaction=%I64u  ordre=%I64u",result.retcode,result.deal,result.order);
  }
//+------------------------------------------------------------------+

#define EXPERT_MAGIC 123456   // MagicNumber de l'
//+------------------------------------------------------------------+
//| Ouverture d'une position Sell                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- déclare et initialise la demande de trading et le résultat de la demande
   MqlTradeRequest request={};
   MqlTradeResult  result={};
//--- paramètres de la demande
   request.action   =TRADE_ACTION_DEAL;                     // type de l'opération de trading
   request.symbol   =Symbol();                              // symbole
   request.volume   =0.1;                                   // volume de 0.2 lot
   request.type     =ORDER_TYPE_SELL;                        // type de l'ordre
   request.price    =SymbolInfoDouble(Symbol(),SYMBOL_BID); // prix d'ouverture
   request.deviation=5;                                     // déviation du prix autorisée
   request.magic    =EXPERT_MAGIC;                          // MagicNumber de l'ordre
//--- envoi la demande
   if(!OrderSend(request,result))
      PrintFormat("OrderSend erreur %d",GetLastError());     // en cas d'erreur d'envoi de la demande, affiche le code d'erreur
//--- informations de l'opération
   PrintFormat("retcode=%u  transaction=%I64u  ordre=%I64u",result.retcode,result.deal,result.order);
  }
<b88>//+------------------------------------------------------------------+

#define EXPERT_MAGIC 123456   // MagicNumber de l'expert
//+------------------------------------------------------------------+
//| Fermeture de toutes les positions                                |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- déclare et initialise la demande de trading et le résultat
   MqlTradeRequest request;
   MqlTradeResult  result;
   int total=PositionsTotal(); // nombre de positions ouvertes
//--- boucle sur toutes les positions ouvertes
   for(int i=total-1; i>=0; i--)
     {
      //--- paramètres de l'ordre
      ulong  position_ticket=PositionGetTicket(i);                                      // ticket de la position
      string position_symbol=PositionGetString(POSITION_SYMBOL);                        // symbole
      int    digits=(int)SymbolInfoInteger(position_symbol,SYMBOL_DIGITS);              // nombre de décimales
      ulong  magic=PositionGetInteger(POSITION_MAGIC);                                  // MagicNumber de la position
      double volume=PositionGetDouble(POSITION_VOLUME);                                 // volume de la position
      ENUM_POSITION_TYPE type=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);    // type de la position
      //--- affiche les informations de la position
      PrintFormat("#%I64u %s  %s  %.2f  %s [%I64d]",
                  position_ticket,
                  position_symbol,
                  EnumToString(type),
                  volume,
                  DoubleToString(PositionGetDouble(POSITION_PRICE_OPEN),digits),
                  magic);
      //--- si le MagicNumber correspond
      if(magic==EXPERT_MAGIC)
        {
         //--- remise à zéro de la demande et du résultat
         ZeroMemory(request);
         ZeroMemory(result);
         //--- paramètres de l'opration
         request.action   =TRADE_ACTION_DEAL;        // type de l'opération de trading
         request.position =position_ticket;          // ticket de la position
         request.symbol   =position_symbol;          // symbole 
         request.volume   =volume;                   // volume de la position
         request.deviation=5;                        // déviation du prix autoriséee
         request.magic    =EXPERT_MAGIC;             // MagicNumber de la position
         //--- définit le prix et le type de l'ordre suivant le type de la position
         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;
           }
         //--- affiche les informations de clôture
         PrintFormat("Ferme #%I64d %s %s",position_ticket,position_symbol,EnumToString(type));
         //--- envoi la demande
         if(!OrderSend(request,result))
            PrintFormat("OrderSend erreur %d",GetLastError());  // en cas d'échec de l'envoi, affiche le code d'erreur
         //--- informations sur l'opération   
         PrintFormat("retcode=%u  transaction=%I64u  ordre=%I64u",result.retcode,result.deal,result.order);
         //---
        }
     }
  }
//+------------------------------------------------------------------+

#define EXPERT_MAGIC 123456  // MagicNumber de l' expert
//+------------------------------------------------------------------+
//| Modification du Stop Loss et du Take Profit d'une position       |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- déclare et initialise la demande de trade et le résultat
   MqlTradeRequest request;
   MqlTradeResult  result;
   int total=PositionsTotal(); // nombre de positions ouvertes
//--- boucle sur toutes les positions ouvertes
   for(int i=0; i<total; i++)
     {
      //--- paramètres de l'ordre
      ulong  position_ticket=PositionGetTicket(i);// ticket de la position
      string position_symbol=PositionGetString(POSITION_SYMBOL); // symbole 
      int    digits=(int)SymbolInfoInteger(position_symbol,SYMBOL_DIGITS); // nombre de décimales
      ulong  magic=PositionGetInteger(POSITION_MAGIC); // MagicNumber de la position
      double volume=PositionGetDouble(POSITION_VOLUME);    // volume de la position
      double sl=PositionGetDouble(POSITION_SL);  // Stop Loss de la position
      double tp=PositionGetDouble(POSITION_TP);  // Take Profit de la position
      ENUM_POSITION_TYPE type=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);  // type de la position
      //--- affiche quelques informations sur la position
      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);
      //--- si le MagicNumber correspond et que le Stop Loss et le Take Profit ne sont pas définis
      if(magic==EXPERT_MAGIC && sl==0 && tp==0)
        {
         //--- calcule les niveaux de prix actuels
         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;
         //--- si la distance de décalage minimum autorisée en points du prix de cloturê courant n'est pas définie
         if(stop_level<=0)
            stop_level=150; // définit la distance de décalage de 150 points du priwx de clôture courant
         else
            stop_level+=50; // définit la distance de décalage à (SYMBOL_TRADE_STOPS_LEVEL + 50) points pour la fiabilité
 
         //--- calcul et arrondi des valeurs du Stop Loss et du Take Profit
         price_level=stop_level*SymbolInfoDouble(position_symbol,SYMBOL_POINT);
         if(type==POSITION_TYPE_BUY)
           {
            sl=NormalizeDouble(bid-price_level,digits);
            tp=NormalizeDouble(bid+price_level,digits);
           }
         else
           {
            sl=NormalizeDouble(ask+price_level,digits);
            tp=NormalizeDouble(ask-price_level,digits);
           }
         //--- remise à zéro de la demande et du résultat
         ZeroMemory(request);
         ZeroMemory(result);
         //--- définition des paramètres de l'opération
         request.action  =TRADE_ACTION_SLTP; // type de l'opération de trading
         request.position=position_ticket;   // ticket de la position
         request.symbol=position_symbol;     // symbole 
         request.sl      =sl;                // Stop Loss de la position
         request.tp      =tp;                // Take Profit de la position
         request.magic=EXPERT_MAGIC;         // MagicNumber de la position
         //--- affiche des informations sur la modification
         PrintFormat("Modification de #%I64d %s %s",position_ticket,position_symbol,EnumToString(type));
         //--- envoi de la demande
         if(!OrderSend(request,result))
            PrintFormat("OrderSend erreur %d",GetLastError());  // en cas d'échec de l'envoi, affiche le code de l'erreur
         //--- informations sur l'opération   
         PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
        }
     }
  }
//+------------------------------------------------------------------+

#property description "Exemple de placement d'ordres en attente"
#property script_show_inputs
#define EXPERT_MAGIC 123456                             // MagicNumber de l'expert
input ENUM_ORDER_TYPE orderType=ORDER_TYPE_BUY_LIMIT;   // type de l'ordre
//+------------------------------------------------------------------+
//| Placement d'ordres en attente                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- déclare et initialise la demande de trade et le résultat
   MqlTradeRequest request={};
   MqlTradeResult  result={};
//--- paramètres pour placer un ordre en attente
   request.action   =TRADE_ACTION_PENDING;                             // type de trade operation
   request.symbol   =Symbol();                                         // symbole
   request.volume   =0.1;                                              // volume de 0.1 lot
   request.deviation=2;                                                // déviation autorisée du prix
   request.magic    =EXPERT_MAGIC;                                     // MagicNumber de l'ordre
   int offset = 50;                                                    // décalage du prix courant pour placer un ordre, en points
   double price;                                                       // prix de déclenchement de l'ordre
   double point=SymbolInfoDouble(_Symbol,SYMBOL_POINT);                // valeur du point
   int digits=SymbolInfoInteger(_Symbol,SYMBOL_DIGITS);                // nombre de décimales (précision)
   //--- vérification du type de l'opération
   if(orderType==ORDER_TYPE_BUY_LIMIT)
     {
      request.type     =ORDER_TYPE_BUY_LIMIT;                          // type de l'ordre
      price=SymbolInfoDouble(Symbol(),SYMBOL_ASK)-offset*point;        // prix d'ouverture
      request.price    =NormalizeDouble(price,digits);                 // prix d'ouverture normalisé
     }
   else if(orderType==ORDER_TYPE_SELL_LIMIT)
     {
      request.type     =ORDER_TYPE_SELL_LIMIT;                          // type de l'ordre
      price=SymbolInfoDouble(Symbol(),SYMBOL_BID)+offset*point;         // prix d'ouverture
      request.price    =NormalizeDouble(price,digits);                  // prix d'ouverture normalisé
     }
   else if(orderType==ORDER_TYPE_BUY_STOP)
     {
      request.type =ORDER_TYPE_BUY_STOP;                                // type de l'ordre
      price        =SymbolInfoDouble(Symbol(),SYMBOL_ASK)+offset*point; // prix d'ouverture
      request.price=NormalizeDouble(price,digits);                      // prix d'ouverture normalisé
     }
   else if(orderType==ORDER_TYPE_SELL_STOP)
     {
      request.type     =ORDER_TYPE_SELL_STOP;                           // type de l'ordre
      price=SymbolInfoDouble(Symbol(),SYMBOL_BID)-offset*point;         // prix d'ouverture
      request.price    =NormalizeDouble(price,digits);                  // prix d'ouverture normalisé
     }
   else Alert("Cet exemple ne permet de ne placer que des ordres en attente");   // si aucun ordre en attente n'est sélectionné
//--- envoie la demande
   if(!OrderSend(request,result))
      PrintFormat("OrderSend erreur %d",GetLastError());                 // en cas d'échec de l'envoi de la demande, affiche le code de l'erreur
//--- informations sur l'opération
   PrintFormat("retcode=%u  transaction=%I64u  ordre=%I64u",result.retcode,result.deal,result.order);
  }
//+------------------------------------------------------------------+

#define EXPERT_MAGIC 123456  // MagicNumber de l'expert
//+------------------------------------------------------------------+
//| Modification des ordres en attente                               |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- déclare et initialise la demande de trade et le résultat
   MqlTradeRequest request={};
   MqlTradeResult  result={};
   int total=OrdersTotal(); // nombre total d'ordres en attente placés
//--- boucle sur tous les ordres en attente placés
   for(int i=0; i<total; i++)
     {
      //--- paramètres pour l'ordre
      ulong  order_ticket=OrderGetTicket(i);                             // ticket de l'ordre
      string order_symbol=Symbol();                                      // symbole
      int    digits=(int)SymbolInfoInteger(order_symbol,SYMBOL_DIGITS);  // nombre de décimales
      ulong  magic=OrderGetInteger(ORDER_MAGIC);                         // MagicNumber de l'ordre
      double volume=OrderGetDouble(ORDER_VOLUME_CURRENT);                // volume actuel de l'ordre
      double sl=OrderGetDouble(ORDER_SL);                                // Stop Loss actuel de l'ordre
      double tp=OrderGetDouble(ORDER_TP);                                // Take Profit actuel de l'ordre
      ENUM_ORDER_TYPE type=(ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE); // type de l'ordre
      int offset = 50;                                                   // décalage du prix courant pour placer l'ordre, en points
      double price;                                                      // prix de déclenchement de l'ordre
      double point=SymbolInfoDouble(order_symbol,SYMBOL_POINT);          // valeur du point
      //--- affiche des informations sur l'ordre
      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);
      //--- si le MagicNumber correspond, et que le Stop Loss et le Take Profit ne sont pas définis
      if(magic==EXPERT_MAGIC && sl==0 && tp==0)
        {
         request.action=TRADE_ACTION_MODIFY;                           // type de l'opération de trading
         request.order = OrderGetTicket(i);                            // ticket de l'ordre
         request.symbol   =Symbol();                                   // symbole
         request.deviation=5;                                          // déviation autorisée du prix
        //--- définition du niveau de prix, du Take Profit et du Stop Loss de l'ordre suivant son type
         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);                // prix d'ouverture normalisé
           }
         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);                 // prix d'ouverture normalisé
           }
         else if(type==ORDER_TYPE_BUY_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);                 // prix d'ouverture normalisé
           }
         else if(type==ORDER_TYPE_SELL_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);                 // prix d'ouverture normalisé
           }
         //--- envoi de la demande
         if(!OrderSend(request,result))
            PrintFormat("OrderSend erreur %d",GetLastError());  // en cas d'échec de l'envoi de la demande, affiche le code de l'erreur
         //--- informations sur l'opération   
         PrintFormat("retcode=%u  transaction=%I64u  ordre=%I64u",result.retcode,result.deal,result.order);
         //--- remise à zéro de la demande et du résultat
         ZeroMemory(request);
         ZeroMemory(result);
        }
     }
  }
//+------------------------------------------------------------------+

#define EXPERT_MAGIC 123456  // MagicNumber de l'expert
//+------------------------------------------------------------------+
//| Suppression des ordres en attente                                |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- déclare et initialise la demande de trading et le résultat
   MqlTradeRequest request={};
   MqlTradeResult  result={};
   int total=OrdersTotal(); // nombre total d'ordre en attente placés
//--- boucle sur tous les ordres en attente placés
   for(int i=total-1; i>=0; i--)
     {
      ulong  order_ticket=OrderGetTicket(i);                   // Ticket de l'ordre
      ulong  magic=OrderGetInteger(ORDER_MAGIC);               // MagicNumber de l'ordre
      //--- si le MagicNumber correspond
      if(magic==EXPERT_MAGIC)
        {
         //--- remise à zéro de la demande et du résultat
         ZeroMemory(request);
         ZeroMemory(result);
         //--- paramètres de l'opération
         request.action=TRADE_ACTION_REMOVE;                   // type de l'opération de trading
         request.order = order_ticket;                         // Ticket de l'ordre
         //--- envoi la demande
         if(!OrderSend(request,result))
            PrintFormat("OrderSend erreur %d",GetLastError());  // en cas d'échec de l'envoi de la demande, affiche le code d'erreur
         //--- informations sur l'opération   
         PrintFormat("retcode=%u  transaction=%I64u  ordre=%I64u",result.retcode,result.deal,result.order);
        }
     }
  }
//+------------------------------------------------------------------+