SuperCharlie_Oxford/Homologacao_v4_4/S6_Transmissao_v4_4.mqh

<EFBFBD><EFBFBD>//+------------------------------------------------------------------+
//|                                          S6_Transmissao_v4_4.mq5 |
//|                                                           OXFORD |
//|                                             HEDGING HORN CAPITAL |
//|                                     https://www.hhcapital.com.br |
//+------------------------------------------------------------------+
#property copyright "Copyright 2022, HEDGING HORN CAPITAL"
#property link      "https://www.hhcapital.com.br"
#property version   "HOMOLOG_v4_4"
#property description "HFT MARKET MAKING BASED ON OXFORD'S STUDIES. MINI INDICE."

//+===================================================================================================================================================================================+
//| 0 - SESSAO DE CABECALHO / ADMISSAO                                                                                                                                                
//+===================================================================================================================================================================================+
//+------------------------------------------------------------------+
//| 0.1 - IMPORTACOES                                                |
//+------------------------------------------------------------------+
#include <Trade/Trade.mqh>
#include <Trade/SymbolInfo.mqh>
#include "S0_Admissao_v4_4.mqh"

//+===================================================================================================================================================================================+
//| 6 - SESSAO DE OPERACOES E EXECUCOES / ESCAPAMENTO                                                                                                                                 
//+===================================================================================================================================================================================+
//+------------------------------------------------------------------+
//| 6.1 - FUNCAO DE COMPRA LIMITADA                                  |
//+------------------------------------------------------------------+
void CompraLimite(operacao &Operacao, slot &Slots[], int i)
{
   //Limpar informacoes das estruturas
   ZeroMemory(Operacao.request);
   ZeroMemory(Operacao.result);
   ZeroMemory(Operacao.check_result);
   
   Operacao.request.magic = Operacao.magic;
   Operacao.request.symbol = _Symbol;
   Operacao.request.action = TRADE_ACTION_PENDING;
   Operacao.request.type = ORDER_TYPE_BUY_LIMIT;
   Operacao.request.type_filling = ORDER_FILLING_RETURN;
   Operacao.request.type_time = ORDER_TIME_DAY;
   Operacao.request.volume = Slots[i].qtd;
   Operacao.request.price = Slots[i].precoEnvio;
  // request.price = NormalizeDouble(precoEnvio,normalizeDoubleSize);
   Operacao.request.deviation = 0;
  // request.sl = NormalizeDouble(precoStop,normalizeDoubleSize);
   Operacao.request.sl = Slots[i].precoStop;
  // request.stoplimit = tickMin;
   Operacao.request.tp = Slots[i].precoAlvo;
   Operacao.request.comment = "Compra Limitada";
  // request.expiration = TimeCurrent()+2;
  // Print(request.price, "  ",request.tp, "  ",request.sl);
  // Print("Tipo: Compra Limitada", "/ Preco: ", NormalizeDouble(precoEnvio,normalizeDoubleSize),"/ Preco Stop: ", NormalizeDouble(precoStop,normalizeDoubleSize), "/ QTD: ", qtd);
   Operacao.numeroContratos = Operacao.numeroContratos + (Slots[i].qtd);   
   ResetLastError();
   
   if(!OrderCheck(Operacao.request, Operacao.check_result))
   {
      PrintFormat("Erro em OrderCheck: %d", GetLastError());
      Print("Compra - Codigo de retorno: ", Operacao.check_result.retcode, "  preco envio: ", Slots[i].precoEnvio, " preco stop: ", Slots[i].precoStop, " preco alvo: ", Slots[i].precoAlvo);
      Operacao.numeroContratos = Operacao.numeroContratos - Slots[i].qtd;
      return;
   }
   else
   {
      if(!OrderSend(Operacao.request, Operacao.result))
      {
         PrintFormat("Erro em OrderSend: %d", GetLastError());
         PrintFormat("Codigo de retorno: %d", Operacao.result.retcode);
         Operacao.numeroContratos = Operacao.numeroContratos - Slots[i].qtd;
         return;
      }
      else
      {
      //   Print("Ordem enviada com sucesso");
      }
   }
   Slots[i].idOrdem = Operacao.result.order;
}

//+------------------------------------------------------------------+
//| 6.2 - FUNCAO DE VENDA LIMITADA                                   |
//+------------------------------------------------------------------+
void VendaLimite(operacao &Operacao, slot &Slots[], int i)
{   
   //Limpar informacoes das estruturas
   ZeroMemory(Operacao.request);
   ZeroMemory(Operacao.result);
   ZeroMemory(Operacao.check_result);
   
   Operacao.request.magic = Operacao.magic;
   Operacao.request.symbol = _Symbol;
   Operacao.request.action = TRADE_ACTION_PENDING;
   Operacao.request.type = ORDER_TYPE_SELL_LIMIT;
   Operacao.request.type_filling = ORDER_FILLING_RETURN;
   Operacao.request.type_time = ORDER_TIME_DAY;
   Operacao.request.volume = Slots[i].qtd;
   Operacao.request.price = Slots[i].precoEnvio;
  // request.price = NormalizeDouble(precoEnvio,normalizeDoubleSize);
   Operacao.request.deviation = 0;
  // request.sl = NormalizeDouble(precoStop,normalizeDoubleSize);
   Operacao.request.sl = Slots[i].precoStop;
  // request.stoplimit = tickMin;
   Operacao.request.tp = Slots[i].precoAlvo;
   Operacao.request.comment = "Venda Limitada";
  // request.expiration = TimeCurrent()+2;
  // Print("Tipo: Venda Limitada", "/ Preco: ", NormalizeDouble(precoEnvio,normalizeDoubleSize),"/ Preco Stop: ", NormalizeDouble(precoStop,normalizeDoubleSize), "/ QTD: ", qtd);
   Operacao.numeroContratos = Operacao.numeroContratos + (Slots[i].qtd);
   ResetLastError();
   
   if(!OrderCheck(Operacao.request, Operacao.check_result))
   {
      PrintFormat("Erro em OrderCheck: %d", GetLastError());
      Print("Venda - Codigo de retorno: ", Operacao.check_result.retcode, "  preco envio: ", Slots[i].precoEnvio, " preco stop: ", Slots[i].precoStop, " preco alvo: ", Slots[i].precoAlvo);
      Operacao.numeroContratos = Operacao.numeroContratos - Slots[i].qtd;
      return;
   }
   else
   {
      if(!OrderSend(Operacao.request, Operacao.result))
      {
         PrintFormat("Erro em OrderSend: %d", GetLastError());
         PrintFormat("Codigo de retorno: %d", Operacao.result.retcode);
         Operacao.numeroContratos = Operacao.numeroContratos - Slots[i].qtd;
         return;
      }
      else
      {
       //  Print("Ordem enviada com sucesso");
      }
   }
   Slots[i].idOrdem = Operacao.result.order;
}

//+------------------------------------------------------------------+
//| 6.3 - FUNCAO DE COMPRA A MERCADO                                 |
//+------------------------------------------------------------------+
void CompraMercado(operacao &Operacao, slot &Slots[], int i)
{
   //Limpar informacoes das estruturas
   ZeroMemory(Operacao.request);
   ZeroMemory(Operacao.result);
   ZeroMemory(Operacao.check_result);
   
   Operacao.request.magic = Operacao.magic;
   Operacao.request.symbol = _Symbol;
   Operacao.request.action = TRADE_ACTION_DEAL;
   Operacao.request.type = ORDER_TYPE_BUY;
   Operacao.request.type_filling = ORDER_FILLING_RETURN;
   Operacao.request.type_time = ORDER_TIME_DAY;
   Operacao.request.volume = Slots[i].qtd;
   Operacao.request.sl = NormalizaPreco(Slots[i].precoStop);
  // request.stoplimit = tickMin;
  // request.tp = NormalizeDouble(precoAlvo,2);
   Operacao.request.comment = "Compra Mercado";
   
  // Print("Tipo: Compra Mercado", "/ Preco Stop: ", NormalizeDouble(precoStop,normalizeDoubleSize), "/ QTD: ", qtd);
      
   ResetLastError();
   
   if(!OrderCheck(Operacao.request, Operacao.check_result))
   {
      PrintFormat("Erro em OrderCheck: %d", GetLastError());
      PrintFormat("Codigo de retorno: %d", Operacao.check_result.retcode);
      return;
   }
   else
   {
      if(!OrderSend(Operacao.request, Operacao.result))
      {
         PrintFormat("Erro em OrderSend: %d", GetLastError());
         PrintFormat("Codigo de retorno: %d", Operacao.result.retcode);
         return;
      }
      else
      {
      //   Print("Ordem enviada com sucesso");
      }
   }
}

//+------------------------------------------------------------------+
//| 6.4 - FUNCAO DE VENDA A MERCADO                                  |
//+------------------------------------------------------------------+
void VendaMercado(operacao &Operacao, slot &Slots[], int i)
{   
   //Limpar informacoes das estruturas
   ZeroMemory(Operacao.request);
   ZeroMemory(Operacao.result);
   ZeroMemory(Operacao.check_result);

   Operacao.request.magic = Operacao.magic;
   Operacao.request.symbol = _Symbol;
   Operacao.request.action = TRADE_ACTION_DEAL;
   Operacao.request.type = ORDER_TYPE_SELL;
   Operacao.request.type_filling = ORDER_FILLING_RETURN;
   Operacao.request.type_time = ORDER_TIME_DAY;
   Operacao.request.volume = Slots[i].qtd;
   Operacao.request.sl = NormalizaPreco(Slots[i].precoStop);
  // request.stoplimit = tickMin;
  // request.tp = NormalizeDouble(precoAlvo,2);
   Operacao.request.comment = "Venda a mercado";
   
  // Print("Tipo: Venda Mercado", "/ Preco Stop: ",NormalizeDouble(precoStop,normalizeDoubleSize), "/ QTD: ", qtd);
      
   ResetLastError();
   
   if(!OrderCheck(Operacao.request, Operacao.check_result))
   {
      PrintFormat("Erro em OrderCheck: %d", GetLastError());
      PrintFormat("Codigo de retorno: %d", Operacao.check_result.retcode);
      return;
   }
   else
   {
      if(!OrderSend(Operacao.request, Operacao.result))
      {
         PrintFormat("Erro em OrderSend: %d", GetLastError());
         PrintFormat("Codigo de retorno: %d", Operacao.result.retcode);
         return;
      }
      else
      {
      //   Print("Ordem enviada com sucesso");
      }
   }
}

//+------------------------------------------------------------------+
//| 6.5 - FUNCAO QUE MODIFICA ORDEM ENVIADA                          |
//+------------------------------------------------------------------+
int ModificaOrdemEnviada(operacao &Operacao, slot &Slots[], int iSlot)
{
   //Percorre todas as ordens
   for(int i=OrdersTotal()-1; i>=0; i--)
   {
      ulong ticket = OrderGetTicket(i);
      string symbol = OrderGetString(ORDER_SYMBOL);
      ulong magicEA = OrderGetInteger(ORDER_MAGIC);
      
      //Verifica para cada ordem, se eh do simbolo corrente e do mesmo robo
      if((symbol == _Symbol) && (magicEA == Operacao.magic) && (ticket == Slots[iSlot].idOrdem))
      {
         Operacao.negocio.OrderModify(ticket, NormalizaPreco(Slots[iSlot].precoEnvio), NormalizaPreco(Slots[iSlot].precoStop), NormalizaPreco(Slots[iSlot].precoAlvo), ORDER_TIME_DAY, OrderGetInteger(ORDER_TIME_EXPIRATION));
         TimeToStruct(TimeCurrent(), Slots[iSlot].cronometro);
        // Print("Atualiza preco ordem: ", ticket, " Novo preco: ", Slots[iSlot].precoEnvio, " Novo stop: ", Slots[iSlot].precoStop, " Novo alvo: ", Slots[iSlot].precoAlvo); 
      }
    }
   
   return 0;
}

//+------------------------------------------------------------------+
//| 6.10 - FUNCAO DE CANCELAMENTO DE ORDEM PENDENTE DE COMPRA         |
//+------------------------------------------------------------------+ 
void CancelaOrdemAberta(operacao &Operacao, int idOrdem)
{
  // Print("Tentou cancelar ordem aberta");
   //CHECAR!!!!!!!!!!!!!!!!!!!
 //  Print("idOrdem: ", idOrdem);
   OrderSelect(idOrdem);
   double tamanho = OrderGetDouble(ORDER_VOLUME_INITIAL);
   bool retCancelou = Operacao.negocio.OrderDelete(idOrdem);
   
   if(retCancelou == false)
   {
      Print("Erro no cancelar ordem. N<00>o encontrou o idOrdem: ", idOrdem);
      return;
   } 
   
   Operacao.numeroContratos = Operacao.numeroContratos - tamanho;
   return;
}

//+------------------------------------------------------------------+
//| 6.7 - FUNCAO DE CANCELAMENTO DE ORDENS PENDENTES                 |
//+------------------------------------------------------------------+ 
void CancelaOrdensAbertas(operacao &Operacao)
{
   ulong ticket = 0;
   ;
   for(int i=OrdersTotal()-1;i>=0;i--)
   {
      ticket = OrderGetTicket(i);
      string symbol = PositionGetString(POSITION_SYMBOL);
      ulong magicEA = PositionGetInteger(POSITION_MAGIC);
      double tamanho = OrderGetDouble(ORDER_VOLUME_INITIAL);
      if((symbol == _Symbol) && (magicEA == Operacao.magic))
      {
         bool retCancelou = Operacao.negocio.OrderDelete(ticket);
         if(retCancelou == true)
         {
            Operacao.numeroContratos = Operacao.numeroContratos - tamanho;
            Print("Cancelou ordem aberta");
         }
      }     
   }
   
   return;
}

//+------------------------------------------------------------------+
//| 6.6 - FUNCAO QUE MODIFICA ORDEM EXECUTADA                        |
//+------------------------------------------------------------------+
void ModificaPosicaoAberta(operacao &Operacao, ulong ticket)
{
   PositionSelect(ticket);
   Operacao.negocio.PositionModify(ticket, Operacao.precoStop, Operacao.precoAlvo);
   
   return;
}


//+------------------------------------------------------------------+
//| 6.7 - FUNCAO QUE MODIFICA ORDEM EXECUTADA                        |
//+------------------------------------------------------------------+
void ModificaStopPosicaoAberta(operacao &Operacao, ulong ticket)
{
   PositionSelect(ticket);
   Operacao.negocio.PositionModify(ticket, Operacao.precoStop, Operacao.precoAlvo);
   
   return;
}



//+------------------------------------------------------------------+
//| 6.8 - FUNCAO DE FECHAMENTO DE UMA POSICAO ESPECIFICA             |
//+------------------------------------------------------------------+
void FechaPosicao(operacao &Operacao, ulong ticket)
{
   PositionSelect(ticket);
   Operacao.negocio.PositionClose(ticket, -1);

   return;
}


//+------------------------------------------------------------------+
//| 6.9 - FUNCAO DE FECHAMENTO DE TODAS AS POSICOES                  |
//+------------------------------------------------------------------+
bool FechaPosicoes(operacao &Operacao)
{
   int qtd = 0;
   qtd = PositionsTotal();

   //Print("Posicoes totais: ", qtd);
   
   for(int i=0;i<qtd;i++)
   {
      if(!PositionSelect(_Symbol))
      {
         Print("Nao ha posicoes abertas no fechamento do dia.");
      }
      else
      {
         ulong ticket = PositionGetTicket(i);
         string symbol = PositionGetString(POSITION_SYMBOL);
         ulong magicEA = PositionGetInteger(POSITION_MAGIC);
         int tipoPosicao = 0;
         double  volume = 0.0; 
         
         tipoPosicao = PositionGetInteger(POSITION_TYPE);
         volume = PositionGetDouble(POSITION_VOLUME);
         
         if((symbol == _Symbol) && (magicEA == Operacao.magic))
         {
            if(tipoPosicao == POSITION_TYPE_BUY)
            {
              Operacao.negocio.PositionClose(ticket, -1);
              Print("Saida de posicao comprada por fechamento do dia.");
            }
            else if(tipoPosicao==POSITION_TYPE_SELL)
            {
              Operacao.negocio.PositionClose(ticket, -1);
              Print("Saida de posicao vendida por fechamento do dia.");
            }
         }
      }
   }
   
  // Operacao.chaveFechaPosicao = false;

   return false;
}

//+------------------------------------------------------------------+
//| 6.10 - FUNCAO QUE NORMALIZA O PRECO PARA O TICK DO ATIVO         |
//+------------------------------------------------------------------+ 
double NormalizaPreco(double price)
{
   double precoNormalizado;
   precoNormalizado = price - MathMod(price,5*_Point);
   return precoNormalizado;
}

//+===================================================================================================================================================================================+
//| FIM DO PROGRAMA                                                                                                   
//+===================================================================================================================================================================================+