Notifications personnalisées

L'API de notification personnalisée inclut des types qui permettent aux algorithmes de trading de fournir des alertes contextuelles en temps réel directement dans cTrader. Ces fenêtres contextuelles permettent aux cBots, indicateurs et plug-ins de communiquer la progression, le succès, les erreurs ou des informations générales aux utilisateurs de manière visuelle et contextuelle.

Avec la prise en charge de l'API de notifications personnalisées, les cBots n'ont plus besoin de s'appuyer sur l'onglet Journal, les objets graphiques ou les ponts Telegram externes pour la communication. Les algorithmes indiquent simplement aux traders ce qui se passe directement via le système de notification standard dans cTrader. Les développeurs d'algorithmes et les utilisateurs bénéficient de rapidité, de fiabilité et de clarté sans aucune configuration complexe.

Les interfaces API pertinentes incluent :

• INotifications.ShowPopup(caption, message, state) pour afficher une notification contextuelle avec un titre, un message et un état donnés (PopupNotificationState).
• Interface PopupNotification pour le contrôle programmatique des notifications de longue durée ou progressives en appelant .Complete() pour mettre à jour leur état final.

Les messages fournis par l'API de notifications personnalisées apparaissent instantanément, sont codés par couleur selon l'état et peuvent être complétés ultérieurement. Les états de notification sont définis à l'aide de l'énumération PopupNotificationState :

• InProgress pour représenter les processus de longue durée ou les états en attente. Example :

  

• Success pour indiquer qu'une opération s'est terminée avec succès. Example :

  

• Error pour signaler un échec ou une exception. Example :

  

• Partial pour communiquer un résultat partiellement réussi (par exemple, certains ordres ont réussi). Example :

  

• Information pour les alertes générales, les mises à jour ou les commentaires. Example :

  

Les objets de l'API Notifications peuvent être utilisés pour effectuer les opérations suivantes :

Exemple de base

Lorsqu'une instance de ce cBot est ajoutée à un graphique, elle fournit cinq boutons, un par état de notification. Cliquer sur un bouton déclenche une notification contextuelle.

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

Suivi et retour d'information sur les ordres

Afficher les commentaires sur l'exécution des ordres

Utilisez les notifications contextuelles pour voir instantanément si votre ordre au marché a réussi ou non. Par exemple, après que votre cBot a passé un ordre d'achat, il affiche une fenêtre contextuelle de succès si votre trade a été exécuté ou une fenêtre contextuelle d'erreur si votre courtier l'a rejeté.

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

Confirmer les sorties TP ou SL

Recevez une notification lorsque votre trade cBot se ferme en raison d'un take-profit ou d'un stop-loss. Une fenêtre contextuelle affiche la raison de la sortie ainsi que le profit ou la perte de la position fermée. Ce retour d'information en temps réel au moment de la sortie vous aide à suivre les trades et à rester informé des résultats de vos positions actives.

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

Suivre les modifications du stop suiveur

Consultez une fenêtre contextuelle chaque fois qu'un stop suiveur met à jour le stop loss de votre position. La notification inclut la nouvelle valeur du stop loss et montre comment le stop suiveur suit l'évolution des prix. Ces alertes vous permettent de surveiller l'ajustement de la protection de votre trade sans ouvrir de panneau.

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

Alertes basées sur le risque et les règles

Avertir des niveaux de marge faibles

Recevez une alerte contextuelle lorsque le niveau de marge de votre compte tombe en dessous d'un seuil critique (par exemple 80 %). L'avertissement vous aide à prendre des mesures en temps opportun, comme la clôture de positions ou l'ajout de fonds, afin d'éviter une liquidation forcée ou un appel de marge. La fenêtre contextuelle agit comme une protection automatisée basée sur des données de risque en temps réel.

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

Afficher les alertes pour les trades bloqués

Certains cBots sont programmés pour cesser de placer des trades lorsque des règles de sécurité internes, telles qu'un faible niveau de fonds propres ou un drawdown excessif, sont déclenchées. Une fenêtre contextuelle peut expliquer le blocage et vous montrer quelle condition a été violée. Cette notification vous permet de comprendre pourquoi un signal a été ignoré et renforce le comportement discipliné de la stratégie.

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

Progression et diagnostics

Afficher la progression de l'analyse avec des fenêtres contextuelles

Utilisez une fenêtre contextuelle InProgress pour indiquer le début d'un processus de longue durée, tel que la validation des données ou la préparation du backtesting. Une fois l'opération terminée, mettez à jour la fenêtre contextuelle à l'état Success ou Error. Le rapport de progression affiché vous tient informé sans avoir besoin de consulter les journaux ou les messages de débogage.

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

Interactions de trading manuel

Notifier les utilisateurs après les trades déclenchés par un bouton

Après avoir cliqué sur un contrôle ou un bouton personnalisé, votre cBot peut passer un ordre et afficher immédiatement une fenêtre contextuelle avec le résultat. La notification confirme si votre action manuelle a réussi ou échoué et affiche toute erreur renvoyée par le courtier. Ce retour visuel réduit les incertitudes et améliore votre confiance dans les interventions manuelles.

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

Avertir des remplacements ou interventions manuels

Lorsque vous remplacez la logique automatisée ou effectuez un remplacement manuel (par exemple, forcer un trade pendant un état bloqué), une fenêtre contextuelle peut accuser réception de l'action.

1
2
3
4
5

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

Événements de marché et alertes de signal

Signaler les croisements d'indicateurs

Surveillez les événements techniques clés tels que les croisements de moyennes mobiles ou les seuils RSI et affichez une alerte contextuelle lorsqu'ils se produisent. La notification met en évidence l'indicateur et la condition remplie, comme un croisement haussier. Cela vous tient informé des signaux techniques et rend votre stratégie plus transparente et traçable.

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

Alerter les ouvertures de session ou les pics de prix

Créez des fenêtres contextuelles qui se déclenchent lorsque des événements de marché importants se produisent, comme l'ouverture de la session de Londres ou un mouvement de prix rapide sur une courte période. Ces notifications agissent comme des outils de sensibilisation situationnelle et vous aident à réagir à une volatilité potentielle ou à vous préparer à l'activité du marché.

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

Débogage et transparence de la stratégie

Tracer visuellement les étapes de la stratégie

Utilisez une séquence de fenêtres contextuelles pour afficher le flux logique de votre stratégie. Par exemple, affichez un message lors de la vérification de la tendance, de la confirmation d'un signal ou de la validation du risque. Chaque fenêtre contextuelle représente un point de contrôle spécifique, ce qui vous permet de suivre comment la stratégie prend des décisions en temps réel.

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

Signaler les échecs de logique ou les données inattendues

Lorsque votre stratégie rencontre une erreur ou des données non valides, comme une incompatibilité de prix ou un indicateur indisponible, utilisez une fenêtre contextuelle pour afficher le problème exact. Cette configuration vous aide à identifier les bugs ou les lacunes de données pendant le développement et le trading démo/réel, ce qui permet un débogage plus rapide et une logique plus résiliente.

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