Przejdź do treści

Niestandardowe powiadomienia

API niestandardowych powiadomień obejmuje typy, które umożliwiają algorytmom handlowym dostarczanie alertów wyskakujących w czasie rzeczywistym bezpośrednio w cTrader. Te wyskakujące okienka pozwalają cBotom, wskaźnikom i wtyczkom komunikować postęp, sukces, błędy lub ogólne informacje użytkownikom w sposób wizualny i kontekstowy.

Dzięki obsłudze API niestandardowych powiadomień cBoty nie muszą już polegać na karcie Dziennik, obiektach wykresu ani zewnętrznych mostach Telegram w celu komunikacji. Algorytmy po prostu informują traderów o tym, co się dzieje, bezpośrednio za pośrednictwem standardowego systemu powiadomień w cTrader. Deweloperzy algorytmów i użytkownicy korzystają z szybkości, niezawodności i przejrzystości bez żadnych skomplikowanych konfiguracji.

Odpowiednie interfejsy API obejmują:

  • INotifications.ShowPopup(caption, message, state) do wyświetlania powiadomienia wyskakującego z podanym tytułem, wiadomością i stanem (PopupNotificationState).
  • Interfejs PopupNotification do programowego sterowania długotrwałymi lub progresywnymi powiadomieniami poprzez wywołanie .Complete() w celu zaktualizowania ich końcowego stanu.

Wiadomości dostarczane przez API niestandardowych powiadomień pojawiają się natychmiast, są oznaczone kolorami według stanu i mogą zostać ukończone później. Stany powiadomień są definiowane za pomocą wyliczenia PopupNotificationState:

  • InProgress do reprezentowania długotrwałych procesów lub stanów oczekujących. Przykład:

  • Success do wskazania, że operacja została zakończona pomyślnie. Przykład:

  • Error do sygnalizowania niepowodzenia lub wyjątku. Przykład:

  • Partial do komunikowania częściowo pomyślnego wyniku (np. niektóre zlecenia powiodły się). Przykład:

  • Information dla ogólnych alertów, aktualizacji lub informacji zwrotnych. Przykład:

Wskazówka

Używaj powiadomień wyskakujących do śledzenia aktywności handlowej, debugowania przepływów logiki, ostrzegania użytkowników o zdarzeniach rynkowych lub błędach danych oraz dostarczania dynamicznych informacji zwrotnych interfejsu użytkownika podczas operacji strategii na żywo lub manualnych.

Obiekty API powiadomień mogą być używane do następujących celów:

Funkcja lub operacja Przykłady
Śledzenie zleceń i informacje zwrotne Wyświetlanie informacji zwrotnych o realizacji zleceń
Potwierdzanie wyjść TP/SL
Śledzenie modyfikacji kroczącego stop loss
Alerty dotyczące ryzyka i reguł Ostrzeganie o niskich poziomach depozytu zabezpieczającego
Wyświetlanie alertów dla zablokowanych transakcji
Postęp i diagnostyka Wyświetlanie postępu analizy za pomocą wyskakujących okienek
Interakcje z handlem manualnym Dostarczanie informacji zwrotnych dla działań handlowych
Ostrzeganie o manualnych nadpisaniach lub interwencjach
Zdarzenia rynkowe i alerty sygnałowe Sygnalizowanie przecięć wskaźników
Ogłaszanie otwarć sesji lub skoków cenowych
Debugowanie strategii i przejrzystość Wizualne śledzenie kroków strategii/logiki
Raportowanie niepowodzeń logiki

Podstawowy przykład

Gdy instancja tego cBota zostanie dodana do wykresu, udostępnia pięć przycisków, po jednym dla każdego stanu powiadomienia. Kliknięcie przycisku wyzwala powiadomienie wyskakujące.

 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
        }
    }
}

Śledzenie zleceń i informacje zwrotne

Wyświetlanie informacji zwrotnych o realizacji zleceń

Używaj powiadomień wyskakujących, aby natychmiast zobaczyć, czy Twoje zlecenie rynkowe zakończyło się sukcesem, czy nie. Na przykład, po tym jak Twój cBot złoży zlecenie kupna, wyświetli powiadomienie o sukcesie, jeśli Twoja transakcja została zrealizowana, lub powiadomienie o błędzie, jeśli Twój broker ją odrzucił.

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);

Potwierdzanie wyjść TP lub SL

Otrzymuj powiadomienia, gdy Twoja transakcja cBota zostanie zamknięta z powodu take-profit lub stop-loss. Wyskakujące okienko pokazuje przyczynę wyjścia wraz z zyskiem lub stratą z zamkniętej pozycji. Ta informacja zwrotna w czasie rzeczywistym w momencie wyjścia pomaga śledzić transakcje i być na bieżąco z wynikami Twoich aktywnych pozycji.

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);
}

Śledzenie modyfikacji kroczącego stop loss

Zobacz wyskakujące okienko za każdym razem, gdy kroczący stop loss aktualizuje stop loss dla Twojej pozycji. Powiadomienie zawiera nową wartość stop-loss i pokazuje, jak kroczący stop loss śledzi akcję cenową. Te alerty pozwalają monitorować, jak dostosowuje się ochrona Twojej transakcji, bez otwierania żadnego panelu.

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);
    }
}

Alerty dotyczące ryzyka i reguł

Ostrzeganie o niskich poziomach depozytu zabezpieczającego

Otrzymuj alert wyskakujący, gdy poziom depozytu zabezpieczającego Twojego konta spadnie poniżej krytycznego progu (np. 80%). Ostrzeżenie pomaga podjąć terminowe działania, takie jak zamknięcie pozycji lub dodanie środków, aby uniknąć wymuszonej likwidacji lub margin call. Wyskakujące okienko działa jako automatyczne zabezpieczenie oparte na danych o ryzyku w czasie rzeczywistym.

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);
    }
}

Wyświetlanie alertów dla zablokowanych transakcji

Niektóre cBoty są zaprogramowane tak, aby przestać składać transakcje, gdy zostaną uruchomione wewnętrzne zasady bezpieczeństwa, takie jak niski kapitał lub nadmierne obniżenie wartości. Wyskakujące okienko może wyjaśnić blokadę i pokazać, który warunek został naruszony. To powiadomienie zapewnia, że rozumiesz, dlaczego sygnał został pominięty, i wzmacnia zdyscyplinowane zachowanie strategii.

 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);
}

Postęp i diagnostyka

Wyświetlanie postępu analizy za pomocą wyskakujących okienek

Użyj wyskakującego okienka InProgress, aby wskazać rozpoczęcie długotrwałego procesu, takiego jak walidacja danych lub przygotowanie do backtestingu. Po zakończeniu operacji zaktualizuj wyskakujące okienko do stanu Success lub Error. Wyświetlany raport postępu informuje Cię na bieżąco bez konieczności sprawdzania logów lub komunikatów debugowania.

 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();
}

Interakcje z handlem manualnym

Powiadamiaj użytkowników po transakcjach uruchamianych przyciskiem

Po kliknięciu niestandardowego elementu sterującego lub przycisku Twój cBot może złożyć zlecenie i natychmiast wyświetlić wyskakujące okienko z wynikiem. Powiadomienie potwierdza, czy Twoje działanie manualne zakończyło się sukcesem, czy niepowodzeniem, i wyświetla wszelkie błędy zwrócone przez brokera. Ta wizualna informacja zwrotna zmniejsza zgadywanie i zwiększa Twoje zaufanie do interwencji manualnych.

 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);
}

Ostrzegaj o manualnych nadpisaniach lub interwencjach

Gdy nadpisujesz zautomatyzowaną logikę lub wykonujesz manualne nadpisanie (np. wymuszasz transakcję w stanie zablokowanym), wyskakujące okienko może potwierdzić to działanie.

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

Zdarzenia rynkowe i alerty sygnałów

Przecięcia wskaźników sygnałowych

Monitoruj kluczowe zdarzenia techniczne, takie jak przecięcia średnich kroczących lub progi RSI, i wyświetlaj alert w wyskakującym okienku, gdy wystąpią. Powiadomienie podkreśla wskaźnik i spełniony warunek, taki jak zwyżkowe przecięcie. Dzięki temu jesteś informowany o sygnałach technicznych, a Twoja strategia staje się bardziej przejrzysta i możliwa do prześledzenia.

 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);
    }
}

Alerty otwarcia sesji lub skoków cenowych

Twórz wyskakujące okienka, które uruchamiają się, gdy wystąpią ważne zdarzenia rynkowe, takie jak otwarcie sesji londyńskiej lub gwałtowny ruch cenowy w krótkim okresie. Te powiadomienia działają jako narzędzia świadomości sytuacyjnej i pomagają reagować na potencjalną zmienność lub przygotować się do aktywności rynkowej.

 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);
    }
}

Debugowanie i przejrzystość strategii

Śledź kroki strategii wizualnie

Użyj sekwencji wyskakujących okienek, aby pokazać logiczny przebieg Twojej strategii. Na przykład wyświetl komunikat podczas sprawdzania trendu, potwierdzania sygnału lub walidacji ryzyka. Każde wyskakujące okienko reprezentuje konkretny punkt kontrolny, co pozwala śledzić, jak strategia podejmuje decyzje w czasie rzeczywistym.

 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);
}

Zgłaszaj błędy logiki lub nieoczekiwane dane

Gdy Twoja strategia napotka błąd lub nieprawidłowe dane, takie jak niezgodność cen lub niedostępny wskaźnik, użyj wyskakującego okienka, aby pokazać dokładny problem. Ta konfiguracja pomaga identyfikować błędy lub luki w danych podczas rozwoju i handlu demo/na żywo, co skutkuje szybszym debugowaniem i bardziej odporną logiką.

 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);
    }
}