Limit Order TP+SL+Cancel Pending ( Example )

using System;
using cAlgo.API;
using cAlgo.API.Internals;

namespace cAlgo
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class LimitOrderSimple : Robot
    {
        [Parameter("Initial Volume", DefaultValue = 1000)]
        public int InitialVolume { get; set; }

        [Parameter("Take Profit (pips)", DefaultValue = 100)]
        public int TakeProfit { get; set; }

        [Parameter("Stop Loss (pips)", DefaultValue = 100)]
        public int StopLoss { get; set; }

        [Parameter("Limit Offset Pips", DefaultValue = 10)]
        public int StopOffsetPips { get; set; }

        private int _currentVolume;
        private int _consecutiveLosses = 0;

        protected override void OnStart()
        {
            Print("OpenCloseMartingaleStrategy started.");
            _currentVolume = InitialVolume;
        }

        protected override void OnBar()
        {
            // Cancel all pending orders at the start of each bar
            foreach (var pendingOrder in PendingOrders)
            {
                var cancelResult = CancelPendingOrder(pendingOrder);
                if (!cancelResult.IsSuccessful)
                {
                    Print($"Error canceling pending order: {cancelResult.Error}");
                }
            }

            // Close all positions at the end of each bar
            foreach (var position in Positions)
            {
                Print($"Closing position: {position.TradeType} at {position.EntryPrice}");
                var closeResult = ClosePosition(position);
                if (!closeResult.IsSuccessful)
                {
                    Print($"Error closing position: {closeResult.Error}");
                }
            }

            // Get the current and previous bar data
            var currentBarIndex = MarketSeries.Close.Count - 2;
            var previousBarIndex = MarketSeries.Close.Count - 1;

            if (currentBarIndex < 1 || previousBarIndex < 0)
            {
                Print("Not enough bar data.");
                return;
            }

            double previousClosePrice = MarketSeries.Close[previousBarIndex];
            double currentClosePrice = MarketSeries.Close[currentBarIndex];

            Print($"Previous Close Price: {previousClosePrice}, Current Close Price: {currentClosePrice}");

            // Determine trade type based on price movement
            if (previousClosePrice > currentClosePrice)
            {
                OpenBuyPosition();
            }
            else if (previousClosePrice < currentClosePrice)
            {
                OpenSellPosition();
            }
        }

        private void OpenSellPosition()
        {
            Print("Opening Sell position.");
            double price = Symbol.Ask + StopOffsetPips * Symbol.PipSize; // Adjusted price
            var result = PlaceLimitOrder(TradeType.Sell, SymbolName, _currentVolume, price, "OpenCloseMartingaleStrategy", StopLoss, TakeProfit);
            if (!result.IsSuccessful)
            {
                Print($"Error placing Sell limit order: {result.Error}");
            }
        }

        private void OpenBuyPosition()
        {
            Print("Opening Buy position.");
            double price = Symbol.Bid - StopOffsetPips * Symbol.PipSize; // Adjusted price
            var result = PlaceLimitOrder(TradeType.Buy, SymbolName, _currentVolume, price, "OpenCloseMartingaleStrategy", StopLoss, TakeProfit);
            if (!result.IsSuccessful)
            {
                Print($"Error placing Buy limit order: {result.Error}");
            }
        }

        protected override void OnPositionClosed(Position position)
        {
          
           
            {
                _currentVolume = InitialVolume;
                _consecutiveLosses = 0;
            }
        }

        protected override void OnStop()
        {
            Print("OpenCloseMartingaleStrategy stopped.");
        }
    }
}