Ir para o conteúdo

Notificações personalizadas

A API de notificação personalizada inclui tipos que permitem que os algoritmos de negociação entreguem alertas pop-up em tempo real diretamente no cTrader. Estes pop-ups permitem que cBots, indicadores e plugins comuniquem progresso, sucesso, erros ou informações gerais aos utilizadores de forma visual e contextual.

Com o suporte da API de notificações personalizadas, os cBots já não têm de depender do separador Log, objetos de gráfico ou pontes Telegram externas para comunicação. Os Algos simplesmente dizem aos traders o que está a acontecer diretamente através do sistema de notificação padrão no cTrader. Os desenvolvedores de algoritmos e os utilizadores beneficiam de velocidade, fiabilidade e clareza sem configurações complexas.

As interfaces API relevantes incluem:

  • INotifications.ShowPopup(caption, message, state) para exibir uma notificação pop-up com um determinado título, mensagem e estado (PopupNotificationState).
  • Interface PopupNotification para controlo programático de notificações de longa duração ou progressivas, chamando .Complete() para atualizar o seu estado final.

As mensagens entregues pela API de notificações personalizadas aparecem instantaneamente, são codificadas por cores por estado e podem ser concluídas posteriormente. Os estados de notificação são definidos usando a enumeração PopupNotificationState:

  • InProgress para representar processos de longa duração ou estados pendentes. Exemplo:

  • Success para indicar que uma operação foi concluída com sucesso. Exemplo:

  • Error para sinalizar uma falha ou exceção. Exemplo:

  • Partial para comunicar um resultado parcialmente bem-sucedido (por exemplo, algumas ordens foram bem-sucedidas). Exemplo:

  • Information para alertas gerais, atualizações ou feedback. Exemplo:

Dica

Use notificações pop-up para acompanhar a atividade de negociação, depurar fluxos lógicos, alertar os utilizadores sobre eventos de mercado ou erros de dados e fornecer feedback dinâmico da interface do utilizador durante operações de estratégia ao vivo ou manual.

Os objetos da API de Notificações podem ser usados para fazer o seguinte:

Funcionalidade ou operação Exemplos
Acompanhamento e feedback de ordens Exibir feedback de execução de ordens
Confirmar saídas de TP/SL
Acompanhar modificações de stop trailing
Alertas baseados em risco e regras Avisar sobre níveis baixos de margem
Mostrar alertas para negociações bloqueadas
Progresso e diagnóstico Mostrar progresso de análise com pop-ups
Interações de negociação manual Fornecer feedback para ações de negociação
Avisar sobre substituições ou intervenções manuais
Eventos de mercado e alertas de sinal Sinalizar cruzamentos de indicadores
Anunciar aberturas de sessão ou picos de preço
Depuração e transparência de estratégia Traçar visualmente os passos da estratégia/lógica
Reportar falhas de lógica

Exemplo básico

Quando uma instância deste cBot é adicionada a um gráfico, fornece cinco botões, um por estado de notificação. Clicar num botão aciona uma notificação pop-up.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
using System;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Internals;

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None, AddIndicators = true)]
    public class PopupNotificationStatesDemo : Robot
    {
        protected override void OnStart()
        {
            var panel = new StackPanel
            {
                Orientation = Orientation.Vertical,
                HorizontalAlignment = HorizontalAlignment.Center,
                VerticalAlignment = VerticalAlignment.Center
            };

            // InProgress
            var inProgressBtn = new Button { Text = "Show: InProgress", Margin = 5 };
            inProgressBtn.Click += _ =>
            {
                Notifications.ShowPopup(
                    "In progress",
                    "Starting a long-running task…",
                    PopupNotificationState.InProgress
                );
            };
            panel.AddChild(inProgressBtn);

            // Success
            var successBtn = new Button { Text = "Show: Success", Margin = 5 };
            successBtn.Click += _ =>
            {
                Notifications.ShowPopup(
                    "Success",
                    "The operation completed successfully.",
                    PopupNotificationState.Success
                );
            };
            panel.AddChild(successBtn);

            // Error
            var errorBtn = new Button { Text = "Show: Error", Margin = 5 };
            errorBtn.Click += _ =>
            {
                Notifications.ShowPopup(
                    "Error",
                    "Something went wrong. Please check the logs or try again.",
                    PopupNotificationState.Error
                );
            };
            panel.AddChild(errorBtn);

            // Partial
            var partialBtn = new Button { Text = "Show: Partial", Margin = 5 };
            partialBtn.Click += _ =>
            {
                Notifications.ShowPopup(
                    "Partial result",
                    "Completed with partial success (e.g. some orders filled).",
                    PopupNotificationState.Partial
                );
            };
            panel.AddChild(partialBtn);

            // Information
            var infoBtn = new Button { Text = "Show: Information", Margin = 5 };
            infoBtn.Click += _ =>
            {
                Notifications.ShowPopup(
                    "Information",
                    "General update: your settings were saved.",
                    PopupNotificationState.Information
                );
            };
            panel.AddChild(infoBtn);

            Chart.AddControl(panel);
        }

        protected override void OnTick()
        {
            // Handle price updates here if needed
        }

        protected override void OnStop()
        {
            // Cleanup if needed
        }
    }
}

Acompanhamento e feedback de ordens

Exibir feedback de execução de ordens

Use notificações pop-up para ver instantaneamente se a sua ordem de mercado foi bem-sucedida ou não. Por exemplo, depois de o seu cBot colocar uma ordem de compra, ele mostra um pop-up de sucesso se a sua negociação foi preenchida ou um pop-up de erro se o seu corretor a rejeitou.

1
2
3
var result = ExecuteMarketOrder(TradeType.Buy, SymbolName, 1000);
var state = result.IsSuccessful ? PopupNotificationState.Success : PopupNotificationState.Error;
Notifications.ShowPopup("Order Execution", $"Order result: {result.Error}", state);

Confirmar saídas de TP ou SL

Receba notificações quando a sua negociação cBot sair devido a take-profit ou stop-loss. Um pop-up mostra o motivo da saída juntamente com o lucro ou perda da posição fechada. Este feedback em tempo real no momento da saída ajuda-o a acompanhar as negociações e a manter-se atualizado com os resultados das suas posições ativas.

1
2
3
4
5
6
protected override void OnPositionClosed(PositionClosedEventArgs args)
{
    var pos = args.Position;
    var reason = pos.ClosingReason.ToString();
    Notifications.ShowPopup("Position Closed", $"Closed due to {reason}. PnL: {pos.GrossProfit}", PopupNotificationState.Information);
}

Acompanhar modificações de stop móvel

Veja um pop-up cada vez que um stop móvel atualiza o stop loss para a sua posição. A notificação inclui o novo valor de stop loss e mostra como o stop móvel está a acompanhar a ação do preço. Estes alertas permitem-lhe monitorizar como a proteção da sua negociação se ajusta sem abrir qualquer painel.

1
2
3
4
5
6
7
protected override void OnPositionModified(PositionModifiedEventArgs args)
{
    if (args.Reason == PositionModificationReason.TrailingStop)
    {
        Notifications.ShowPopup("Trailing Stop Moved", $"New SL: {args.Position.StopLoss}", PopupNotificationState.Information);
    }
}

Alertas baseados em risco e regras

Avisar sobre níveis de margem baixos

Receba um alerta pop-up quando o nível de margem da sua conta cair abaixo de um limite crítico (por exemplo, 80%). O aviso ajuda-o a tomar medidas oportunas, como fechar posições ou adicionar fundos, para evitar a liquidação forçada ou um pedido de cobertura. O pop-up atua como uma salvaguarda automatizada baseada em dados de risco em tempo real.

1
2
3
4
5
6
7
protected override void OnTick()
{
    if (Account.MarginLevel < 80)
    {
        Notifications.ShowPopup("Low Margin Warning", $"Current margin level: {Account.MarginLevel:0.00}%", PopupNotificationState.Error);
    }
}

Mostrar alertas para negociações bloqueadas

Alguns cBots são programados para parar de colocar negociações quando regras de segurança internas, como capital baixo ou drawdown excessivo, são acionadas. Um pop-up pode explicar o bloqueio e mostrar-lhe qual condição foi violada. Esta notificação garante que compreende por que um sinal foi ignorado e reforça o comportamento disciplinado da estratégia.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
protected override void OnBar()
{
    if (Account.Equity < 100)
    {
        Notifications.ShowPopup("Trade Blocked", "Equity too low to place trade", PopupNotificationState.Error);
        return;
    }

    ExecuteMarketOrder(TradeType.Sell, SymbolName, 1000);
}

Progresso e diagnósticos

Mostrar progresso da análise com pop-ups

Use um pop-up InProgress para indicar o início de um processo de longa duração, como validação de dados ou preparação para testes de verificação. Uma vez concluída a operação, atualize o pop-up para um estado de Success ou Error. O relatório de progresso exibido mantém-no informado sem necessidade de verificar registos ou mensagens de depuração.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
private PopupNotification _progressPopup;

protected override void OnStart()
{
    _progressPopup = Notifications.ShowPopup("Analysis Started", "Running analysis...", PopupNotificationState.InProgress);
    Timer.Start(4); // Simulate 4-second task
}

protected override void OnTimer()
{
    _progressPopup.Complete(PopupNotificationState.Success);
    Timer.Stop();
}

Interações de negociação manual

Notificar utilizadores após negociações acionadas por botões

Depois de clicar num controlo ou botão personalizado, o seu cBot pode colocar uma ordem e mostrar imediatamente um pop-up com o resultado. A notificação confirma se a sua ação manual foi bem-sucedida ou falhou e exibe qualquer erro devolvido pelo corretor. Este feedback visual reduz as conjeturas e melhora a sua confiança nas intervenções manuais.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
protected override void OnStart()
{
    var panel = new StackPanel();
    var button = new Button { Text = "Manual Buy" };

    button.Click += args =>
    {
        var result = ExecuteMarketOrder(TradeType.Buy, SymbolName, 1000);
        var status = result.IsSuccessful ? PopupNotificationState.Success : PopupNotificationState.Error;
        Notifications.ShowPopup("Manual Trade", $"Buy order result: {result.Error}", status);
    };

    panel.AddChild(button);
    Chart.AddControl(panel);
}

Avisar sobre substituições ou intervenções manuais

Quando substituir a lógica automatizada ou realizar uma substituição manual (por exemplo, forçar uma negociação durante um estado bloqueado), um pop-up pode reconhecer a ação.

1
2
3
4
5
button.Click += args =>
{
    Notifications.ShowPopup("Manual Override", "User manually triggered a trade", PopupNotificationState.Information);
    ExecuteMarketOrder(TradeType.Sell, SymbolName, 1000);
};

Eventos de mercado e alertas de sinal

Sinalizar cruzamentos de indicadores

Monitorize eventos técnicos importantes, como cruzamentos de médias móveis ou limites de RSI, e mostre um alerta pop-up quando ocorrerem. A notificação destaca o indicador e a condição cumprida, como um cruzamento de alta. Isto mantém-no informado sobre sinais técnicos e torna a sua estratégia mais transparente e rastreável.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
private MovingAverage _fast, _slow;

protected override void OnStart()
{
    _fast = Indicators.MovingAverage(MarketSeries.Close, 5, MovingAverageType.Exponential);
    _slow = Indicators.MovingAverage(MarketSeries.Close, 20, MovingAverageType.Exponential);
}

protected override void OnBar()
{
    int i = MarketSeries.Close.Count - 1;
    if (_fast.Result[i] > _slow.Result[i] && _fast.Result[i - 1] <= _slow.Result[i - 1])
    {
        Notifications.ShowPopup("MA Crossover", "Fast MA crossed above Slow MA", PopupNotificationState.Information);
    }
}

Alertar aberturas de sessão ou picos de preço

Crie pop-ups que são acionados quando ocorrem eventos importantes de mercado, como a abertura da sessão de Londres ou um movimento rápido de preço num curto período. Estas notificações atuam como ferramentas de consciência situacional e ajudam-no a reagir a potencial volatilidade ou a preparar-se para a atividade do mercado.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
protected override void OnBar()
{
    var time = Server.Time;
    if (time.TimeOfDay.Hours == 8 && time.TimeOfDay.Minutes == 0)
    {
        Notifications.ShowPopup("London Session Open", "London market has opened", PopupNotificationState.Information);
    }

    if (Math.Abs(Symbol.Bid - Symbol.Ask) / Symbol.PipSize > 15)
    {
        Notifications.ShowPopup("Spread Spike", "Spread exceeded 15 pips!", PopupNotificationState.Warning);
    }
}

Depuração e transparência da estratégia

Traçar visualmente os passos da estratégia

Use uma sequência de pop-ups para mostrar o fluxo lógico da sua estratégia. Por exemplo, exiba uma mensagem ao verificar a tendência, confirmar um sinal ou validar o risco. Cada pop-up representa um ponto de verificação específico, o que lhe permite seguir como a estratégia toma decisões em tempo real.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
protected override void OnBar()
{
    Notifications.ShowPopup("Step 1", "Checking market condition", PopupNotificationState.Information);

    if (MarketSeries.Close.Last(1) > MarketSeries.Open.Last(1))
    {
        Notifications.ShowPopup("Step 2", "Bullish candle detected", PopupNotificationState.Information);
    }

    Notifications.ShowPopup("Step 3", "Trade logic complete", PopupNotificationState.Success);
}

Reportar falhas lógicas ou dados inesperados

Quando a sua estratégia encontra um erro ou dados inválidos, como uma incompatibilidade de preços ou um indicador indisponível, use um pop-up para mostrar o problema exato. Esta configuração ajuda-o a identificar bugs ou lacunas de dados durante o desenvolvimento e negociação em demo/ao vivo, resultando numa depuração mais rápida e numa lógica mais resiliente.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
protected override void OnBar()
{
    try
    {
        // Assume some strategy logic
        if (Symbol.Bid < 0) throw new Exception("Invalid price feed");

        Notifications.ShowPopup("Logic OK", "Price validation passed", PopupNotificationState.Success);
    }
    catch (Exception ex)
    {
        Notifications.ShowPopup("Logic error", ex.Message, PopupNotificationState.Error);
    }
}