//+------------------------------------------------------------------+
//|                                                       Atom 2.mq5 |
//|                                  Copyright 2021, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Rodrigo César Pagani"
#property link      "mailto: rodrigo@pagani.com.br"
#define   VERSION   "2.00"
#property version   VERSION
#define   nome_ea   "AtomBot "+VERSION+" - "+AccountInfoString(ACCOUNT_COMPANY)

//+------------------------------------------------------------------+
//| Definição localização Indicadores                                |
//+------------------------------------------------------------------+
#define   LinkKeltner    "::Shared Projects\\Atom2\\Indicators\\keltner_channel315.ex5"
#define   LinkVWap       "::Shared Projects\\Atom2\\Indicators\\VWap.ex5"
#define   LinkSATL       "Shared Projects\\Atom2\\Indicators\\satl.ex5"
#define   LinkFATL       "Shared Projects\\Atom2\\Indicators\\fatl.ex5"
#define   LinkMediaMovel "Shared Projects\\Atom2\\Indicators\\CustomIMA.ex5"
#define   LinkAngulo     "Shared Projects\\Atom2\\Indicators\\angle_of_averages.ex5"
#define   LinkRegressao  "Shared Projects\\Atom2\\Indicators\\Regressao.ex5"
#define   LinkZScore     "Shared Projects\\Atom2\\Indicators\\ZScore.ex5"

//+------------------------------------------------------------------+
//| inclusao das classes a serem utilizadas                          |
//+------------------------------------------------------------------+
#resource "\\Shared Projects\\Atom2\\Indicators\\keltner_channel315.ex5"
#resource "\\Shared Projects\\Atom2\\Indicators\\VWap.ex5"
#resource "\\Shared Projects\\Atom2\\Indicators\\fatl.ex5"
#resource "\\Shared Projects\\Atom2\\Indicators\\satl.ex5"
#resource "\\Shared Projects\\Atom2\\Indicators\\CustomIMA.ex5"
#resource "\\Shared Projects\\Atom2\\Indicators\\angle_of_averages.ex5"
#resource "\\Shared Projects\\Atom2\\Indicators\\Regressao.ex5"
#resource "\\Shared Projects\\Atom2\\Indicators\\ZScore.ex5"

#include <AtomBot2\Bot.mqh>
#include <AtomBot2\Negociacao.mqh>
#include <AtomBot2\StructEnum.mqh>
#include <AtomBot2\Financeiro.mqh>
#include <AtomBot2\FuncoesUteis.mqh>
#include <AtomBot2\Painel.mqh>

CMyBot bot;


//+------------------------------------------------------------------+
//| input genericas do EA                                            |
//+------------------------------------------------------------------+
input group              "Configurações da Ordem";
input double             ExpertContratos                 = 1;                     //Lotes, contratos ou ações
input long               ExpertNumeroMagico              = 41;                    //Número Mágico
input ENUM_ORDER_TYPE_FILLING  ExpertOrderFilling        = ORDER_FILLING_FOK;     //Tipo de preenchimento da ordem
input string             ExpertComentario                = "AtomBot";             //Comentário do EA
input double             ExpertGain                      = 70;                    //Take Profit pontos
input double             ExpertLoss                      = 150;                   //Stop Loss pontos
input condicao_          ExpertCompra                    = condicao_s;            //Operar compra
input condicao_          ExpertVenda                     = condicao_s;            //Operar venda
condicao_          ExpertDestaqueTPSL              = condicao_n;            //Destacar linha do Take Profit/Stop Loss/Abertura Posição
color              ExpertCorOP                     = clrYellow;             //Cor para linha Abertura Posição
color              ExpertCorTP                     = clrDeepSkyBlue;        //Cor para linha Take Profit
color              ExpertCorSL                     = clrRed;                //Cor para linha Stop Loss
//--------------------------------------------------------------------
input group              "Configuração da Hora";
//input TypeSystem_        ExpertTipoOperacao              = TypeSystem1;           //Day trade / Swing Trade
input tipohora_          ExpertTipo_hr                   = tipo_1;                //Tipo de horário
input string             ExpertHoraInicio_hr             = "9:30";                //Hora inicio
input string             ExpertIntervalo_Parar_hr        = "11:30";               //Intervalo - Parar de Operar (0-Desabilitado)
input string             ExpertIntervalo_Volta_hr        = "13:00";               //Intervalo - Voltar Operar (0-Desabilitado)
input string             ExpertHoraFim_hr                = "16:30";               //Hora final
input string             ExpertHoraFecha_hr              = "17:00";               //Fechar posição/ordens aberta
//--------------------------------------------------------------------
input group              "Metas Financeiras";
input condicao_          ExpertGanho_mf                  = condicao_s;            //Ativar meta diária para Ganho
input double             ExpertMetaGanho_mf              = 60.0;                  //Ganho máximo diário em R$
input condicao_          ExpertPerca_mf                  = condicao_s;            //Ativar meta diária para Perca
input double             ExpertMetaPerda_mf              = 980.0;                 //Perca máxima diária em R$
input condicao_          ExpertDesativarTerminal         = condicao_n;            //Encerrar terminal ao atingir meta financeira
//--------------------------------------------------------------------
input group              "Break Even";
input condicao_          ExpertBreakeven_be              = condicao_s;            //Ativar BreakEven
input double             ExpertDistancia_be              = 30;                    //Distância ativar
input double             ExpertProtecao_be               = 15;                    //Pontos a proteger
//--------------------------------------------------------------------
input group              "Trail Stop";
input condicao_          ExpertTrailstop_ts              = condicao_s;            //Ativar Trail Stop
input double             ExpertDistancia_ts              = 40;                    //Distância ativar
input double             ExpertProtecao_ts               = 20;                    //Margem em pontos
input double             ExpressStep_ts                  = 15;                    //Step Trail Stop
//--------------------------------------------------------------------
input group              "Trade System";
input TradeSystem_       ExpertTradeSystem               = TradeSystem1;          //Trade System
//--------------------------------------------------------------------
//input group              "Estratégias de ordem";
//input condicao_          ExpertPrecoMedio                = condicao_s;            //Ativar preço médio
//input int                ExpertMaximo_pm                 = 3;                     //Máximo de ordens da estratégia
//input double             ExpertFator_pm                  = 2;                     //Fator incrementador da estratégia
//input double             ExpertPontos_pm                 = 115;                   //Distância em pontos entre ordens
//--------------------------------------------------------------------
input group              "Configuração do Painel";
input condicao_          ExpertCriar_pn                  = condicao_s;            //Criar Painel
input int                ExpertXX_pn                     = 20;                    //Afastamento Horizontal do Painel
input int                ExpertYY_pn                     = 20;                    //Afastamento Vertical do Painel
input int                ExpertLargura_pn                = 340;                   //Largura do Painel
input int                ExpertAltura_pn                 = 375;                   //Altura do Painel
//--------------------------------------------------------------------
input group              "Keltner Channel";
input condicao_          ExpertAtivarKeltner             = condicao_s;            //Ativar Keltner Channel
input int                ExpertMM_Keltner                = 20;                    //Período média móvel Keltner
input int                ExpertPeriodo_Keltner           = 14;                    //Período Canal Keltner
input double             ExpertDesvio_Keltner            = 1.2;                   //Desvio Keltner
input enPrices           ExpertCalc_Price                = pr_typical;            //Preço média móvel
//--------------------------------------------------------------------
input group              "Linha de Tendência Adaptativa";
input condicao_          ExpertAtivarFATL                = condicao_n;            //Ativar Linha de Tendência Adaptativa Rápida(FATL)
input condicao_          ExpertAtivarSATL                = condicao_n;            //Ativar Linha de Tendência Adaptativa Lenta(SATL)
//--------------------------------------------------------------------
input group              "Grau de inclinação da média";
input condicao_          ExpertAtivarGrau                = condicao_s;            //Ativar Grau de inclinação
input int                ExpertMAPeriod                  = 34;                    //Período Média
input enumAveragesType   ExpertMAType                    = avgNlma;               //Tipo de cálculo
input enPrices           ExpertMAPrice                   = pr_close;              //Preço a usar
input int                ExpertAngleBars                 = 6;                     //Barras para angulo
input double             ExpertAngleLevel                = 8;                     //Nivel
//--------------------------------------------------------------------
input group              "Regressão Linear";
input condicao_          ExpertAtivarRegressaoLinear     = condicao_s;            //Ativar Regressão Linear
input int                ExpertRLPeriodo                 = 20;                    //Período Médio
input double             ExpertRLDesvio                  = 2.0;                   //Coeficiente de Desvio
//--------------------------------------------------------------------
input group              "Z-Score";
input condicao_          ExpertAtivarZScore              = condicao_s;            //Ativar Z-Score
input int                ExpertZSPeriodo                 = 20;                    //Período
input ENUM_APPLIED_PRICE ExpertZSPreco                   = PRICE_CLOSE;           //Preço
input double             ExpertZSDesvio                  = 2.0;                   //Coeficiente de Desvio
//--------------------------------------------------------------------
input group              "Média Móvel Rápida";
input condicao_          ExpertAtivarMediaRapida         = condicao_n;            //Ativar Média Móvel Rápida
input ENUM_APPLIED_PRICE ExpertRapidaPreco               = PRICE_CLOSE;           //Preço Aplicado para média
input int                ExpertRapidaPeriodo             = 7;                     //Período Média Móvel Rápida
input ENUM_MA_METHOD     ExpertRapidaMetodo              = MODE_SMA;              //Método Média Rápida
input color              ExpertRapidaCor                 = clrLightGreen;         //Cor Média Rápida
input ENUM_LINE_STYLE    ExpertRapidaEstilo              = STYLE_SOLID;           //Estilo da linha
input int                ExpertRapidaEspessura           = 1;                     //Espessura da linha
//--------------------------------------------------------------------
input group              "Média Móvel Lenta";
input condicao_          ExpertAtivarMediaLenta          = condicao_n;            //Ativar Média Móvel Lenta
input ENUM_APPLIED_PRICE ExpertLentaPreco                = PRICE_CLOSE;           //Preço Aplicado para média
input int                ExpertLentaPeriodo              = 21;                    //Período Média Móvel Rápida
input ENUM_MA_METHOD     ExpertLentaMetodo               = MODE_SMA;              //Método Média Rápida
input color              ExpertLentaCor                  = clrRed;                //Cor Média Rápida
input ENUM_LINE_STYLE    ExpertLentaEstilo               = STYLE_SOLID;           //Estilo da linha
input int                ExpertLentaEspessura            = 1;                     //Espessura da linha
//--------------------------------------------------------------------
input group              "Estocástico";
input condicao_          ExpertAtivarEstocastico         = condicao_n;            //Ativar Estocástico
input int                ExpertPeriodo_K                 = 8;                     //K-period (número de barras para cálculos)
input int                ExpertPeriodo_D                 = 3;                     //D-period (período da primeira suavização)
input int                ExpertSlowing                   = 3;                     //Final da suavização
input ENUM_MA_METHOD     ExpertMethod                    = MODE_SMA;              //Tipo de suavização
input ENUM_STO_PRICE     ExpertPrice_Field               = STO_LOWHIGH;           //Método de cálculo estocástico
input int                ExpertUp                        = 80;                    //Linha Superior Estocástico
input int                ExpertDown                      = 20;                    //Linha Inferior Estocástico
//--------------------------------------------------------------------
input group              "VWAP";
input condicao_          ExpertAtivarVWAP                = condicao_n;            //Ativar VWAP
input PRICE_TYPE         ExpertPrice_Type                = CLOSE_HIGH_LOW;        //Valor para Cálculo
input condicao_          ExpertCalc_Every_Tick           = condicao_n;            //Calcular cada Tick
input condicao_          ExpertEnable_Daily              = condicao_s;            //Habilitar Diário
condicao_          ExpertShow_Daily_Value          = condicao_n;            //Mostrar Valor Diário
input condicao_          ExpertEnable_Weekly             = condicao_s;            //Habilitar Semanal
condicao_          ExpertShow_Weekly_Value         = condicao_n;            //Mostrar Valor Semanal
input condicao_          ExpertEnable_Monthly            = condicao_s;            //Habilitar Mensal
condicao_          ExpertShow_Monthly_Value        = condicao_n;            //Mostrar Valor Mensal
//--------------------------------------------------------------------
input group              "Configuração Grupo Telegram";
input condicao_          ExpertAtivarBotTelegram         = condicao_n;            //Ativar Bot Telegram
input string             Experttoken                     = "";                    //Token do Grupo          
input long               ExpertUsuatioTelegram           = 0;                     //Usuário no Telegram     

//token ZeusBot                    1969425464:AAE5ub30YI5gwq4VGOnCCLesurBF_w5Ss3Q
//token AtomBot                    1964419004:AAGEDQfd4xvPK2NHQi2_i02C4uiKX1J_yLY
//Usuário para mandar mensagens    -546140899

//+------------------------------------------------------------------+
//| variaveis globais para os indicadores                            |
//+------------------------------------------------------------------+
// Keltner Channel
int    Keltner_Handle=0;    //Handle
double Keltner_Up[];
double Keltner_Middle[];
double Keltner_Down[];

//FATL
int    FATL_Handle=0;    //Handle
double FATL_Buffer[];

//SATL
int    SATL_Handle=0;    //Handle
double SATL_Buffer[];

//Grau Inclinação da Média
int    Grau_Handle=0;    //Handle
double Grauh_Buffer[];
double Grauc_Buffer[];
double Grau_Buffer[];

// VWAP
int    VWAP_Handle=0; //Handle
double VWAP_DIA[];
double VWAP_SEMANA[];
double VWAP_MES[];

// Stochastic
int    Stochastic_Handle=0; //Handle
double Stochastic_Buffer[];

//--- Médias Móveis
// RÁPIDA - menor período
int    Rapida_Handle=0;  // Handle controlador da média móvel rápida
double Rapida_Buffer[];  // Buffer para armazenamento dos dados das médias

// LENTA - maior período
int    Lenta_Handle=0;   // Handle controlador da média móvel lenta
double Lenta_Buffer[];   // Buffer para armazenamento dos dados das médias

// Angulo Média
int    Angulo_Handle=0;   // Handle controlador do Angulo da média
double Angulo_Buffer[];   // Buffer para armazenamento dos dados dos Angulos

// Regressão Linear
int    Regressao_Handle=0;   // Handle Regressão Linear
double Regressao_Buffer[];   // Buffer Regressão Linear

// Z-Score
int    ZScore_Handle=0;   // Handle Z-Score
double ZScore_Buffer[];   // Buffer Z-Score

//+------------------------------------------------------------------+
//| variaveis globais gerais                                         |
//+------------------------------------------------------------------+
MqlRates        Precos[];       // variável para armazenar preços
MqlTick         Tick;           // variável para armazenar ticks
string          Prefixo                 = "OBJECT:";
string          MoedaCorrente           = " "+(string)AccountInfoString(ACCOUNT_CURRENCY);
int             QtdeBuffer              = 4; //Qtde de registros a ser copiado no buffer
boleta          Negociacao;
financa         Financeiro;
double          SL_Anterior             = 0.00;
double          TP_Anterior             = 0.00;
double          OP_Anterior             = 0.00;
datetime        UltimoCandle;

//+------------------------------------------------------------------+
//| Initialization function of the expert                            |
//+------------------------------------------------------------------+
int OnInit(){
  RemoveIndicadores();
  
  ReiniciarBoleta();
  Negociacao.Desligado=false;  
  if(TotalPosicao(Negociacao.Ativo,Negociacao.NumeroMagico)>0)
    RecuperaBoleta();

  if(!Validacoes())
    return(INIT_FAILED);
  
  //--- create timer
  EventSetTimer(4);
  ConfiguraoInicial();
  
  AtualizarFinanceiro(Negociacao.Ativo,Negociacao.NumeroMagico);
    
  CopyRates(Negociacao.Ativo, Negociacao.Periodo, 0, QtdeBuffer, Precos);
  ArraySetAsSeries(Precos, true);

  InicializarIndicadores();
  AtualizarIndicadores();


  if(ExpertCriar_pn==1){
    CriarPainel(Prefixo, nome_ea, ExpertXX_pn, ExpertYY_pn, ExpertLargura_pn, ExpertAltura_pn);
    AtualizarPainel();
  }
  
  if(ExpertAtivarBotTelegram==1){
    bot.Usuario = ExpertUsuatioTelegram;
    bot.Token(Experttoken);
    bot.GetMe();
  }

  //--- ok
  return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Deinitialization function of the expert                          |
//+------------------------------------------------------------------+
void OnDeinit(const int reason){
  //--- destroy timer
  EventKillTimer();
  MarketBookRelease(Negociacao.Ativo);

  RemoveIndicadores();
  
  DestroiPainel(reason);
  ObjectsDeleteAll(0,Prefixo);
  IndicatorRelease(Keltner_Handle);
  IndicatorRelease(VWAP_Handle);
  IndicatorRelease(FATL_Handle);
  IndicatorRelease(SATL_Handle);
  IndicatorRelease(Stochastic_Handle);
  IndicatorRelease(Rapida_Handle);
  IndicatorRelease(Lenta_Handle);
  IndicatorRelease(Angulo_Handle);
  IndicatorRelease(Regressao_Handle);
  IndicatorRelease(ZScore_Handle);

  //Motivo do robo ter saido
  Print(GetReasonID(reason));
}
//+------------------------------------------------------------------+
//| "Tick" event handler function                                    |
//+------------------------------------------------------------------+
void OnTick(){
  if(Negociacao.Periodo != _Period)
    Negociacao.Periodo = _Period;
    
  // Alimentar com dados variável de tick
  SymbolInfoTick(Negociacao.Ativo,Tick);

  bool NovaOperacao= (TotalPosicao(Negociacao.Ativo,Negociacao.NumeroMagico)==0);
  bool NovoCandle  = CandleNovo(Negociacao.Ativo, Negociacao.Periodo);
  bool MesmoCandle = NegociacaoCandle(Negociacao.Ativo,Negociacao.NumeroMagico);

  if(NovoCandle){ 
    UltimoCandle   = Tick.time;   
  }

  if(LimiteHorario()){
    ClosePosicao(Negociacao.Ativo,Negociacao.NumeroMagico);
    ReiniciarBoleta();
  }
    
  if(NovaOperacao && MercadoAberto() && !MesmoCandle){
    AtualizarIndicadores();
    if(NovoCandle)
      ReiniciarBoleta();
    if(ExpertTradeSystem==1 && NovoCandle)
      RomperKeltner();
    if(ExpertTradeSystem==2)
      TocarKeltner();      
    if(ExpertTradeSystem==3 && NovoCandle)
      RetornoKeltner();
    if(ExpertTradeSystem==4)
      TocarKeltnerAcoes();
    if(ExpertTradeSystem==5)
      KeltnerAngulo();
  }

  if(((ExpertCompra==1 && Negociacao.Tipo=="Comprado") || (ExpertVenda==1 && Negociacao.Tipo=="Vendido"))){
    Stop();
    if(ExpertBreakeven_be==1)
      BreakEven();
    if(ExpertTrailstop_ts==1)
      TrailStop();
  }

  if(ExpertCriar_pn) 
    AtualizarPainel();
  if(ExpertDestaqueTPSL==1 && (Negociacao.StopLoss!=SL_Anterior || Negociacao.TakeProfit!=TP_Anterior || Negociacao.PrecoEntrada!=OP_Anterior)){      
    ObjectDelete(0, Prefixo+"PrecoAbertura");
    ObjectDelete(0, Prefixo+"StopLoss");
    ObjectDelete(0, Prefixo+"TakeProfit");
    if((ObjectFind(0,Prefixo+"StopLoss")!=0 || ObjectFind(0,Prefixo+"TakeProfit")!=0 || ObjectFind(0,Prefixo+"PrecoAbertura")!=0) && TotalPosicao(Negociacao.Ativo,Negociacao.NumeroMagico)==1){    
      Linha_Horizontal(Prefixo+"PrecoAbertura",Negociacao.PrecoEntrada,1,ExpertCorOP,STYLE_SOLID);
      Linha_Horizontal(Prefixo+"StopLoss",Negociacao.PrecoSL,1,ExpertCorSL,STYLE_SOLID);
      Linha_Horizontal(Prefixo+"TakeProfit",Negociacao.PrecoTP,1,ExpertCorTP,STYLE_SOLID);
      TP_Anterior=Negociacao.PrecoTP;
      SL_Anterior=Negociacao.PrecoSL;
      OP_Anterior=Negociacao.PrecoEntrada;
    }
  }
}
//+------------------------------------------------------------------+
//| "Trade" event handler function                                   |
//+------------------------------------------------------------------+
void OnTrade(){
   
}
//+------------------------------------------------------------------+
//| "ChartEvent" event handler function                                   |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam){
  //--- Move the panel with the mouse                  
  if(ExpertCriar_pn) 
    MovePainel(id, lparam, dparam, sparam);
  
  if(id==CHARTEVENT_OBJECT_CLICK){
    if(sparam==Prefixo+"Button1"){
      ClosePosicao(Negociacao.Ativo, Negociacao.NumeroMagico);
      if(TotalPosicao(Negociacao.Ativo, Negociacao.NumeroMagico)==0){
        Print("Posição encerrada com sucesso.");      
        ChartRedraw();
        ReiniciarBoleta();
      }      
    }
    uint retorno=0;
    if(sparam==Prefixo+"Button2" && MercadoAberto())
      retorno=CompraMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);          
    if(sparam==Prefixo+"Button3" && MercadoAberto())    
      retorno=VendaMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);
    if((sparam==Prefixo+"Button3" || sparam==Prefixo+"Button2") && !MercadoAberto())
      Print(StatusBot());
    if(retorno!=0 && retorno!=10008 && retorno!=10009)
      Print("8 - Erro de operação: ", GetRetcodeID(retorno));
    ZeroMemory(retorno);    
  }  
}
//+------------------------------------------------------------------+
//| "Timer" event handler function                                   |
//+------------------------------------------------------------------+
void OnTimer(){
  //---
    
  if(NovoDia(Negociacao.Ativo)){
    UltimoCandle=Tick.time;
    ReiniciarBoleta();
    AtualizarFinanceiro(Negociacao.Ativo,Negociacao.NumeroMagico);
    Print("------------------------------------Novo Dia------------------------------------");
    if(ExpertAtivarBotTelegram==1){
      string Mensagem = "\n---------------------------------------"+"\nBom dia pessoal, começando mais um pregão."+"\nDentro de instantes nosso robô entra em operação."+"\nBora para o gain e boa sorte para nós.";
      bot.EnviaMensagem(ExpertUsuatioTelegram, ExpertComentario+Mensagem);
    }
   }
  
  MetaFinanceira();
  if(ExpertCriar_pn){
    AtualizarPainel();  
    ChartRedraw();
  }
 
  if(ExpertAtivarBotTelegram==1){
    bot.GetUpdates();
    string mensagem=bot.ProcessMessages(ExpertComentario);
    if(mensagem=="/saldo"){
      AtualizarFinanceiro(Negociacao.Ativo,Negociacao.NumeroMagico);
      string resumo = "Resumo financeiro EA\n";        
      resumo += "Dia: "+   (string)Financeiro.QtdeGainD1+"/"+(string)Financeiro.QtdeTradeD1+" ("+(string)Porcentagem(Financeiro.QtdeGainD1,Financeiro.QtdeTradeD1)+"%) - R$ "+(string)Financeiro.ResultadoD1+"\n";
      resumo += "Semana: "+(string)Financeiro.QtdeGainW1+"/"+(string)Financeiro.QtdeTradeW1+" ("+(string)Porcentagem(Financeiro.QtdeGainW1,Financeiro.QtdeTradeW1)+"%) - R$ "+(string)Financeiro.ResultadoW1+"\n";
      resumo += "Mês: "+   (string)Financeiro.QtdeGainMN+"/"+(string)Financeiro.QtdeTradeMN+" ("+(string)Porcentagem(Financeiro.QtdeGainMN,Financeiro.QtdeTradeMN)+"%) - R$ "+(string)Financeiro.ResultadoMN+"\n";
      resumo += "Ano: "+   (string)Financeiro.QtdeGainY1+"/"+(string)Financeiro.QtdeTradeY1+" ("+(string)Porcentagem(Financeiro.QtdeGainY1,Financeiro.QtdeTradeY1)+"%) - R$ "+(string)Financeiro.ResultadoY1+"\n";
      bot.SendMessage(ExpertUsuatioTelegram,resumo);
    }
      
    if(mensagem=="/zerar"){
      Print("Zerando posições pelo Telegram");
      ClosePosicao(Negociacao.Ativo, Negociacao.NumeroMagico);
      if(TotalPosicao(Negociacao.Ativo, Negociacao.NumeroMagico)==0){
        bot.SendMessage(ExpertUsuatioTelegram,"Posições zeradas com sucesso");
        ReiniciarBoleta();
      }
    }
    if(mensagem=="/ligar"){
      Print("Ligando EA pelo Telegram");
      Negociacao.Desligado = false;
    }
    if(mensagem=="/desligar"){
      Print("Desligando EA pelo Telegram");
      Negociacao.Desligado = true;
    }
    if(mensagem=="/status"){
      bot.SendMessage(ExpertUsuatioTelegram,StatusBot());
    }
    if(mensagem=="/resumo"){
      ResumoNegociacaoTelegram();
    }
    if(mensagem=="/reset"){
      ReiniciarBoleta();
    }
    
  }
 
}

//+------------------------------------------------------------------+
//| TradeTransaction function                                        |
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction& trans,
                        const MqlTradeRequest& request,
                        const MqlTradeResult& result){
//---
  ulong                deal_magic =0;
  ENUM_DEAL_ENTRY      deal_entry;
  ENUM_DEAL_REASON     deal_reason;
  ENUM_DEAL_TYPE       deal_type;
  double               deal_profit=0;
  
  if(trans.type==TRADE_TRANSACTION_DEAL_ADD && trans.symbol==Negociacao.Ativo){
    if(HistoryDealSelect(trans.deal)){
      deal_magic  = HistoryDealGetInteger(trans.deal,DEAL_MAGIC);      
      deal_entry  = (ENUM_DEAL_ENTRY) HistoryDealGetInteger(trans.deal,DEAL_ENTRY);
      deal_reason = (ENUM_DEAL_REASON)HistoryDealGetInteger(trans.deal,DEAL_REASON);
      deal_type   = (ENUM_DEAL_TYPE)  HistoryDealGetInteger(trans.deal,DEAL_TYPE);
      if(deal_magic==Negociacao.NumeroMagico){
        if(deal_entry==DEAL_ENTRY_IN){        
          if(!Negociacao.PosicaoAberta){
            Negociacao.PosicaoAberta  = true;
            Negociacao.PrecoEntrada   = trans.price;
            Negociacao.Tipo           = TipoPosicao(Negociacao.Ativo, Negociacao.NumeroMagico);
            Negociacao.Ticket         = PositionGetTicket(PosicaoAtual(Negociacao.Ativo, Negociacao.NumeroMagico));
            Negociacao.TicketOrder    = 0;
            Negociacao.TotalOrder     = 0;
            Negociacao.TeveOrder      = false;
            Negociacao.PrecoUltOrder  = Negociacao.PrecoEntrada;
            Negociacao.QtdeUltOrder   = 0.00;
            Negociacao.MetaBatida     = false;
            Negociacao.Desligado      = false;
            Negociacao.FezBreakEven   = false;
            Negociacao.FezTrailStop   = false;
            Negociacao.PrecoTP        = trans.price_tp;
            Negociacao.PrecoSL        = trans.price_sl;
          }
        
          Print("################### - Nova Operação - ######################");
          ResumoNegociacao();
          if(ExpertAtivarBotTelegram==1)
            ResumoNegociacaoTelegram();
        }
        
        if(deal_entry!=DEAL_ENTRY_IN){
          if((ENUM_DEAL_REASON) deal_reason==DEAL_REASON_TP || (ENUM_DEAL_REASON) deal_reason==DEAL_REASON_SL || (ENUM_DEAL_REASON)deal_reason==DEAL_REASON_EXPERT || (ENUM_DEAL_REASON)deal_reason==DEAL_REASON_CLIENT){
            Print("############# Fechando Operação #############");
            ObjectDelete(0, Prefixo+"PrecoAbertura");
            ObjectDelete(0, Prefixo+"StopLoss");
            ObjectDelete(0, Prefixo+"TakeProfit");
            TP_Anterior=0.00;
            SL_Anterior=0.00;
            OP_Anterior=0.00;
            
          
            ReiniciarBoleta();
            ResumoNegociacao();
            deal_profit= NormalizeDouble(HistoryDealGetDouble(trans.deal,DEAL_PROFIT),2);
                  
            Financeiro.ResultadoY1+=deal_profit;
            Financeiro.ResultadoD1+=deal_profit;
            Financeiro.ResultadoW1+=deal_profit;
            Financeiro.ResultadoMN+=deal_profit;

            if(Financeiro.ResultadoD1>Financeiro.ResultadoMaxD1)
              Financeiro.ResultadoMaxD1=Financeiro.ResultadoD1;

            Financeiro.QtdeTradeY1+=1;
            Financeiro.QtdeTradeD1+=1;
            Financeiro.QtdeTradeW1+=1;
            Financeiro.QtdeTradeMN+=1;

            if(deal_profit>0){
              Financeiro.QtdeGainY1+=1;
              Financeiro.QtdeGainD1+=1;
              Financeiro.QtdeGainW1+=1;
              Financeiro.QtdeGainMN+=1;
            }
            if(deal_profit<0){
              Financeiro.QtdeLossY1+=1;
              Financeiro.QtdeLossD1+=1;
              Financeiro.QtdeLossW1+=1;
              Financeiro.QtdeLossMN+=1;
            }
          }
        }
      }
    }
  }
}
//+------------------------------------------------------------------+
//| Validaçãoes                                                      |
//+------------------------------------------------------------------+
bool Validacoes(){
  if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED)){
    Alert("Verifique se a negociação automatizada é permitida nas configurações do terminal!");
    return(false);
  }else{
    if(!MQLInfoInteger(MQL_TRADE_ALLOWED)){
      Alert("A negociação automatizada é proibida nas configurações do ",__FILE__);
      return(false);
    }
  }  
  return(true);
}
//+------------------------------------------------------------------+
//| Configurações Iniciais                                           |
//+------------------------------------------------------------------+
void ConfiguraoInicial(){
  //Remove grade do gráfico
  ChartSetInteger(0,CHART_SHOW_GRID, false);  
  ChartSetInteger(0,CHART_COLOR_CHART_UP,clrGreen);
  ChartSetInteger(0,CHART_COLOR_CHART_DOWN,clrRed);
  ChartSetInteger(0,CHART_COLOR_CANDLE_BEAR,clrWhite);
  ChartSetInteger(0,CHART_COLOR_CANDLE_BULL,clrWhite);
  ChartSetInteger(0,CHART_AUTOSCROLL,true);
  ChartSetInteger(0,CHART_MODE,CHART_CANDLES);
  ChartSetInteger(0,CHART_SHOW_LAST_LINE,false);
  ChartSetInteger(0,CHART_SHIFT,true);
  if(ExpertDestaqueTPSL==1)
    ChartSetInteger(0,CHART_COLOR_STOP_LEVEL,0,clrNONE);
  else
    ChartSetInteger(0,CHART_COLOR_STOP_LEVEL,0,clrRed);
  
}
//+------------------------------------------------------------------+
//| Inicializar Indicadores                                          |
//+------------------------------------------------------------------+
int InicializarIndicadores(){
  int subwindow;
  if(ExpertAtivarKeltner==1){
    Keltner_Handle   = iCustom(Negociacao.Ativo, Negociacao.Periodo, LinkKeltner, Negociacao.Periodo, ExpertMM_Keltner, ExpertPeriodo_Keltner, ExpertDesvio_Keltner, ExpertCalc_Price);
    ChartIndicatorAdd(0,0,Keltner_Handle);
    ChartIndicatorAdd(2,0,Keltner_Handle);
    ChartIndicatorAdd(3,0,Keltner_Handle);
  }

  if(ExpertAtivarVWAP==1){
    VWAP_Handle   = iCustom(Negociacao.Ativo, Negociacao.Periodo, LinkVWap, "VWAP", ExpertPrice_Type, (ExpertCalc_Every_Tick==1), (ExpertEnable_Daily==1), (ExpertShow_Daily_Value==1), (ExpertEnable_Weekly==1), (ExpertShow_Weekly_Value==1), (ExpertEnable_Monthly==1), (ExpertShow_Monthly_Value==1));
    ChartIndicatorAdd(0,0,VWAP_Handle);
    ChartIndicatorAdd(1,0,VWAP_Handle);
    ChartIndicatorAdd(2,0,VWAP_Handle);
  }

  if(ExpertAtivarSATL==1){
    SATL_Handle   = iCustom(Negociacao.Ativo, Negociacao.Periodo, LinkSATL);
    ChartIndicatorAdd(0,0,SATL_Handle);
  }

  if(ExpertAtivarFATL==1){
    FATL_Handle   = iCustom(Negociacao.Ativo, Negociacao.Periodo, LinkFATL);
    ChartIndicatorAdd(0,0,FATL_Handle);
  }

  if(ExpertAtivarMediaRapida==1){    
    Rapida_Handle   = iCustom(Negociacao.Ativo, Negociacao.Periodo, LinkMediaMovel, ExpertRapidaPeriodo, 0, ExpertRapidaMetodo, ExpertRapidaCor, ExpertRapidaEstilo, ExpertRapidaEspessura);
    ChartIndicatorAdd(0,0,Rapida_Handle);
  }

  if(ExpertAtivarMediaLenta==1){
    Lenta_Handle   = iCustom(Negociacao.Ativo, Negociacao.Periodo, LinkMediaMovel, ExpertLentaPeriodo, 0, ExpertLentaMetodo, ExpertLentaCor, ExpertLentaEstilo, ExpertLentaEspessura);
    ChartIndicatorAdd(0,0,Lenta_Handle);   
  }

  if(ExpertAtivarEstocastico==1){
    subwindow = (int)ChartGetInteger(0,CHART_WINDOWS_TOTAL);
    Stochastic_Handle= iStochastic(Negociacao.Ativo, Negociacao.Periodo, ExpertPeriodo_K, ExpertPeriodo_D, ExpertSlowing, ExpertMethod, ExpertPrice_Field);
    ChartIndicatorAdd(0,subwindow,Stochastic_Handle);   
  }

  if(ExpertAtivarGrau==1){
    subwindow = (int)ChartGetInteger(0,CHART_WINDOWS_TOTAL);
    Angulo_Handle   = iCustom(Negociacao.Ativo, Negociacao.Periodo, LinkAngulo, ExpertMAPeriod, ExpertMAType, ExpertMAPrice, ExpertAngleBars, ExpertAngleLevel);
    ChartIndicatorAdd(0,subwindow,Angulo_Handle);   
  }
  
  if(ExpertAtivarRegressaoLinear==1){
    subwindow = (int)ChartGetInteger(0,CHART_WINDOWS_TOTAL);
    Regressao_Handle   = iCustom(Negociacao.Ativo, Negociacao.Periodo, LinkRegressao, ExpertRLPeriodo, ExpertRLDesvio);
    ChartIndicatorAdd(0,subwindow,Regressao_Handle);   
  }
  
  if(ExpertAtivarZScore==1){
    subwindow = (int)ChartGetInteger(0,CHART_WINDOWS_TOTAL);
    ZScore_Handle   = iCustom(Negociacao.Ativo, Negociacao.Periodo, LinkZScore, ExpertZSPeriodo, ExpertZSPreco, ExpertZSDesvio);
    ChartIndicatorAdd(0,subwindow,ZScore_Handle);   
  }
  
  if(Keltner_Handle<0 || VWAP_Handle<0 || SATL_Handle<0 || FATL_Handle<0 || Rapida_Handle<0 || Lenta_Handle<0 || Stochastic_Handle<0 || Angulo_Handle<0 || Regressao_Handle<0 || ZScore_Handle<0){
    Alert("Erro ao tentar criar Handles para o indicador - erro: ",GetLastError(),"!");
    return(INIT_FAILED);
  }
  return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Atualizar Indicadores                                            |
//+------------------------------------------------------------------+
void AtualizarIndicadores(){
  //--- Alimentar Buffers das Velas com dados:
  CopyRates(Negociacao.Ativo,Negociacao.Periodo,0,QtdeBuffer,Precos);
  ArraySetAsSeries(Precos,true);

  if(ExpertAtivarKeltner==1){
    CopyBuffer(Keltner_Handle, 0, 0, QtdeBuffer, Keltner_Middle);
    CopyBuffer(Keltner_Handle, 2, 0, QtdeBuffer, Keltner_Up);
    CopyBuffer(Keltner_Handle, 3, 0, QtdeBuffer, Keltner_Down);
    // Ordenar o vetor de dados:
    ArraySetAsSeries(Keltner_Middle, true);
    ArraySetAsSeries(Keltner_Up, true);
    ArraySetAsSeries(Keltner_Down, true);
  }
  if(ExpertAtivarVWAP==1){
    CopyBuffer(VWAP_Handle, 0, 0, QtdeBuffer, VWAP_DIA);
    CopyBuffer(VWAP_Handle, 1, 0, QtdeBuffer, VWAP_SEMANA);
    CopyBuffer(VWAP_Handle, 2, 0, QtdeBuffer, VWAP_MES);
    // Ordenar o vetor de dados:
    ArraySetAsSeries(VWAP_DIA, true);
    ArraySetAsSeries(VWAP_SEMANA, true);
    ArraySetAsSeries(VWAP_MES, true);
  }
  if(ExpertAtivarFATL==1){
    CopyBuffer(FATL_Handle, 0, 0, QtdeBuffer, FATL_Buffer);
    ArraySetAsSeries(FATL_Buffer, true);  
  }
  if(ExpertAtivarSATL==1){
    CopyBuffer(SATL_Handle, 0, 0, QtdeBuffer, SATL_Buffer);
    ArraySetAsSeries(SATL_Buffer, true);
  }  
  if(ExpertAtivarMediaRapida==1){    
    CopyBuffer(Rapida_Handle,0,0,QtdeBuffer,Rapida_Buffer);
    ArraySetAsSeries(Rapida_Buffer,true);
  }
  if(ExpertAtivarMediaLenta==1){
    CopyBuffer(Lenta_Handle,0,0,QtdeBuffer,Lenta_Buffer);
    ArraySetAsSeries(Lenta_Buffer,true);
  }
  if(ExpertAtivarEstocastico==1){
    CopyBuffer(Stochastic_Handle,0,0,QtdeBuffer,Stochastic_Buffer);
    ArraySetAsSeries(Stochastic_Buffer,true);
  }
  if(ExpertAtivarGrau==1){
    CopyBuffer(Angulo_Handle,0,0,QtdeBuffer,Angulo_Buffer);
    ArraySetAsSeries(Angulo_Buffer,true);
  }
  if(ExpertAtivarRegressaoLinear==1){
    CopyBuffer(Regressao_Handle,0,0,QtdeBuffer,Regressao_Buffer);
    ArraySetAsSeries(Regressao_Buffer,true);
  }  
  if(ExpertAtivarZScore==1){
    CopyBuffer(ZScore_Handle,0,0,QtdeBuffer,ZScore_Buffer);
    ArraySetAsSeries(ZScore_Buffer,true);
  }  
}
//+------------------------------------------------------------------+
//| Atualizar Painel                                                 |
//+------------------------------------------------------------------+
void AtualizarPainel(){
  double Ping = TerminalInfoInteger(TERMINAL_PING_LAST);
  double Latencia=NormalizeDouble(Ping/1000,2);
  d_label1.Text(Hora(TimeTradeServer()));
  d_label2.Text(Data(SymbolInfoInteger(Negociacao.Ativo,SYMBOL_EXPIRATION_TIME)));
  d_label3.Text(Negociacao.Ativo);
  //d_label4.Text(Hora(TimeLocal()));
  d_label4.Text(TimerCandle(UltimoCandle));
  d_label5.Text((string)SymbolInfoInteger(Negociacao.Ativo,SYMBOL_SPREAD));   
  d_label6.Text(DoubleToString(Tick.last, _Digits)); 
  d_label7.Text((string)Financeiro.QtdeGainD1+"/"+(string)Financeiro.QtdeTradeD1+" ("+(string)Porcentagem(Financeiro.QtdeGainD1,Financeiro.QtdeTradeD1)+"%)"); 
  d_label8.Text((string)Financeiro.QtdeGainW1+"/"+(string)Financeiro.QtdeTradeW1+" ("+(string)Porcentagem(Financeiro.QtdeGainW1,Financeiro.QtdeTradeW1)+"%)"); 
  d_label9.Text((string)Financeiro.QtdeGainMN+"/"+(string)Financeiro.QtdeTradeMN+" ("+(string)Porcentagem(Financeiro.QtdeGainMN,Financeiro.QtdeTradeMN)+"%)"); 
  d_label10.Text((string)Financeiro.QtdeGainY1+"/"+(string)Financeiro.QtdeTradeY1+" ("+(string)Porcentagem(Financeiro.QtdeGainY1,Financeiro.QtdeTradeY1)+"%)"); 
  d_label11.Text(DoubleToString(NormalizeDouble(Financeiro.ResultadoD1, 2),2)+MoedaCorrente); 
  d_label12.Text(DoubleToString(NormalizeDouble(Financeiro.ResultadoW1, 2),2)+MoedaCorrente); 
  d_label13.Text(DoubleToString(NormalizeDouble(Financeiro.ResultadoMN, 2),2)+MoedaCorrente); 
  d_label14.Text(DoubleToString(NormalizeDouble(Financeiro.ResultadoY1, 2),2)+MoedaCorrente); 
  d_label15.Text(TipoConta()); 
  d_label16.Text(DoubleToString(Latencia,2)); 
  d_label17.Text(DoubleToString(NormalizeDouble(AccountInfoDouble(ACCOUNT_BALANCE),2),2)+MoedaCorrente); 
  d_label18.Text(Negociacao.Tipo); 
  d_label19.Text("0"); 
  d_label20.Text("0.00"+MoedaCorrente); 
  if(Posicionado(Negociacao.Ativo, Negociacao.NumeroMagico)){
    d_label19.Text((string)PositionGetDouble(POSITION_VOLUME));   
    d_label20.Text(DoubleToString(NormalizeDouble(LucroAtual(Negociacao.Ativo, Negociacao.NumeroMagico),2),2)+MoedaCorrente); 
  }
  d_label21.Text(StatusBot());
//  ChartRedraw();
}
//+------------------------------------------------------------------+
//| Reiniciar Boleta                                                 |
//+------------------------------------------------------------------+
void ReiniciarBoleta(){
  ZeroMemory(Negociacao);  
  Negociacao.Ativo          = _Symbol; 
  Negociacao.Periodo        = _Period;
  Negociacao.Moeda          = " "+(string)AccountInfoString(ACCOUNT_CURRENCY);
  Negociacao.Tipo           = TipoPosicao(Negociacao.Ativo, ExpertNumeroMagico);
  Negociacao.NumeroMagico   = ExpertNumeroMagico;
  Negociacao.StopLoss       = ExpertLoss;
  Negociacao.TakeProfit     = ExpertGain;
  Negociacao.TotalOrder     = 0;
  Negociacao.PosicaoAberta  = false;
  Negociacao.TeveOrder      = false;
  Negociacao.MetaBatida     = false;
  Negociacao.Desligado      = false;
  Negociacao.Encerrado      = false;
  Negociacao.FezBreakEven   = false;
  Negociacao.FezTrailStop   = false;
  Negociacao.Ticket         = 0;
  Negociacao.TicketOrder    = 0;
  Negociacao.PrecoEntrada   = 0.00;
  Negociacao.PrecoTP        = 0.00;
  Negociacao.PrecoSL        = 0.00;
  Negociacao.PrecoUltOrder  = 0.00;  
  Negociacao.QtdeUltOrder   = 0.00;

}
//+------------------------------------------------------------------+
//| Reiniciar Boleta                                                 |
//+------------------------------------------------------------------+
void RecuperaBoleta(){
  ZeroMemory(Negociacao);  
  Negociacao.Ativo          = _Symbol; 
  Negociacao.Periodo        = _Period;
  Negociacao.Moeda          = " "+(string)AccountInfoString(ACCOUNT_CURRENCY);
  Negociacao.Tipo           = TipoPosicao(Negociacao.Ativo, ExpertNumeroMagico);
  Negociacao.NumeroMagico   = ExpertNumeroMagico;
  Negociacao.StopLoss       = ExpertLoss;
  Negociacao.TakeProfit     = ExpertGain;
  Negociacao.TotalOrder     = TotalOrdem(Negociacao.Ativo, ExpertNumeroMagico);
  Negociacao.PosicaoAberta  = TotalPosicao(Negociacao.Ativo, ExpertNumeroMagico)>0;
  Negociacao.TeveOrder      = TotalOrdem(Negociacao.Ativo, ExpertNumeroMagico)>0;
  Negociacao.MetaBatida     = false;
  Negociacao.Desligado      = false;
  Negociacao.Encerrado      = false;
  Negociacao.FezBreakEven   = false; 
  Negociacao.FezTrailStop   = false;
  Negociacao.Ticket         = PositionGetTicket(PosicaoAtual(Negociacao.Ativo, Negociacao.NumeroMagico));
  Negociacao.PrecoEntrada   = PositionGetDouble(POSITION_PRICE_OPEN);
  Negociacao.PrecoTP        = PositionGetDouble(POSITION_TP);
  Negociacao.PrecoSL        = PositionGetDouble(POSITION_SL);
  uint   ultimaOrdem        = UltimaOrdem(Negociacao.Ativo, Negociacao.NumeroMagico);
  Negociacao.TicketOrder    = OrderGetTicket(ultimaOrdem);
  Negociacao.PrecoUltOrder  = OrderGetDouble(ORDER_PRICE_OPEN);
  Negociacao.QtdeUltOrder   = OrderGetDouble(ORDER_VOLUME_CURRENT);
  TP_Anterior=ObjectGetDouble(0,Prefixo+"PrecoAbertura",OBJPROP_PRICE,0);
  SL_Anterior=ObjectGetDouble(0,Prefixo+"StopLoss",OBJPROP_PRICE,0);
  OP_Anterior=ObjectGetDouble(0,Prefixo+"TakeProfit",OBJPROP_PRICE,0);
}
//+------------------------------------------------------------------+
//| Atualizar Financeiro                                             |
//+------------------------------------------------------------------+
void AtualizarFinanceiro(string Ativo, long numeromagioco){
  ZeroMemory(Financeiro);
  string               deal_simbol;
  ulong                deal_magic      = 0;
  ulong                ticket          = 0;
  ENUM_DEAL_ENTRY      deal_entry;
  ENUM_DEAL_REASON     deal_reason;
  double               deal_profit     = 0;
  double               lucro_dia       = 0;
  long                 PosicaoAnterior = 0;  
  datetime             InicioAno       = GetTimeFrame(Y1);
  datetime             InicioMes       = GetTimeFrame(MN1);
  datetime             InicioSemana    = GetTimeFrame(W1);
  datetime             InicioDia       = GetTimeFrame(D1);
  
  HistorySelect(InicioAno,TimeCurrent());  
  int totalHistory = HistoryDealsTotal();  

  for(int i=0;i<totalHistory;i++){
    if((ticket=HistoryDealGetTicket(i))>0){
      deal_magic      = HistoryDealGetInteger(ticket,DEAL_MAGIC);    
      deal_simbol     = HistoryDealGetString(ticket, DEAL_SYMBOL);
      deal_entry      = (ENUM_DEAL_ENTRY)HistoryDealGetInteger(ticket,DEAL_ENTRY);
      deal_reason     = (ENUM_DEAL_REASON)HistoryDealGetInteger(ticket,DEAL_REASON);
      bool Condicao1  = deal_magic==numeromagioco && deal_simbol==Ativo && deal_entry!=DEAL_ENTRY_IN;
      bool Condicao2  = (ENUM_DEAL_REASON)deal_reason==DEAL_REASON_TP || (ENUM_DEAL_REASON)deal_reason==DEAL_REASON_SL || (ENUM_DEAL_REASON)deal_reason==DEAL_REASON_EXPERT;
      if(Condicao1 && Condicao2){
        deal_profit= NormalizeDouble(HistoryDealGetDouble(ticket,DEAL_PROFIT),2);
        if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioDia)
		    Financeiro.ResultadoD1+=deal_profit;
		  if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioSemana)
		    Financeiro.ResultadoW1+=deal_profit;
		  if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioMes)
		    Financeiro.ResultadoMN+=deal_profit;
        if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioAno)  
          Financeiro.ResultadoY1+=deal_profit;        
          
        if(HistoryDealGetInteger(ticket,DEAL_POSITION_ID)!=PosicaoAnterior){
          PosicaoAnterior = HistoryDealGetInteger(ticket,DEAL_POSITION_ID);
		  
  		    if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioDia)
		      Financeiro.QtdeTradeD1+=1;
		    if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioSemana)
		      Financeiro.QtdeTradeW1+=1;
		    if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioMes)
            Financeiro.QtdeTradeMN+=1;
          if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioAno)
  		      Financeiro.QtdeTradeY1+=1;
            
          if(deal_profit>0){
		      if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioDia){
		        Financeiro.QtdeGainD1+=1;
		        lucro_dia+=deal_profit;
		      }
		      if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioSemana)
		        Financeiro.QtdeGainW1+=1;
		      if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioMes)  
		        Financeiro.QtdeGainMN+=1;
            if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioAno)
		        Financeiro.QtdeGainY1+=1;
		    }
		    if(deal_profit<0){
		      if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioDia)
		        Financeiro.QtdeLossD1+=1;
		      if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioSemana)
		        Financeiro.QtdeLossW1+=1;
		      if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioMes)
		        Financeiro.QtdeLossMN+=1;
		      if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioAno)
		        Financeiro.QtdeLossY1+=1;
          }		              
        }         
      }
    }
  } 
  if((ExpertGanho_mf==1 && Financeiro.ResultadoD1>=ExpertMetaGanho_mf) || (ExpertPerca_mf==1 && Financeiro.ResultadoD1<=(lucro_dia-ExpertMetaPerda_mf)))
    Negociacao.MetaBatida=true;
}
//+------------------------------------------------------------------+
//| Meta Financeira                                                  |
//+------------------------------------------------------------------+
void MetaFinanceira(){
  //-----> Meta Financeira
  if((ExpertGanho_mf==1 && Financeiro.ResultadoD1>=ExpertMetaGanho_mf) || (ExpertPerca_mf==1 && Financeiro.ResultadoD1<=(Financeiro.ResultadoMaxD1-ExpertMetaPerda_mf)))
    Negociacao.MetaBatida=true;
  if(ExpertPerca_mf==1 && (Financeiro.ResultadoD1+LucroAtual(Negociacao.Ativo, Negociacao.NumeroMagico))<=(Financeiro.ResultadoMaxD1-ExpertMetaPerda_mf))
    Negociacao.MetaBatida=true;

  if((ExpertGanho_mf==1 || ExpertPerca_mf==1) && Negociacao.MetaBatida && !Negociacao.Encerrado){
    Print("Meta Batida R$: "+(string)Financeiro.ResultadoD1+"------"+(string)TimeCurrent()+"--------------------------------------------------");
    Print("Dia: "+(string)Financeiro.QtdeGainD1+"/"+(string)Financeiro.QtdeTradeD1+" Resultado Financeiro: "+(string)Financeiro.ResultadoD1);
    Print("Semana: "+(string)Financeiro.QtdeGainW1+"/"+(string)Financeiro.QtdeTradeW1+" Resultado Financeiro: "+(string)Financeiro.ResultadoW1);
    Print("Mês: "+(string)Financeiro.QtdeGainMN+"/"+(string)Financeiro.QtdeTradeMN+" Resultado Financeiro: "+(string)Financeiro.ResultadoMN);
    Print("Ano: "+(string)Financeiro.QtdeGainY1+"/"+(string)Financeiro.QtdeTradeY1+" Resultado Financeiro: "+(string)Financeiro.ResultadoY1);
    ClosePosicao(Negociacao.Ativo, Negociacao.NumeroMagico);
    ReiniciarBoleta();
    Negociacao.MetaBatida=true;
    Negociacao.Encerrado=true;
    if(ExpertDesativarTerminal==1)
      TerminalClose(0);
  }
}
//+------------------------------------------------------------------+
//| Status do EA                                                     |
//+------------------------------------------------------------------+
string StatusBot(){ 
  datetime lastbar_time   = (datetime)SeriesInfoInteger(Negociacao.Ativo,PERIOD_M1,SERIES_LASTBAR_DATE);
  bool     Aberto         = lastbar_time>=StringToTime(ExpertHoraInicio_hr) && lastbar_time<StringToTime(ExpertHoraFim_hr);
  bool     MetaFinanceira = Negociacao.MetaBatida;
  bool     Conectado      = TerminalInfoInteger(TERMINAL_CONNECTED);
  bool     Intervalo      = true;
  
  if(ExpertIntervalo_Volta_hr!="0" && ExpertIntervalo_Parar_hr!="0")
    Intervalo = (lastbar_time<=StringToTime(ExpertIntervalo_Parar_hr) || lastbar_time>=StringToTime(ExpertIntervalo_Volta_hr));
   
  if(!Aberto && !Negociacao.Desligado && Conectado)
    return("Fora do horário de operação");
  if(Aberto && Intervalo && !MetaFinanceira && !Negociacao.PosicaoAberta && !Intervalo && !Negociacao.Desligado && Conectado)
    return("Aguardando novo sinal");
  if(Aberto && Intervalo && !MetaFinanceira && Negociacao.PosicaoAberta && !Negociacao.Desligado && Conectado)
    return("Posicionado");
  if(Aberto && !Intervalo && !MetaFinanceira && !Negociacao.PosicaoAberta && !Negociacao.Desligado && Conectado)
    return("Parada para intervalo programado");    
  if(MetaFinanceira  && !Negociacao.Desligado && Conectado)
    return("Meta financeira atingida");
  if(Negociacao.Desligado && Conectado)
    return("EA desligado pelo Telegram");
  if(!Conectado)
    return("Sem conexão com corretora");
  return("Aguardando novo sinal");
}
//+------------------------------------------------------------------+
//| Atualização Stop Loss / Take Profit                              |
//+------------------------------------------------------------------+
void Stop(){ 
  if(Negociacao.PosicaoAberta && !Negociacao.FezBreakEven && !Negociacao.FezTrailStop){
    double TakeProfit = 0.00;
    double StopLoss   = 0.00;
    if(Negociacao.Tipo=="Comprado"){
      TakeProfit=Negociacao.PrecoEntrada+Negociacao.TakeProfit;
      StopLoss  =Negociacao.PrecoEntrada-Negociacao.StopLoss;
    }
    if(Negociacao.Tipo=="Vendido"){
      TakeProfit=Negociacao.PrecoEntrada-Negociacao.TakeProfit;
      StopLoss  =Negociacao.PrecoEntrada+Negociacao.StopLoss;
    }   
    TakeProfit = NormalizarPreco(Negociacao.Ativo, TakeProfit);
    StopLoss   = NormalizarPreco(Negociacao.Ativo, StopLoss);

    PositionSelectByTicket(Negociacao.Ticket);
    bool Condicao1 = Negociacao.Tipo=="Comprado" || Negociacao.Tipo=="Vendido";
    bool Condicao2 = TakeProfit!=PositionGetDouble(POSITION_TP) || StopLoss!=PositionGetDouble(POSITION_SL);
    bool Condicao3 = TakeProfit!=0 && StopLoss!=0;
    bool Condicao4 = Negociacao.Ticket==PositionGetInteger(POSITION_TICKET);
    
    //bool Condicao5 = CheckStopLoss_Takeprofit((ENUM_ORDER_TYPE)PositionGetInteger(POSITION_TYPE), Negociacao.PrecoEntrada, StopLoss, TakeProfit);
    
    if(Condicao1 && Condicao2 && Condicao3 && Condicao4){
      uint retorno=0;
      Print("############# Atualizando SL/TP #############");
      retorno     = AtualizaTPSL(Negociacao.Ativo, Negociacao.Ticket, NormalizarPreco(Negociacao.Ativo, TakeProfit), NormalizarPreco(Negociacao.Ativo, StopLoss), Negociacao.NumeroMagico);
      if(retorno==10008 || retorno==10009){
        Negociacao.PrecoTP=NormalizarPreco(Negociacao.Ativo, TakeProfit);
        Negociacao.PrecoSL=NormalizarPreco(Negociacao.Ativo, StopLoss);
        Negociacao.PrecoEntrada=PositionGetDouble(POSITION_PRICE_OPEN);        
        ResumoNegociacao();
      }else
        if(retorno!=0 && retorno!=10008 && retorno!=10009)
          Print("5 - Erro de operação: ", GetRetcodeID(retorno));
    }
    //https://www.mql5.com/pt/articles/2555 TRADE_RETCODE_NO_CHANGES
    ZeroMemory(TakeProfit);
    ZeroMemory(StopLoss);        
  }
}

//https://www.mql5.com/pt/articles/2555 TRADE_RETCODE_NO_CHANGES

//+------------------------------------------------------------------+
//| BreakEven                                                        |
//+------------------------------------------------------------------+
void BreakEven(){
  if(Negociacao.PosicaoAberta && !Negociacao.FezBreakEven){
    double TakeProfit = 0.00;
    double StopLoss   = 0.00;
    if(Negociacao.Tipo=="Comprado" && Tick.last>Negociacao.PrecoEntrada+ExpertDistancia_be){
      TakeProfit=Negociacao.PrecoEntrada+Negociacao.TakeProfit;
      StopLoss  =Negociacao.PrecoEntrada+ExpertProtecao_be;
    }
    if(Negociacao.Tipo=="Vendido" && Tick.last<Negociacao.PrecoEntrada-ExpertDistancia_be){
      TakeProfit=Negociacao.PrecoEntrada-Negociacao.TakeProfit;
      StopLoss  =Negociacao.PrecoEntrada-ExpertProtecao_be;
    }

    PositionSelectByTicket(Negociacao.Ticket);
    bool Condicao1 = (Negociacao.Tipo=="Comprado" && StopLoss>Negociacao.PrecoSL) || (Negociacao.Tipo=="Vendido" && StopLoss<Negociacao.PrecoSL);
    bool Condicao2 = TakeProfit!=Negociacao.PrecoTP || StopLoss!=Negociacao.PrecoSL;
    bool Condicao3 = TakeProfit!=0 && StopLoss!=0;
    bool Condicao4 = Negociacao.Ticket==PositionGetInteger(POSITION_TICKET);
    //bool Condicao5 = CheckStopLoss_Takeprofit((ENUM_ORDER_TYPE)PositionGetInteger(POSITION_TYPE), Negociacao.PrecoEntrada, StopLoss, TakeProfit);
    if(Condicao1 && Condicao2 && Condicao3 && Condicao4){
      uint retorno=0;
      Print("############# Break Even #############");
      retorno     = AtualizaTPSL(Negociacao.Ativo, Negociacao.Ticket, NormalizarPreco(Negociacao.Ativo, TakeProfit), NormalizarPreco(Negociacao.Ativo, StopLoss), Negociacao.NumeroMagico);
      if(retorno==10008 || retorno==10009){
        Negociacao.FezBreakEven=true;
        Negociacao.PrecoTP=NormalizarPreco(Negociacao.Ativo, TakeProfit);
        Negociacao.PrecoSL=NormalizarPreco(Negociacao.Ativo, StopLoss);
        Negociacao.PrecoEntrada=PositionGetDouble(POSITION_PRICE_OPEN);
        ResumoNegociacao();
      }else
        if(retorno!=0 && retorno!=10008 && retorno!=10009)
          Print("6 - Erro de operação: ", GetRetcodeID(retorno));
    }
    ZeroMemory(TakeProfit);
    ZeroMemory(StopLoss);        
  }
}
//+------------------------------------------------------------------+
//| TrailStop                                                        |
//+------------------------------------------------------------------+
void TrailStop(){
  if(Negociacao.PosicaoAberta){
    double TakeProfit = 0.00;
    double StopLoss   = 0.00;
    if(Negociacao.Tipo=="Comprado" && Tick.last>Negociacao.PrecoEntrada+ExpertDistancia_ts){
      TakeProfit=Negociacao.PrecoEntrada+Negociacao.TakeProfit;
      StopLoss  =Tick.last-ExpertProtecao_ts;
    }
    if(Negociacao.Tipo=="Vendido" && Tick.last<Negociacao.PrecoEntrada-ExpertDistancia_ts){
      TakeProfit=Negociacao.PrecoEntrada-Negociacao.TakeProfit;
      StopLoss  =Tick.last+ExpertProtecao_ts;
    }
    
    PositionSelectByTicket(Negociacao.Ticket);
    bool Condicao1 = (Negociacao.Tipo=="Comprado" && StopLoss>Negociacao.PrecoSL+ExpressStep_ts) || (Negociacao.Tipo=="Vendido" && StopLoss<Negociacao.PrecoSL-ExpressStep_ts);
    bool Condicao2 = TakeProfit!=Negociacao.PrecoTP || StopLoss!=Negociacao.PrecoSL;
    bool Condicao3 = TakeProfit!=0 && StopLoss!=0;
    bool Condicao4 = Negociacao.Ticket==PositionGetInteger(POSITION_TICKET);
    //bool Condicao5 = CheckStopLoss_Takeprofit((ENUM_ORDER_TYPE)PositionGetInteger(POSITION_TYPE), Negociacao.PrecoEntrada, StopLoss, TakeProfit);
    if(Condicao1 && Condicao2 && Condicao3 && Condicao4){
      uint retorno=0;
      Print("############# Trail Stop #############");
      retorno     = AtualizaTPSL(Negociacao.Ativo, Negociacao.Ticket, NormalizarPreco(Negociacao.Ativo, TakeProfit), NormalizarPreco(Negociacao.Ativo, StopLoss), Negociacao.NumeroMagico);

      if(retorno==10008 || retorno==10009){
        Negociacao.FezTrailStop=true;
        Negociacao.PrecoTP=NormalizarPreco(Negociacao.Ativo, TakeProfit);
        Negociacao.PrecoSL=NormalizarPreco(Negociacao.Ativo, StopLoss);
        Negociacao.PrecoEntrada=PositionGetDouble(POSITION_PRICE_OPEN);
        ResumoNegociacao();
      }else
        if(retorno!=0 && retorno!=10008 && retorno!=10009)
          Print("7 - Erro de operação: ", GetRetcodeID(retorno));
    }
    ZeroMemory(TakeProfit);
    ZeroMemory(StopLoss);    
  }
}
//+------------------------------------------------------------------+
//| Permição para Operar                                             |
//+------------------------------------------------------------------+
bool MercadoAberto(){
  datetime horario=TimeCurrent();
  if(ExpertTipo_hr==0)
    horario=TimeLocal();
  if(ExpertTipo_hr==1)
    horario=(datetime)SeriesInfoInteger(Negociacao.Ativo,PERIOD_M1,SERIES_LASTBAR_DATE);

  bool Aberto    = horario>=StringToTime(ExpertHoraInicio_hr) && horario<StringToTime(ExpertHoraFim_hr) && !Negociacao.MetaBatida && !Negociacao.Desligado;
  bool Intervalo = true;
  if(ExpertIntervalo_Volta_hr!="0" && ExpertIntervalo_Parar_hr!="0")
    Intervalo = (horario<=StringToTime(ExpertIntervalo_Parar_hr) || horario>=StringToTime(ExpertIntervalo_Volta_hr));
//  bool SwingTrade = ExpertTipoOperacao==2 && horario>StringToTime(ExpertHoraInicio_hr) && !Negociacao.Desligado;
//  bool retorn = (Aberto && Intervalo) || SwingTrade;
  
  bool retorn = (Aberto && Intervalo);
  return retorn;
}
//+------------------------------------------------------------------+
//| Permição para Operar                                             |
//+------------------------------------------------------------------+
bool LimiteHorario(){
  datetime horario=TimeCurrent();
  if(ExpertTipo_hr==0)
    horario=TimeLocal();
  if(ExpertTipo_hr==1)
    horario=Precos[0].time;
  return(horario>=StringToTime(ExpertHoraFecha_hr) && Negociacao.PosicaoAberta);
}
//+------------------------------------------------------------------+
//| Estratégia de Entrada - Romper Keltner                           |
//+------------------------------------------------------------------+
void RomperKeltner(){
  uint retorno=0;
  
  if(Precos[1].close > Keltner_Up[1] && Precos[1].open < Keltner_Up[1] && Precos[1].open > Keltner_Down[1] && Precos[2].close < Keltner_Up[2] && Precos[2].close > Keltner_Down[2] && ExpertCompra==1){
    Print("############# Entrada Compra/Venda #############");  
    retorno=CompraMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);
  }
  if(Precos[1].close < Keltner_Down[1] && Precos[1].open > Keltner_Down[1] && Precos[1].open < Keltner_Up[1] && Precos[2].close < Keltner_Up[2] && Precos[2].close > Keltner_Down[2] && ExpertVenda==1){
    Print("############# Entrada Compra/Venda #############");  
    retorno=VendaMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);
  }
  if(retorno!=0 && retorno!=10008 && retorno!=10009)
    Print("1 - Erro de operação: ", GetRetcodeID(retorno));
  ZeroMemory(retorno);
}

//+------------------------------------------------------------------+
//| Estratégia de Entrada - Tocar Keltner                            |
//+------------------------------------------------------------------+
void TocarKeltner(){
  uint retorno=0;

  if(Precos[0].close >= Keltner_Up[0] && Precos[0].open < Keltner_Up[0] && Precos[0].open > Keltner_Down[0] && Precos[1].close < Keltner_Up[1] && Precos[1].close > Keltner_Down[1] && ExpertVenda==1)
    retorno=VendaMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);

  if(Precos[0].close <= Keltner_Down[0] && Precos[0].open > Keltner_Down[0] && Precos[0].open < Keltner_Up[0] && Precos[1].close < Keltner_Up[1] && Precos[1].close > Keltner_Down[1] && ExpertCompra==1)
    retorno=CompraMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);

  if(retorno!=0 && retorno!=10008 && retorno!=10009)
    Print("3 - Erro de operação: ", GetRetcodeID(retorno));

  ZeroMemory(retorno);
}
//+------------------------------------------------------------------+
//| Estratégia de Entrada - Tocar Keltner Ações                      |
//+------------------------------------------------------------------+
void TocarKeltnerAcoes(){
  uint retorno=0;
   
  if(Tick.bid >= Keltner_Up[0] && Precos[0].open < Keltner_Up[0] && Precos[0].open > Keltner_Down[0] && Precos[1].close < Keltner_Up[1] && Precos[1].close > Keltner_Down[1] && ExpertVenda==1)
    retorno=VendaMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);

  if(Tick.ask <= Keltner_Down[0] && Precos[0].open > Keltner_Down[0] && Precos[0].open < Keltner_Up[0] && Precos[1].close < Keltner_Up[1] && Precos[1].close > Keltner_Down[1] && ExpertCompra==1)
    retorno=CompraMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);
    
  if(retorno!=0 && retorno!=10008 && retorno!=10009)
    Print("9 - Erro de operação: ", GetRetcodeID(retorno));

  ZeroMemory(retorno);
}
//+------------------------------------------------------------------+
//| Estratégia de Entrada - Retornar Keltner                         |
//+------------------------------------------------------------------+
void RetornoKeltner(){
  uint retorno= 0;
  if(Precos[2].close>Keltner_Up[2] && Precos[1].close<Keltner_Up[1] && ExpertVenda==1)
    retorno=VendaMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);

  if(Precos[2].close<Keltner_Down[2] && Precos[1].close>Keltner_Down[1] && ExpertCompra==1)
    retorno=CompraMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);

  if(retorno!=0 && retorno!=10008 && retorno!=10009)
    Print("4 - Erro de operação: ", GetRetcodeID(retorno));

  ZeroMemory(retorno);  
}
//+------------------------------------------------------------------+
//| Estratégia de Entrada - Keltner/Angulo                           |
//+------------------------------------------------------------------+
void KeltnerAngulo(){
  uint retorno= 0;
  if(ExpertAtivarKeltner==1 && ExpertAtivarGrau==1){
    double AnguloInclinacao=3;
  
    bool RomperDown  = Tick.last<(Keltner_Down[0]-10) && Precos[2].close<Keltner_Up[2] && Precos[1].close>Keltner_Down[1] && Precos[0].close<Keltner_Down[0] && Angulo_Buffer[0]<-AnguloInclinacao;
    bool RetornoUp   = Precos[2].close>Keltner_Up[2] && Precos[1].open>Keltner_Up[1] && Precos[1].close<Keltner_Up[1] && Angulo_Buffer[0]<Angulo_Buffer[1];
    
    bool RomperUp    = Tick.last>(Keltner_Up[0]+10) && Precos[2].close>Keltner_Down[2] && Precos[1].close<Keltner_Up[1] && Precos[0].close>Keltner_Up[0] && Angulo_Buffer[0]>AnguloInclinacao;
    bool RetornoDown = Precos[2].close<Keltner_Down[2] && Precos[1].open<Keltner_Down[1] && Precos[1].close>Keltner_Down[1] && Angulo_Buffer[0]>Angulo_Buffer[1];


    if((RomperDown) && ExpertVenda==1)
      retorno=VendaMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);

    if((RomperUp) && ExpertCompra==1)
      retorno=CompraMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);

    if(retorno!=0 && retorno!=10008 && retorno!=10009)
      Print("10 - Erro de operação: ", GetRetcodeID(retorno));
  }
  ZeroMemory(retorno);  
}

//+------------------------------------------------------------------+
//| Resumo de como está as variáveis para negociação                 |
//+------------------------------------------------------------------+
void ResumoNegociacao(){
  Print("------------------------------------------------------------------------");
  Print("Horário           : ",(string)TimeLocal());
  Print("Nome Ativo        : ",Negociacao.Ativo);
  Print("Período           : ",EnumToString((ENUM_TIMEFRAMES)Negociacao.Periodo));
  Print("Número Mágico     : ",Negociacao.NumeroMagico);
  Print("Tipo Negociação   : ",Negociacao.Tipo);
  Print("Moeda             : ",Negociacao.Moeda);
  Print("Ticket            : ",Negociacao.Ticket);
  Print("Posição Aberta    : ",Negociacao.PosicaoAberta);
  Print("Preço Entrada     : ",Negociacao.PrecoEntrada);
  Print("Pontos Take Profit: ",Negociacao.TakeProfit);
  Print("Pontos Stop Loss  : ",Negociacao.StopLoss);
  Print("Preço Take Profit : ",Negociacao.PrecoTP);
  Print("Preço Stop Loss   : ",Negociacao.PrecoSL);
  Print("Total de Ordens   : ",Negociacao.TotalOrder);
  Print("Teve Ordens       : ",Negociacao.TeveOrder);
  Print("Preço última Ordem: ",Negociacao.PrecoUltOrder);
  Print("Qtde última Ordem : ",Negociacao.QtdeUltOrder);
  Print("Meta Batida       : ",Negociacao.MetaBatida);
  Print("Desligado         : ",Negociacao.Desligado);
  Print("Fez Break Even    : ",Negociacao.FezBreakEven);
  Print("Fez Trail Stop    : ",Negociacao.FezTrailStop);  
}
void ResumoNegociacaoTelegram(){
  string resumo="--------------------------------------\n";
  resumo+="Horário           : "+(string)TimeLocal()+"\n";
  resumo+="Nome Ativo        : "+(string)Negociacao.Ativo+"\n";
  resumo+="Período           : "+EnumToString((ENUM_TIMEFRAMES)Negociacao.Periodo)+"\n";
  resumo+="Número Mágico     : "+(string)Negociacao.NumeroMagico+"\n";
  resumo+="Tipo Negociação   : "+(string)Negociacao.Tipo+"\n";
  resumo+="Moeda             : "+(string)Negociacao.Moeda+"\n";
  resumo+="Ticket            : "+(string)Negociacao.Ticket+"\n";
  resumo+="Posição Aberta    : "+(string)Negociacao.PosicaoAberta+"\n";
  resumo+="Preço Entrada     : "+(string)Negociacao.PrecoEntrada+"\n";
  resumo+="Pontos Take Profit: "+(string)Negociacao.TakeProfit+"\n";
  resumo+="Pontos Stop Loss  : "+(string)Negociacao.StopLoss+"\n";
  resumo+="Preço Take Profit : "+(string)Negociacao.PrecoTP+"\n";
  resumo+="Preço Stop Loss   : "+(string)Negociacao.PrecoSL+"\n";
  resumo+="Total de Ordens   : "+(string)Negociacao.TotalOrder+"\n";
  resumo+="Teve Ordens       : "+(string)Negociacao.TeveOrder+"\n";
  resumo+="Preço última Ordem: "+(string)Negociacao.PrecoUltOrder+"\n";
  resumo+="Qtde última Ordem : "+(string)Negociacao.QtdeUltOrder+"\n";
  resumo+="Meta Batida       : "+(string)Negociacao.MetaBatida+"\n";
  resumo+="Desligado         : "+(string)Negociacao.Desligado+"\n";
  resumo+="Fez Break Even    : "+(string)Negociacao.FezBreakEven+"\n";
  resumo+="Fez Trail Stop    : "+(string)Negociacao.FezTrailStop+"\n";
  resumo+="Status: "+StatusBot();
  bot.SendMessage(ExpertUsuatioTelegram,resumo);
}
//+------------------------------------------------------------------+