Saltar a contenido

Notificaciones personalizadas

La API de notificaciones personalizadas incluye tipos que permiten a los algoritmos de operaciones enviar alertas emergentes en tiempo real directamente en cTrader. Estas ventanas emergentes permiten a los cBots, indicadores y plugins comunicar el progreso, el éxito, los errores o la información general a los usuarios de forma visual y contextual.

Con el soporte de la API de notificaciones personalizadas, los cBots ya no tienen que depender de la pestaña Registro, los objetos del gráfico o los puentes externos de Telegram para la comunicación. Los algoritmos simplemente informan a los operadores de lo que está sucediendo directamente a través del sistema de notificaciones estándar en cTrader. Los desarrolladores y usuarios de algoritmos se benefician de la velocidad, la fiabilidad y la claridad sin necesidad de configuraciones complejas.

Las interfaces de API relevantes incluyen:

  • INotifications.ShowPopup(caption, message, state) para mostrar una notificación emergente con un título, mensaje y estado dados (PopupNotificationState).
  • La interfaz PopupNotification para el control programático de notificaciones de larga duración o progresivas llamando a .Complete() para actualizar su estado final.

Los mensajes enviados por la API de notificaciones personalizadas aparecen al instante, están codificados por colores según el estado y pueden completarse más tarde. Los estados de notificación se definen utilizando la enumeración PopupNotificationState:

  • InProgress para representar procesos de larga duración o estados pendientes. Ejemplo:

  • Success para indicar que una operación se completó con éxito. Ejemplo:

  • Error para señalar un fallo o excepción. Ejemplo:

  • Partial para comunicar un resultado parcialmente exitoso (por ejemplo, algunas órdenes tuvieron éxito). Ejemplo:

  • Information para alertas generales, actualizaciones o comentarios. Ejemplo:

Consejo

Utilice notificaciones emergentes para realizar un seguimiento de la actividad de operaciones, depurar flujos lógicos, alertar a los usuarios sobre eventos del mercado o errores de datos y proporcionar comentarios dinámicos de la interfaz de usuario durante operaciones de estrategia en vivo o manuales.

Los objetos de la API de notificaciones se pueden utilizar para hacer lo siguiente:

Característica u operación Ejemplos
Seguimiento y comentarios de órdenes Mostrar comentarios sobre la ejecución de órdenes
Confirmar salidas de TP/SL
Seguir modificaciones de stop loss dinámico
Alertas basadas en riesgo y reglas Advertir sobre niveles de margen bajos
Mostrar alertas de operaciones bloqueadas
Progreso y diagnóstico Mostrar el progreso del análisis con ventanas emergentes
Interacciones de operación manual Proporcionar comentarios sobre acciones de operación
Advertir sobre anulaciones o intervenciones manuales
Eventos de mercado y alertas de señales Señalar cruces de indicadores
Anunciar aperturas de sesión o picos de precios
Depuración y transparencia de estrategias Trazar visualmente los pasos de la estrategia/lógica
Informar sobre fallos lógicos

Ejemplo básico

Cuando se añade una instancia de este cBot a un gráfico, proporciona cinco botones, uno por cada estado de notificación. Al hacer clic en un botón se activa una notificación emergente.

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

Seguimiento y comentarios de órdenes

Mostrar comentarios sobre la ejecución de órdenes

Utilice notificaciones emergentes para ver al instante si su orden de mercado se ha ejecutado correctamente o no. Por ejemplo, después de que su cBot coloque una orden de compra, muestra una ventana emergente de éxito si su operación se ha completado o una ventana emergente de error si su bróker la ha rechazado.

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 salidas de TP o SL

Reciba una notificación cuando su operación de cBot salga debido a take profit o stop loss. Una ventana emergente muestra el motivo de la salida junto con el beneficio o la pérdida de la posición cerrada. Esta retroalimentación en tiempo real en el momento de la salida le ayuda a hacer un seguimiento de las operaciones y a mantenerse al día de los resultados de sus posiciones activas.

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

Seguir modificaciones de stop loss dinámico

Vea una ventana emergente cada vez que un stop loss dinámico actualice el stop loss de su posición. La notificación incluye el nuevo valor de stop loss y muestra cómo el stop loss dinámico sigue la acción del precio. Estas alertas le permiten controlar cómo se ajusta la protección de su operación sin abrir ningún panel.

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 basadas en riesgo y reglas

Advertir sobre niveles de margen bajos

Reciba una alerta emergente cuando el nivel de margen de su cuenta caiga por debajo de un umbral crítico (por ejemplo, 80%). La advertencia le ayuda a tomar medidas oportunas, como cerrar posiciones o añadir fondos, para evitar la liquidación forzosa o una llamada de margen. La ventana emergente actúa como una salvaguarda automatizada basada en datos de riesgo en tiempo 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 de operaciones bloqueadas

Algunos cBots están programados para dejar de realizar operaciones cuando se activan reglas de seguridad internas, como capital bajo o drawdown excesivo. Una ventana emergente puede explicar el bloqueo y mostrarle qué condición se ha violado. Esta notificación garantiza que usted entienda por qué se ha omitido una señal y refuerza el comportamiento disciplinado de la estrategia.

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

Progreso y diagnóstico

Mostrar el progreso del análisis con ventanas emergentes

Utilice una ventana emergente InProgress para indicar el inicio de un proceso de larga duración, como la validación de datos o la preparación para el backtesting. Una vez completada la operación, actualice la ventana emergente a un estado de Success o Error. El informe de progreso mostrado le mantiene informado sin necesidad de consultar registros o mensajes de depuración.

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

Interacciones de operación manual

Notificar a los usuarios después de operaciones activadas por botones

Después de hacer clic en un control o botón personalizado, su cBot puede colocar una orden y mostrar inmediatamente una ventana emergente con el resultado. La notificación confirma si su acción manual ha tenido éxito o ha fallado y muestra cualquier error devuelto por el bróker. Esta retroalimentación visual reduce las conjeturas y mejora su confianza en las intervenciones manuales.

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

Advertir sobre anulaciones o intervenciones manuales

Cuando anule la lógica automatizada o realice una anulación manual (por ejemplo, forzar una operación durante un estado bloqueado), una ventana emergente puede reconocer la acción.

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 y alertas de señales

Señalar cruces de indicadores

Supervise eventos técnicos clave como cruces de medias móviles o umbrales de RSI y muestre una alerta emergente cuando se produzcan. La notificación destaca el indicador y la condición cumplida, como un cruce alcista. Esto le mantiene informado de las señales técnicas y hace que su estrategia sea más transparente y rastreable.

 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 sobre aperturas de sesión o picos de precios

Cree ventanas emergentes que se activen cuando se produzcan eventos importantes del mercado, como la apertura de la sesión de Londres o un movimiento rápido de precios en un corto período de tiempo. Estas notificaciones actúan como herramientas de conciencia situacional y le ayudan a reaccionar ante la volatilidad potencial o a prepararse para la actividad del 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);
    }
}

Depuración y transparencia de estrategias

Trazar visualmente los pasos de la estrategia

Utilice una secuencia de ventanas emergentes para mostrar el flujo lógico de su estrategia. Por ejemplo, muestre un mensaje al comprobar la tendencia, confirmar una señal o validar el riesgo. Cada ventana emergente representa un punto de control específico, lo que le permite seguir cómo la estrategia toma decisiones en tiempo 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);
}

Informar sobre fallos lógicos o datos inesperados

Cuando su estrategia encuentre un error o datos no válidos, como un desajuste de precios o un indicador no disponible, utilice una ventana emergente para mostrar el problema exacto. Esta configuración le ayuda a identificar errores o lagunas de datos durante el desarrollo y las operaciones de demostración/en vivo, lo que da como resultado una depuración más rápida y una lógica más resistente.

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