Construindo um Modelo de Restrição de Tendência com Candlesticks (Parte 5): Sistema de Notificação (Parte I)

Conteúdo

• Introdução
• Notificações do terminal
• Notificações push
• Notificações por email
• Depurando Trend Constraint V1.04
• Integrando os canais de redes sociais (ex.: Telegram e WhatsApp)
• Integração com Telegram
• Integração com WhatsApp
• O poder de uma rede privada virtual (VPS) no nosso sistema de notificações
• Conclusão

Introdução

O MetaTrader 5 oferece várias opções de notificação para informar os usuários sobre eventos de negociação, como notificações de terminal, por email e push. Integrá-lo com plataformas sociais como Telegram e WhatsApp para compartilhamento de sinais pode ser altamente benéfico. Configurar notificações no MetaTrader 5 permite que você se mantenha informado sobre suas atividades de negociação, independentemente de sua localização. Utilizando os métodos de acesso às notificações mencionados, você pode escolher a opção que melhor se adequa às suas necessidades. Este guia vai te orientar na configuração e personalização das notificações do MetaTrader 5, incluindo a integração com Telegram e outras plataformas de mídia social. Ele se concentrará nos detalhes de configuração e nos primeiros passos para a integração, preparando o caminho para uma exploração mais aprofundada na Parte II desta série.

Notificações do terminal

As notificações do terminal são alertas internos na plataforma MetaTrader 5. Elas cobrem todos os eventos de alerta acionados dentro do MetaTrader 5. Você pode definir manualmente alertas no MetaTrader 5 para serem acionados quando condições específicas forem atendidas. As configurações de alerta geralmente são encontradas na aba ferramentas, na parte inferior da janela padrão do MetaTrader 5.

• Símbolo: Selecione o instrumento de negociação para o qual deseja configurar o alerta.
• Condição: Escolha a condição que acionará o alerta (ex.: Bid >, Ask <, Tempo =, etc.).
• Valor: Especifique o valor contra o qual a condição será comparada (ex.: um nível de preço específico).
• Fonte: Selecione o tipo de alerta (ex.: Som, Arquivo, Email, etc.). Para notificações de terminal, você pode escolher Som.
• Ação: Selecione a ação a ser tomada quando o alerta for acionado (ex.: tocar um som, enviar uma notificação, etc.).
• Som: Escolha um arquivo de som para ser reproduzido quando o alerta for acionado.
• Intervalo: Defina o intervalo de tempo após o qual o alerta será verificado novamente.
• Máximo de Iterações: Especifique o número de vezes que o alerta deve ser acionado.

Abaixo está um exemplo de configuração de um alerta usando o Step Index sintético. Os valores mostrados na tabela podem ser ajustados com base nas suas necessidades. Após configurar as definições, clique em Ok para criar o alerta, e ele estará pronto para ativação. Veja a imagem de demonstração animada abaixo da tabela para um resumo rápido. Para começar, clique com o botão direito na aba de alertas na janela de ferramentas, selecione criar no menu que aparecerá e uma caixa de diálogo com as configurações descritas na tabela será aberta.

Configuração	Valor
Símbolo	Step Index
Condição	Bid>
Valor	9666
Fonte	Som
Ação	Selecionado um arquivo de som (alert2.wav)
Intervalo	Definido para 60 segundos
Máximo de Iterações	Configurações para 5

 

Notificações push

É um recurso no MetaTrader 5 que permite que notificações geradas na plataforma, seja internamente ou por um indicador ou assessor especializado, sejam enviadas para um telefone celular via a plataforma MetaTrader 5, através do ID MetaQuotes do dispositivo móvel. Para que o dispositivo móvel receba notificações push, o MetaTrader 5 deve ser instalado a partir da playstore para Android ou apple store para IOS. No MetaTrader 5 de desktop, as notificações push devem ser ativadas para que o alerta seja recebido no celular. Um ID MetaQuotes único é criado no celular logo após a instalação do MetaTrader 5 móvel. 

À esquerda, você pode encontrar uma imagem ilustrando como localizar o ID MetaQuotes. À direita, há uma imagem demonstrando como ativar notificações push na plataforma MetaTrader 5 de desktop, juntamente com o campo para inserir o ID MetaQuotes. Marcando a caixa e inserindo o ID da sua plataforma móvel, você poderá começar a receber notificações instantaneamente na seção de mensagens do MetaTrader 5 móvel. Você pode adicionar vários IDs MetaQuotes de diferentes dispositivos móveis, separando-os.

       

Notificações por email

O email continua sendo uma ferramenta poderosa e versátil de comunicação devido à sua conveniência, eficiência e ampla gama de funcionalidades. Seja para uso pessoal, correspondência de negócios ou redes profissionais, o email fornece um meio confiável e eficaz de se manter conectado e trocar informações. Configurar notificações por email no MetaTrader 5 permite receber alertas por email para várias atividades de negociação, como movimentos de preços, execuções de ordens e eventos personalizados.

A vantagem dos emails é sua entrega quase instantânea, permitindo troca de informações rápida e disseminação eficiente para grandes grupos. Os serviços de email geralmente oferecem criptografia para proteger o conteúdo, garantindo segurança de informações confidenciais. A entrega direta para caixas de entrada dos destinatários minimiza os riscos de interceptação em comparação com outras formas de comunicação.

Aqui está um guia passo a passo para configurar notificações por email:

• Inicie a plataforma MetaTrader 5 no seu computador.
• Vá para Ferramentas > Opções > Email.
• Marque a caixa Habilitar.
• Preencha os Detalhes do Servidor SMTP:

Configuração	Preencher detalhes
Servidor SMTP	O endereço do servidor SMTP do seu provedor de email (por exemplo, smtp.gmail.com para o Gmail).
Login SMTP	Seu endereço de email (por exemplo, [e-mail]).
Senha SMTP	Sua senha de email ou senha específica de aplicativo, se estiver usando o Gmail.
De	Seu endereço de email (por exemplo, [e-mail]).
Para	O endereço de email para onde você deseja receber notificações (pode ser o mesmo que o endereço "De" ou diferente).

O que é um servidor SMTP.

Com base em minha pesquisa, um servidor Simple Mail Transfer Protocol (SMTP) é um servidor de email que utiliza o protocolo (SMTP) para enviar, receber e retransmitir emails de saída. Ele funciona juntamente com o Agente de Transferência de Correio (MTA) para direcionar os emails do cliente de email do remetente para o servidor de email do destinatário. Aqui está uma lista de provedores de email com servidores SMTP:

• gmail
• yahoo mail
• hotmail
• zohomail
• icloud mail

Depurando Trend Constraint V1.04

Integramos com sucesso o estilo Draw_Line nas tendências do nosso sistema. No entanto, descobri que muitos alertas estavam sendo acionados após cada barra devido a esse novo recurso. Por exemplo, quando um gráfico estava configurado para um período de tempo de um minuto, alertas eram gerados em cada fechamento de vela de um minuto, o que é bastante excessivo.

Nosso objetivo é obter sinais otimizados, focando apenas em alguns selecionados. Para resolver esse problema, contemplei a possibilidade de corrigir o código removendo myalert() dos buffers cinco e seis. É essencial que esse código seja corrigido para a integração perfeita do Telegram e WhatsApp, conforme discutido neste artigo. Abaixo está a versão revisada do nosso código:

Buffer 5 Modificado:

// --- Buffer5 (Buy Trend)
      if(MA5[i] > MA6[i])
        {
         Buffer5[i] = Low[i] - 15 * myPoint;
         // Disabled myAlert from Buffer 5
         // myAlert("indicator", "BUY TREND | MA Fast: " + DoubleToString(MA5[i], 2) + " | MA Slow: " + DoubleToString(MA6[i], 2));
        }

Buffer 6 Modificado:

// --- Buffer6 (Sell Trend)
      if(MA5[i] < MA6[i])
        {
         Buffer6[i] = High[i] + 15 * myPoint;
         // Disabled myAlert from Buffer 6
         // myAlert("indicator", "SELL TREND | MA Fast: " + DoubleToString(MA5[i], 2) + " | MA Slow: " + DoubleToString(MA6[i], 2));
        }

Trend Constraint V1.04 modificado:

///Indicator Name: Trend Constraint
#property copyright "Clemence Benjamin"
#property link      "https://mql5.com"
#property version   "1.04"
#property description "A model that seek to produce sell signal when D1 candle is Bearish only and  buy signal when it is Bullish"
//--- indicator settings
#property indicator_chart_window
#property indicator_buffers 6
#property indicator_plots 6

#property indicator_type1 DRAW_ARROW
#property indicator_width1 5
#property indicator_color1 0xFF3C00
#property indicator_label1 "Buy"

#property indicator_type2 DRAW_ARROW
#property indicator_width2 5
#property indicator_color2 0x0000FF
#property indicator_label2 "Sell"

#property indicator_type3 DRAW_ARROW
#property indicator_width3 2
#property indicator_color3 0xE8351A
#property indicator_label3 "Buy Reversal"

#property indicator_type4 DRAW_ARROW
#property indicator_width4 2
#property indicator_color4 0x1A1AE8
#property indicator_label4 "Sell Reversal"

#property indicator_type5 DRAW_LINE
#property indicator_style5 STYLE_SOLID
#property indicator_width5 2
#property indicator_color5 0xFFAA00
#property indicator_label5 "Buy Trend"

#property indicator_type6 DRAW_LINE
#property indicator_style6 STYLE_SOLID
#property indicator_width6 2
#property indicator_color6 0x0000FF
#property indicator_label6 "Sell Trend"

#define PLOT_MAXIMUM_BARS_BACK 5000
#define OMIT_OLDEST_BARS 50

//--- indicator buffers
double Buffer1[];
double Buffer2[];
double Buffer3[];
double Buffer4[];
double Buffer5[];
double Buffer6[];

input double Oversold = 30;
input double Overbought = 70;
input int Slow_MA_period = 200;
input int Fast_MA_period = 100;
datetime time_alert; //used when sending alert
input bool Audible_Alerts = true;
input bool Push_Notifications = true;
double myPoint; //initialized in OnInit
int RSI_handle;
double RSI[];
double Open[];
double Close[];
int MA_handle;
double MA[];
int MA_handle2;
double MA2[];
int MA_handle3;
double MA3[];
int MA_handle4;
double MA4[];
double Low[];
double High[];
int MA_handle5;
double MA5[];
int MA_handle6;
double MA6[];

void myAlert(string type, string message)
  {
   if(type == "print")
      Print(message);
   else if(type == "error")
     {
      Print(type+" | Trend Constraint V1.04 @ "+Symbol()+","+IntegerToString(Period())+" | "+message);
     }
   else if(type == "order")
     {
     }
   else if(type == "modify")
     {
     }
   else if(type == "indicator")
     {
      if(Audible_Alerts) Alert(type+" | Trend Constraint V1.04 @ "+Symbol()+","+IntegerToString(Period())+" | "+message);
      if(Push_Notifications) SendNotification(type+" | Trend Constraint V1.04 @ "+Symbol()+","+IntegerToString(Period())+" | "+message);
     }
  }

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {   
   SetIndexBuffer(0, Buffer1);
   PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   PlotIndexSetInteger(0, PLOT_ARROW, 241);
   SetIndexBuffer(1, Buffer2);
   PlotIndexSetDouble(1, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(1, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   PlotIndexSetInteger(1, PLOT_ARROW, 242);
   SetIndexBuffer(2, Buffer3);
   PlotIndexSetDouble(2, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(2, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   PlotIndexSetInteger(2, PLOT_ARROW, 236);
   SetIndexBuffer(3, Buffer4);
   PlotIndexSetDouble(3, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(3, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   PlotIndexSetInteger(3, PLOT_ARROW, 238);
   SetIndexBuffer(4, Buffer5);
   PlotIndexSetDouble(4, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(4, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   SetIndexBuffer(5, Buffer6);
   PlotIndexSetDouble(5, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(5, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   //initialize myPoint
   myPoint = Point();
   if(Digits() == 5 || Digits() == 3)
     {
      myPoint *= 10;
     }
   RSI_handle = iRSI(NULL, PERIOD_CURRENT, 14, PRICE_CLOSE);
   if(RSI_handle < 0)
     {
      Print("The creation of iRSI has failed: RSI_handle=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   MA_handle = iMA(NULL, PERIOD_CURRENT, 7, 0, MODE_SMMA, PRICE_CLOSE);
   if(MA_handle < 0)
     {
      Print("The creation of iMA has failed: MA_handle=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   MA_handle2 = iMA(NULL, PERIOD_CURRENT, 400, 0, MODE_SMA, PRICE_CLOSE);
   if(MA_handle2 < 0)
     {
      Print("The creation of iMA has failed: MA_handle2=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   MA_handle3 = iMA(NULL, PERIOD_CURRENT, 100, 0, MODE_EMA, PRICE_CLOSE);
   if(MA_handle3 < 0)
     {
      Print("The creation of iMA has failed: MA_handle3=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   MA_handle4 = iMA(NULL, PERIOD_CURRENT, 200, 0, MODE_SMA, PRICE_CLOSE);
   if(MA_handle4 < 0)
     {
      Print("The creation of iMA has failed: MA_handle4=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   MA_handle5 = iMA(NULL, PERIOD_CURRENT, Fast_MA_period, 0, MODE_SMA, PRICE_CLOSE);
   if(MA_handle5 < 0)
     {
      Print("The creation of iMA has failed: MA_handle5=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   MA_handle6 = iMA(NULL, PERIOD_CURRENT, Slow_MA_period, 0, MODE_SMA, PRICE_CLOSE);
   if(MA_handle6 < 0)
     {
      Print("The creation of iMA has failed: MA_handle6=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime& time[],
                const double& open[],
                const double& high[],
                const double& low[],
                const double& close[],
                const long& tick_volume[],
                const long& volume[],
                const int& spread[])
  {
   int limit = rates_total - prev_calculated;
   //--- counting from 0 to rates_total
   ArraySetAsSeries(Buffer1, true);
   ArraySetAsSeries(Buffer2, true);
   ArraySetAsSeries(Buffer3, true);
   ArraySetAsSeries(Buffer4, true);
   ArraySetAsSeries(Buffer5, true);
   ArraySetAsSeries(Buffer6, true);
   //--- initial zero
   if(prev_calculated < 1)
     {
      ArrayInitialize(Buffer1, EMPTY_VALUE);
      ArrayInitialize(Buffer2, EMPTY_VALUE);
      ArrayInitialize(Buffer3, EMPTY_VALUE);
      ArrayInitialize(Buffer4, EMPTY_VALUE);
      ArrayInitialize(Buffer5, EMPTY_VALUE);
      ArrayInitialize(Buffer6, EMPTY_VALUE);
     }
   else
      limit++;
   datetime Time[];
   
   int RSIBuffer;
   int MABuffer;
   int RSIPeriod = 14;
   ArrayResize(RSI, rates_total);
   ArrayResize(Open, rates_total);
   ArrayResize(Close, rates_total);
   CopyOpen(NULL, 0, 0, rates_total, Open);
   CopyClose(NULL, 0, 0, rates_total, Close);
   if(CopyBuffer(RSI_handle, 0, 0, rates_total, RSI) < 0)
     {
      Print("Getting RSI values failed, not enough bars!");
     }
   ArrayResize(MA, rates_total);
   if(CopyBuffer(MA_handle, 0, 0, rates_total, MA) < 0)
     {
      Print("Getting MA values failed, not enough bars!");
     }
   ArrayResize(MA2, rates_total);
   if(CopyBuffer(MA_handle2, 0, 0, rates_total, MA2) < 0)
     {
      Print("Getting MA values failed, not enough bars!");
     }
   ArrayResize(MA3, rates_total);
   if(CopyBuffer(MA_handle3, 0, 0, rates_total, MA3) < 0)
     {
      Print("Getting MA values failed, not enough bars!");
     }
   ArrayResize(MA4, rates_total);
   if(CopyBuffer(MA_handle4, 0, 0, rates_total, MA4) < 0)
     {
      Print("Getting MA values failed, not enough bars!");
     }
   ArrayResize(Low, rates_total);
   if(CopyLow(NULL, 0, 0, rates_total, Low) < 0)
     {
      Print("Getting LOW values failed, not enough bars!");
     }
   ArrayResize(High, rates_total);
   if(CopyHigh(NULL, 0, 0, rates_total, High) < 0)
     {
      Print("Getting HIGH values failed, not enough bars!");
     }
   ArrayResize(MA5, rates_total);
   if(CopyBuffer(MA_handle5, 0, 0, rates_total, MA5) < 0)
     {
      Print("Getting MA values failed, not enough bars!");
     }
   ArrayResize(MA6, rates_total);
   if(CopyBuffer(MA_handle6, 0, 0, rates_total, MA6) < 0)
     {
      Print("Getting MA values failed, not enough bars!");
     }
   
   for(int i=limit-1; i>=0; i--)
     {
      if(i < rates_total-1 && time[i] != time[i+1]+PeriodSeconds())
        {
         continue;
        }
      Buffer1[i] = EMPTY_VALUE;
      Buffer2[i] = EMPTY_VALUE;
      Buffer3[i] = EMPTY_VALUE;
      Buffer4[i] = EMPTY_VALUE;
      Buffer5[i] = EMPTY_VALUE;
      Buffer6[i] = EMPTY_VALUE;

      // --- Indicator calculations
      // --- Buffer1 (Buy)
      if((Close[i] > MA[i] && MA[i] > MA2[i] && RSI[i] < Oversold) || (RSI[i] < Oversold && Close[i] > MA3[i]))
        {
         Buffer1[i] = Low[i] - 5 * myPoint;
         myAlert("indicator", "BUY OPPORTUNITY | RSI: " + DoubleToString(RSI[i], 2) + " | MA: " + DoubleToString(MA[i], 2));
        }
      
      // --- Buffer2 (Sell)
      if((Close[i] < MA[i] && MA[i] < MA2[i] && RSI[i] > Overbought) || (RSI[i] > Overbought && Close[i] < MA3[i]))
        {
         Buffer2[i] = High[i] + 5 * myPoint;
         myAlert("indicator", "SELL OPPORTUNITY | RSI: " + DoubleToString(RSI[i], 2) + " | MA: " + DoubleToString(MA[i], 2));
        }
      
      // --- Buffer3 (Buy Reversal)
      if(RSI[i] < Oversold && Close[i] > MA[i])
        {
         Buffer3[i] = Low[i] - 10 * myPoint;
         myAlert("indicator", "BUY REVERSAL | RSI: " + DoubleToString(RSI[i], 2) + " | MA: " + DoubleToString(MA[i], 2));
        }
      
      // --- Buffer4 (Sell Reversal)
      if(RSI[i] > Overbought && Close[i] < MA[i])
        {
         Buffer4[i] = High[i] + 10 * myPoint;
         myAlert("indicator", "SELL REVERSAL | RSI: " + DoubleToString(RSI[i], 2) + " | MA: " + DoubleToString(MA[i], 2));
        }
      
      // --- Buffer5 (Buy Trend)
      if(MA5[i] > MA6[i])
        {
         Buffer5[i] = Low[i] - 15 * myPoint;
         //Disabled myAlert from Buffer 5
         // myAlert("indicator", "BUY TREND | MA Fast: " + DoubleToString(MA5[i], 2) + " | MA Slow: " + DoubleToString(MA6[i], 2));
        }
      
      // --- Buffer6 (Sell Trend)
      if(MA5[i] < MA6[i])
        {
         Buffer6[i] = High[i] + 15 * myPoint;
         // Disabled myAlert from Buffer 6
         // myAlert("indicator", "SELL TREND | MA Fast: " + DoubleToString(MA5[i], 2) + " | MA Slow: " + DoubleToString(MA6[i], 2));
        }
     }
   return(rates_total);
  }

Integrando a rede social (ex.: Telegram e WhatsApp)

Esta seção do artigo mostrará a integração do Telegram e WhatsApp no MetaTrader 5 especificamente para o nosso indicador de Restrição de Tendência. Esse processo aumenta significativamente as capacidades do MetaTrader 5, oferecendo notificações em tempo real, seguras e convenientes. Essas integrações melhoram a eficiência, capacidade de resposta e eficácia das atividades de negociação, servindo como ferramentas valiosas para os traders atualmente. Com uma vasta base de usuários nessas plataformas, compartilhar sinais com essas comunidades pode ser benéfico. Vamos nos aprofundar em como podemos transmitir os sinais gerados pelo nosso indicador para as plataformas de mídia social. Realizei pesquisas e testei para confirmar sua funcionalidade.

Requisitos: 

• Plataforma mais recente do MetaTrader5 para desktop.
• Contas verificadas de WhatsApp e Telegram (baixe na playstore para Android e na app store para IOS).
• Navegador de internet, por exemplo, Google Chrome.
• Servidor para hospedar scripts intermediários.

Integração com Telegram

Passo 1: Criar um Bot no Telegram

Criar o Bot:

• Abra o Telegram e procure pelo bot "BotFather".
• Inicie uma conversa com o BotFather e use o comando /newbot para criar um novo bot.
• Siga as instruções para definir um nome e nome de usuário para o seu bot.
• O BotFather fornecerá um token, que você usará para interagir com a API do Telegram.

Obter o ID do Chat:

• Adicione seu bot a um grupo no Telegram ou inicie um chat com ele.
• Use a seguinte URL no seu navegador para obter atualizações e encontrar o seu ID de chat: https://api.telegram.org/bot<YourBotToken>/getUpdates
• Envie uma mensagem no chat e verifique a URL novamente para encontrar o ID do chat.

Para um guia mais abrangente sobre como obter um ID de bate-papo, visite Github

Passo 2: Criar um Script Intermediário

Você precisará de um script para enviar mensagens via API do Telegram.

Para criar um script intermediário, vamos usar a linguagem Python, conforme as pesquisas realizadas. Este script em Python usa a biblioteca requests para enviar uma mensagem para um chat no Telegram via bot. Aqui está uma explicação de cada linha do script:

import requests

Importa a biblioteca requests usada para fazer requisições HTTP em Python. Neste script, será usada para enviar uma requisição POST para a API do Bot Telegram.

def send_telegram_message(chat_id, message, bot_token):

Define uma função chamada send_telegram_message: Esta função possui três parâmetros:

1. chat_id: O identificador exclusivo para o chat de destino ou nome de usuário do canal alvo.
2. message: O texto da mensagem a ser enviado.
3. bot_token: O token do bot do Telegram, fornecido por @BotFather ao criar o bot.

    url = f"https://api.telegram.org/bot{bot_token}/sendMessage"

Esta linha constrói a URL para o método sendMessage da API do Bot Telegram usando o bot_token fornecido.

    payload = {
        'chat_id': chat_id,
        'text': message
    }

Cria o payload para a requisição POST. Este dicionário contém os parâmetros necessários para o método sendMessage:

• chat_id: O ID do chat para onde a mensagem será enviada.
• text: O conteúdo da mensagem.

    response = requests.post(url, data=payload)

Esta linha envia a requisição HTTP POST para a URL construída com os dados do payload usando o método requests.post. A resposta da API é armazenada na variável response.

    return response.json()

Esta linha converte a resposta para o formato JSON e a retorna. Esta resposta JSON geralmente contém informações sobre a mensagem enviada, incluindo ID da mensagem, remetente, detalhes do chat e mais.

Combinando todas as partes do código, aqui está o que obtemos:

import requests

def send_telegram_message(chat_id, message, bot_token):
    url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
    payload = {
        'chat_id': chat_id,
        'text': message
    }
    response = requests.post(url, data=payload)
    return response.json()

Passo 3: Configurar o MetaTrader 5 para Usar o Script Intermediário

Crie um script MQL5 para enviar alertas por requisições HTTP para o seu script intermediário.

Vamos analisar o código e entender cada linha:

void SendTelegramMessage(string chat_id, string message, string bot_token)

 Define uma função chamada SendTelegramMessage.

Parâmetros dentro da função:

• chat_id: Uma string representando o ID do chat do Telegram para onde a mensagem será enviada.
• message: Uma string contendo a mensagem a ser enviada.
• bot_token: Uma string representando o token do bot necessário para a autorização com a API do Telegram.

Abertura do Corpo da Função:

{
    string url = "http://your-server-url/send_telegram_message";

 Atribui o URL do endpoint do servidor à variável url. Este URL é o endereço do servidor que lida com o encaminhamento da mensagem para o Telegram.

    char postData[];
    StringToCharArray("chat_id=" + chat_id + "&message=" + message + "&bot_token=" + bot_token, postData);

postData Array:

• Declaração: Declara um array postData do tipo char para armazenar os dados da requisição POST.
• Conversão de String para Array de Char: Converte uma string concatenada dos parâmetros chat_id, message e bot_token em um array de caracteres e armazena em postData. A string concatenada forma o corpo da requisição POST no formato exigido pelo servidor.

    char result[];

Declara um array result do tipo char para armazenar a resposta da requisição web.

    int res = WebRequest("POST", url, "", NULL, 0, postData, 0, result, NULL);

Requisição Web:

• Método HTTP: "POST" indica o tipo de requisição.
• URL: url é o endpoint para enviar a requisição.
• Headers: Uma string vazia "" significa sem cabeçalhos adicionais.
• Cookies: NULL indica que não há cookies.
• Timeout: 0 especifica que não há tempo limite.
• Post Data: postData é o dado a ser enviado na requisição POST.
• Resultado: result é onde a resposta será armazenada.
• A função retorna um inteiro res, que é o código de status HTTP da resposta.

    if (res != 200)

Verificar Código de Resposta: Compara o código de resposta res com 200 (HTTP OK). Se não for 200, indica um erro.

Tratador de Erro:

    {
        Print("Error sending message: ", GetLastError());
    }

Imprimir Mensagem de Erro: Se o código de resposta não for 200, este bloco imprime uma mensagem de erro juntamente com o último código de erro usando GetLastError().

Tratador de Sucesso:

    else
    {
        Print("Message sent successfully.");
    }

Imprimir Mensagem de Sucesso: Se o código de resposta for 200, este bloco imprime uma mensagem indicando que a mensagem foi enviada com sucesso.

Esta linha encerra a função SendTelegramMessage com a chave de fechamento.

 Código MQL5 Enviando Mensagens para o Telegram:

void SendTelegramMessage(string chat_id, string message, string bot_token)
{
    string url = "http://your-server-url/send_telegram_message";
    char postData[];
    StringToCharArray("chat_id=" + chat_id + "&message=" + message + "&bot_token=" + bot_token, postData);
    
    char result[];
    int res = WebRequest("POST", url, "", NULL, 0, postData, 0, result, NULL);
    if (res != 200)
    {
        Print("Error sending message: ", GetLastError());
    }
    else
    {
        Print("Message sent successfully.");
    }
}

Este script MQL5 acima foi projetado para enviar uma mensagem para um chat do Telegram, fazendo uma requisição web para um endpoint de servidor. O exemplo de uso mostra como utilizar a função SendTelegramMessage dentro do evento OnStart, que é executado quando o script é iniciado. A seguir, veremos a integração com o WhatsApp na próxima seção, e toda a explicação sobre a integração com o Telegram faz sentido mesmo quando se trata de uma plataforma social diferente. Lembre-se sempre de substituir algumas partes do código pelas suas credenciais reais para que funcionem.

Integração com WhatsApp

Passo 1: Registrar-se com um Provedor de API de Mensagens.

• Escolha um Provedor: Twilio é uma escolha popular para a integração com o WhatsApp.
• Crie uma Conta: Cadastre-se no Twilio e complete qualquer verificação necessária.
• Obtenha Credenciais da API: Obtenha suas credenciais da API (SID da conta, token de autenticação) do Twilio.

Passo 2: Criar um Script Intermediário

Script Intermediário em Python para Integração com WhatsApp:

import requests

def send_whatsapp_message(to, message, account_sid, auth_token):
    url = f"https://api.twilio.com/2010-04-01/Accounts/{account_sid}/Messages.json"
    payload = {
        'From': 'whatsapp:[phone]',  # Twilio sandbox number
        'To': f'whatsapp:{to}',
        'Body': message
    }
    headers = {
        'Authorization': f'Basic {account_sid}:{auth_token}'
    }
    response = requests.post(url, data=payload, headers=headers)
    return response.json()

Passo 3: Configurar o MetaTrader 5 para Usar o Middleware

Código MQL5 para enviar notificações pelo WhatsApp:

void SendWhatsAppMessage(string to, string message, string account_sid, string auth_token)
{
    string url = "http://your-server-url/send_whatsapp_message";
    char postData[];
    StringToCharArray("to=" + to + "&message=" + message + "&account_sid=" + account_sid + "&auth_token=" + auth_token, postData);
    
    char result[];
    int res = WebRequest("POST", url, "", NULL, 0, postData, 0, result, NULL);
    if (res != 200)
    {
        Print("Error sending message: ", GetLastError());
    }
    else
    {
        Print("Message sent successfully.");
    }
}

O Poder do Serviço Privado Virtual (VPS) no nosso sistema de notificações

Um Serviço Privado Virtual opera continuamente sem tempo de inatividade, garantindo que sua plataforma MetaTrader 5 e os sistemas de notificação estejam sempre ativos. Isso é fundamental para receber notificações em tempo real sem interrupções. Os provedores de VPS oferecem conexões de internet robustas e estáveis, reduzindo o risco de desconexões que podem ocorrer com redes domésticas ou de escritório. Os servidores VPS estão frequentemente localizados em data centers com conexões de alta velocidade para grandes bolsas financeiras, reduzindo a latência e melhorando a velocidade com que os alertas de negociação e notificações são recebidos e executados. Ao contrário da hospedagem compartilhada, um VPS fornece recursos dedicados de CPU, RAM e armazenamento, garantindo desempenho consistente para a execução do MetaTrader 5 e o gerenciamento de notificações. Um VPS pode ser acessado remotamente de qualquer dispositivo com conexão à internet, permitindo que você gerencie sua plataforma MetaTrader 5 e receba notificações de qualquer lugares.

Conclusão

Configuramos com sucesso um sistema de notificação robusto para o nosso indicador, estabelecendo a base para a integração com o WhatsApp e o Telegram. Essa melhoria é fundamental para atrair uma grande comunidade, pois esses sinais podem ser compartilhados instantaneamente. Os desenvolvedores podem se beneficiar comercializando esses sinais para traders interessados por meio dessas plataformas populares, oferecendo um meio rápido e eficiente de transmissão diretamente da plataforma para os canais de mídia social.

Essa abordagem garante a acessibilidade dos sinais a qualquer momento e em qualquer lugar com acesso à internet, permitindo um compartilhamento fácil com apenas um clique. Os traders podem escolher convenientemente entre Telegram ou WhatsApp para acesso aos sinais. Detalhes adicionais sobre a integração serão explorados na Parte II. Por favor, encontre os arquivos de referência anexados abaixo. Sinta-se à vontade para participar das discussões na seção de comentários.