Estratégia do botão SpaceX Excluir StopLoss TakeProfit

Visão geral

Esta estratégia reproduz o botão "DELETE SL_TP" do painel MetaTrader original SpaceX_Delete_StopLoss_TakeProfit_button.mq5. Ele foi projetado como um utilitário auxiliar que verifica o portfólio atual e cancela todas as ordens protetoras ativas de stop-loss ou take-profit que pertencem a posições abertas. A conversão tem como alvo o StockSharp API de alto nível e fornece uma maneira conveniente de remover colchetes de proteção sem abrir manualmente cada ticket.

A estratégia não abre ou fecha posições por si só. Ele simplesmente inspeciona as negociações já abertas e remove suas ordens de proteção quando instruído a fazê-lo. Isto o torna adequado para traders que gerenciam posições manualmente ou por meio de outros sistemas automatizados, mas desejam um botão de pânico rápido que limpe todas as ordens de stop e take-profit.

Consultor Especialista Original

A versão MetaTrader desenha uma única janela de diálogo com um botão DELETE SL_TP. Sempre que o botão é pressionado, o especialista percorre todas as posições abertas e chama PositionModify com valores zero para stop-loss e take-profit. Como resultado, cada nível de proteção é destacado da posição enquanto o volume da posição permanece inalterado.

Principais comportamentos do código-fonte:

• Nenhuma entrada ou saída de mercado é criada.
• Todos os símbolos no terminal são processados sem filtragem.
• Apenas os valores de stop-loss e take-profit são removidos; os comentários do pedido e os números mágicos permanecem intactos.
• A ação é acionada exclusivamente pelo botão GUI.

StockSharp Implementação

A conversão StockSharp mantém o comportamento focado na remoção de ordens de proteção. Em vez de uma caixa de diálogo GUI, a ação é orientada por parâmetros de estratégia que podem ser alternados na interface do usuário StockSharp ou no código. A estratégia funciona com qualquer adaptador de corretora que exponha informações de stop de ordem ou de lucro.

Dois modos de execução são suportados:

1. Execução automática na inicialização – opcional. Quando ativada, a estratégia remove as ordens de proteção imediatamente após começar a ser executada.
2. Comando manual – um parâmetro booleano que imita o botão original. Definir o parâmetro como true agenda uma limpeza no próximo tique do temporizador, após o qual o sinalizador é redefinido para false.

A conversão cancela as ordens de proteção chamando CancelOrder em cada ordem ativa identificada como stop-loss, take-profit ou qualquer outra ordem de proteção condicional. Os volumes de posição nunca são tocados.

Parâmetros

Nome	Descrição	Padrão
Executar ao iniciar (ApplyOnStart)	Quando true a estratégia remove as ordens de proteção imediatamente após o início da estratégia.	true
Todos os títulos (AffectAllSecurities)	Processa todas as posições do portfólio. Quando false apenas a segurança da estratégia é considerada.	true
Solicitação de exclusão (DeleteRequest)	Gatilho manual que emula o botão MetaTrader. Mude para true para realizar uma remoção única; ele reinicia automaticamente.	false
Intervalo(s) de pesquisa (PollingIntervalSeconds)	Intervalo do temporizador em segundos usado para pesquisar o acionamento manual. O cronômetro também executa a solicitação de exclusão quando Run On Start está desabilitado.	1

Como funciona

1. No início, a estratégia valida o intervalo de pesquisa e inicia um cronômetro que é ativado a cada N segundos.
2. Se Run On Start estiver ativado, uma limpeza imediata será executada.
3. Cada tique do cronômetro verifica o sinalizador Delete Request. Quando a flag é true a estratégia coleta os títulos que possuem posições abertas dentro do escopo configurado e cancela todas as ordens de proteção desses instrumentos.
4. Após a execução, o sinalizador manual é redefinido para false, garantindo que a ação seja executada apenas uma vez por solicitação.

Identificando ordens de proteção

Uma ordem é tratada como protetora quando qualquer uma das seguintes condições for atendida:

• O tipo de pedido é Stop, TakeProfit ou Conditional.
• Um preço stop, preço take-profit ou condição de ordem não nula está presente.

Esta definição conservadora abrange os adaptadores mais comuns. Se um conector usar tipos de pedidos personalizados ou condições para gerenciamento de parada, estenda a lógica de detecção adequadamente.

Dicas de uso

• Anexe a estratégia ao conector que gerencia suas negociações abertas. Certifique-se de que todas as posições que você deseja gerenciar estejam visíveis no portfólio configurado.
• Acione a solicitação de exclusão da grade de parâmetros no Hydra ou Terminal alternando a caixa de seleção Delete Request.
• Combine o utilitário com outras estratégias para remover temporariamente os bráquetes de proteção antes de aplicar novos.
• Mantenha o intervalo de pesquisa pequeno (1 segundo por padrão) para uma experiência de botão responsiva. Aumente-o se quiser reduzir a atividade do temporizador.

Diferenças em comparação com o original EA

• O botão MetaTrader atua instantaneamente por meio de uma caixa de diálogo de gráfico. Em StockSharp a ação é exposta como um parâmetro monitorado por um temporizador.
• As ordens de proteção são canceladas em vez de modificar os objetos de posição. Esta é a abordagem natural em StockSharp porque os níveis de stop-loss e take-profit são representados como ordens separadas em vez de propriedades de posição inline.
• O controle opcional do osciloscópio permite limitar a operação à segurança anexada, o que é uma conveniência extra em comparação com o especialista original.

Limitações

• A estratégia exige que o adaptador exponha ordens de stop-loss e take-profit como ordens ativas. Se o corretor usar níveis de proteção do lado do servidor que não sejam representados como pedidos, talvez não seja possível cancelá-los.
• Nenhuma caixa de diálogo GUI é criada. O controle é realizado inteiramente através de parâmetros estratégicos ou acesso programático.
• O utilitário não recria níveis de proteção; apenas os remove.

Teste

A estratégia não inclui testes automatizados dedicados porque executa funções utilitárias sem cálculos complexos. O teste manual pode ser realizado abrindo posições de amostra, anexando a estratégia e verificando se todas as ordens de proteção são canceladas após cada acionamento.

namespace StockSharp.Samples.Strategies;

using System;
using Ecng.Common;
using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.Messages;

/// <summary>
/// SpaceX Delete SL/TP strategy: Standard Deviation breakout.
/// Buys when price breaks above upper StdDev band, sells on break below lower.
/// </summary>
public class SpaceXDeleteStopLossTakeProfitButtonStrategy : Strategy
{
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<int> _smaPeriod;
	private readonly StrategyParam<int> _stdDevPeriod;

	public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }
	public int SmaPeriod { get => _smaPeriod.Value; set => _smaPeriod.Value = value; }
	public int StdDevPeriod { get => _stdDevPeriod.Value; set => _stdDevPeriod.Value = value; }

	public SpaceXDeleteStopLossTakeProfitButtonStrategy()
	{
		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(5).TimeFrame())
			.SetDisplay("Candle Type", "Candle timeframe", "General");
		_smaPeriod = Param(nameof(SmaPeriod), 20)
			.SetGreaterThanZero()
			.SetDisplay("SMA Period", "SMA period for baseline", "Indicators");
		_stdDevPeriod = Param(nameof(StdDevPeriod), 20)
			.SetGreaterThanZero()
			.SetDisplay("StdDev Period", "Standard Deviation period", "Indicators");
	}

	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);
		var sma = new SimpleMovingAverage { Length = SmaPeriod };
		var stdDev = new StandardDeviation { Length = StdDevPeriod };
		var subscription = SubscribeCandles(CandleType);
		subscription.Bind(sma, stdDev, ProcessCandle).Start();
	}

	private void ProcessCandle(ICandleMessage candle, decimal smaValue, decimal stdDevValue)
	{
		if (candle.State != CandleStates.Finished) return;

		var upper = smaValue + 2 * stdDevValue;
		var lower = smaValue - 2 * stdDevValue;

		if (candle.ClosePrice > upper && Position <= 0)
			BuyMarket();
		else if (candle.ClosePrice < lower && Position >= 0)
			SellMarket();
	}
}

import clr

clr.AddReference("StockSharp.Messages")
clr.AddReference("StockSharp.Algo")
clr.AddReference("StockSharp.Algo.Indicators")
clr.AddReference("StockSharp.Algo.Strategies")

from System import TimeSpan
from StockSharp.Messages import DataType, CandleStates
from StockSharp.Algo.Indicators import SimpleMovingAverage, StandardDeviation
from StockSharp.Algo.Strategies import Strategy
from datatype_extensions import *
from indicator_extensions import *

class space_x_delete_stop_loss_take_profit_button_strategy(Strategy):
    def __init__(self):
        super(space_x_delete_stop_loss_take_profit_button_strategy, self).__init__()
        self._sma_period = self.Param("SmaPeriod", 20).SetGreaterThanZero().SetDisplay("SMA Period", "SMA period for baseline", "Indicators")
        self._std_period = self.Param("StdDevPeriod", 20).SetGreaterThanZero().SetDisplay("StdDev Period", "Standard Deviation period", "Indicators")
        self._candle_type = self.Param("CandleType", DataType.TimeFrame(TimeSpan.FromMinutes(5))).SetDisplay("Candle Type", "Candle timeframe", "General")

    @property
    def CandleType(self): return self._candle_type.Value
    @CandleType.setter
    def CandleType(self, value): self._candle_type.Value = value

    def OnStarted2(self, time):
        super(space_x_delete_stop_loss_take_profit_button_strategy, self).OnStarted2(time)

        sma = SimpleMovingAverage()
        sma.Length = self._sma_period.Value
        std = StandardDeviation()
        std.Length = self._std_period.Value

        sub = self.SubscribeCandles(self.CandleType)
        sub.Bind(sma, std, self.OnProcess).Start()

    def OnProcess(self, candle, sma_val, std_val):
        if candle.State != CandleStates.Finished:
            return

        upper = sma_val + 2 * std_val
        lower = sma_val - 2 * std_val
        close = float(candle.ClosePrice)

        if close > upper and self.Position <= 0:
            self.BuyMarket()
        elif close < lower and self.Position >= 0:
            self.SellMarket()

    def CreateClone(self):
        return space_x_delete_stop_loss_take_profit_button_strategy()