TradeManagerV03

using System;
using System.Linq;
using cAlgo.API;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;
using cAlgo.Indicators;

namespace cAlgo
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None)]
    public class TradeManagerV03 : Robot
    {
        [Parameter("Maximum DrawDown % :", DefaultValue = 5.0, MinValue = 1.0, MaxValue = 50.0)]
        public double maxDrawDown { get; set; }

        [Parameter("Modify Long Orders TP :", DefaultValue = false)]
        public bool modifyLongTakeProfit { get; set; }

        [Parameter("Modify Long Orders SL :", DefaultValue = false)]
        public bool modifyLongStopLoss { get; set; }

        [Parameter("Long Orders TP :", DefaultValue = 0.0, MinValue = 0.0)]
        public double longTakeProfit { get; set; }

        [Parameter("Long Orders SL :", DefaultValue = 0.0, MinValue = 0.0)]
        public double longStopLoss { get; set; }

        [Parameter("Modify Short Orders TP :", DefaultValue = false)]
        public bool modifyShortTakeProfit { get; set; }

        [Parameter("Modify Short Orders SL :", DefaultValue = false)]
        public bool modifyShortStopLoss { get; set; }

        [Parameter("Short Orders TP :", DefaultValue = 0.0, MinValue = 0.0)]
        public double shortTakeProfit { get; set; }

        [Parameter("Short Orders SL :", DefaultValue = 0.0, MinValue = 0.0)]
        public double shortStopLoss { get; set; }



        protected override void OnStart()
        {
            // Put your initialization logic here
            longTakeProfit = Math.Round(longTakeProfit, Symbol.Digits);
            shortTakeProfit = Math.Round(shortTakeProfit, Symbol.Digits);
            longStopLoss = Math.Round(longStopLoss, Symbol.Digits);
            shortStopLoss = Math.Round(shortStopLoss, Symbol.Digits);


        }

        protected override void OnTick()
        {
            // Put your core logic here
            if (Account.Equity < Account.Balance * ((100 - maxDrawDown) / 100))
            {
                foreach (var position in Positions)
                    ClosePositionAsync(position);
            }



            if (modifyLongTakeProfit == true || modifyLongStopLoss == true || modifyShortTakeProfit == true || modifyShortStopLoss == true)
            {
                foreach (var position in Positions)
                {
                    double? stopLoss = position.StopLoss;
                    double? takeProfit = position.TakeProfit;

                    RefreshData();

                    if (position.SymbolCode != Symbol.Code)
                        continue;

                    else if (position.TradeType == TradeType.Buy)
                    {
                        if (modifyLongTakeProfit == true && longTakeProfit == 0)
                            takeProfit = null;
                        else if (modifyLongTakeProfit == true && longTakeProfit > 0 && longTakeProfit > Symbol.Bid)
                            takeProfit = longTakeProfit;

                        if (modifyLongStopLoss == true && longStopLoss == 0)
                            stopLoss = null;
                        else if (modifyLongStopLoss == true && longStopLoss > 0 && longStopLoss < Symbol.Bid)
                            stopLoss = longStopLoss;
                    }


                    else if (position.TradeType == TradeType.Sell)
                    {
                        if (modifyShortTakeProfit == true && shortTakeProfit == 0)
                            takeProfit = null;
                        else if (modifyShortTakeProfit == true && shortTakeProfit > 0 && shortTakeProfit < Symbol.Ask)
                            takeProfit = shortTakeProfit;


                        if (modifyShortStopLoss == true && shortStopLoss == 0)
                            stopLoss = null;
                        else if (modifyShortStopLoss == true && shortStopLoss > 0 && shortStopLoss > Symbol.Ask)
                            stopLoss = shortStopLoss;
                    }


                    if (stopLoss != position.StopLoss || takeProfit != position.TakeProfit)
                        ModifyPositionAsync(position, stopLoss, takeProfit);

                }

            }

        }


        protected override void OnStop()
        {
            // Put your deinitialization logic here            
        }
    }
}