cTrader RSI & MACD Trading cBot

using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml.Linq;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;

/*
   This code was created using the Algo Strategy Building Tool by ClickAlgo Limited
   https://clickalgo.com/strategy-builder
 
   This cBot does not guarantee any particular outcome or
   profit of any kind. Use it at your own risk.

   Created: 05/07/2024
   Name: MACD & RSI Strategy

   The MACD and RSI strategy refers to a trading method that makes use of both indicators in analyzing and trading the markets. The combination of both momentum indicators may give more insight into what the market may do next and how it could move in the future. 
*/

namespace cAlgo.Robots
{
    [Robot(AccessRights = AccessRights.None)]
    public class AlgoBuilderBot : Robot
    {
        // user parameter settings

        [Parameter("Risk % Balance", Group = "Protection", DefaultValue = 1, MinValue = 0.01, Step = 1)]
        public double RiskPerTrade  { get; set; }

        [Parameter("Stop loss", Group = "Protection", DefaultValue = 3)]
        public int StopLoss { get; set; }

        [Parameter("Take profit", Group = "Protection", DefaultValue = 3)]
        public int TakeProfit { get; set; }

        [Parameter("Bot Token", Group = "Telegram Alert", DefaultValue = "aa123")]
        public string BotToken { get; set; }

        [Parameter("Chat ID", Group = "Telegram Alert", DefaultValue = "12345")]
        public string ChatID { get; set; }

        // Indicator settings for bullish signals

        [Parameter("Timeframe", DefaultValue = "h1", Group = "RSI Buy #1")]
        public TimeFrame RsiTimeFrameBuy1 { get; set; }
        
        [Parameter("RSI Periods", DefaultValue =  14, Group = "RSI Buy #1")]
        public int RsiPeriodsBuy1 { get; set; }
        
        [Parameter("RSI Lower", DefaultValue =  30, Group = "RSI Buy #1")]
        public int RsiLowerBuy1 { get; set; }

        [Parameter("Timeframe", DefaultValue = "h1", Group = "MACD Crossover Buy #2")]
        public TimeFrame MacdTimeFrameBuy2 { get; set; }
        
        [Parameter("Signal Periods", DefaultValue =  9, Group = "MACD Crossover Buy #2")]
        public int MacdPeriodsBuy2 { get; set; }
        
        [Parameter("MACD Lower", DefaultValue =  -0.001, Group = "MACD Crossover Buy #2")]
        public double MacdLowerBuy2 { get; set; }
        
        [Parameter("Long Cycle", DefaultValue =  26, Group = "MACD Crossover Buy #2")]
        public int MacdLongCycleBuy2 { get; set; }
        
        [Parameter("Short Cycle", DefaultValue =  12, Group = "MACD Crossover Buy #2")]
        public int MacdShortCycleBuy2 { get; set; }

        // Indicator settings for bearish signals

        [Parameter("Timeframe", DefaultValue = "h1", Group = "RSI Sell #1")]
        public TimeFrame RsiTimeFrameSell1 { get; set; }
        
        [Parameter("RSI Periods", DefaultValue =  14, Group = "RSI Sell #1")]
        public int RsiPeriodsSell1 { get; set; }
        
        [Parameter("RSI Upper", DefaultValue =  70, Group = "RSI Sell #1")]
        public int RsiUpperSell1 { get; set; }

        [Parameter("Timeframe", DefaultValue = "h1", Group = "MACD Crossover Sell #2")]
        public TimeFrame MacdTimeFrameSell2 { get; set; }
        
        [Parameter("Signal Periods", DefaultValue =  9, Group = "MACD Crossover Sell #2")]
        public int MacdPeriodsSell2 { get; set; }
        
        [Parameter("MACD Upper", DefaultValue =  0.001, Group = "MACD Crossover Sell #2")]
        public double MacdUpperSell2 { get; set; }
        
        [Parameter("Long Cycle", DefaultValue =  26, Group = "MACD Crossover Sell #2")]
        public int MacdLongCycleSell2 { get; set; }
        
        [Parameter("Short Cycle", DefaultValue =  12, Group = "MACD Crossover Sell #2")]
        public int MacdShortCycleSell2 { get; set; }

        // declaring the standard bullish indicators

        private RelativeStrengthIndex _rsi_Buy1;
        private MacdCrossOver _macd_Buy2;

        // declaring the standard bearish indicators

        private RelativeStrengthIndex _rsi_Sell1;
        private MacdCrossOver _macd_Sell2;

        // declaring the market data variables for bullish signals.

        private Bars _rsiBars_Buy1;
        private Bars _macdBars_Buy2;

        // declaring the market data variables for bearish signals.

        private Bars _rsiBars_Sell1;
        private Bars _macdBars_Sell2;

        // Private fields.

        private string StrategyName { get; set; }

        // makes sure only 1 trade opens per signal
        bool IsBullish { get; set; }
        bool IsBearish { get; set; }    

        // Initialise variables when the cBot starts.

        protected override void OnStart()
        {
            StrategyName = "MACD & RSI Strategy";

            // constructing the market data for the bullish indicators
            _rsiBars_Buy1 = MarketData.GetBars(RsiTimeFrameBuy1);
            _macdBars_Buy2 = MarketData.GetBars(MacdTimeFrameBuy2);

            // constructing the market data for the bearish indicators
            _rsiBars_Sell1 = MarketData.GetBars(RsiTimeFrameSell1);
            _macdBars_Sell2 = MarketData.GetBars(MacdTimeFrameSell2);

            // constructing the BULLISH indicators
            _rsi_Buy1 = Indicators.RelativeStrengthIndex(_rsiBars_Buy1.ClosePrices, RsiPeriodsBuy1);
            _macd_Buy2 = Indicators.MacdCrossOver(_macdBars_Buy2.ClosePrices, MacdLongCycleBuy2, MacdShortCycleBuy2, MacdPeriodsBuy2);

            // constructing the BEARISH indicators
            _rsi_Sell1 = Indicators.RelativeStrengthIndex(_rsiBars_Sell1.ClosePrices, RsiPeriodsSell1);
            _macd_Sell2 = Indicators.MacdCrossOver(_macdBars_Sell2.ClosePrices, MacdLongCycleSell2, MacdShortCycleSell2, MacdPeriodsSell2);
        }

        // The onTick method is called on each price change.
        protected override void OnTick()
        {
          
        }

         // this method is called when the candle closes and is used to check the trade signals, execute trades and send alerts.
        protected override void OnBarClosed()
        {
            TradeRulesBullish();            
            TradeRulesBearish();
        }

        // parent method to check rules and open bullish trade or send signal.
        private void TradeRulesBullish()
        {
            // flag to open a trade if all rules true.
            bool OpenBuyTrade = false;

            if (IsBullishSignal())
            {
                OpenBuyTrade = true;
            }
 
            if (OpenBuyTrade)
            {
                if (!IsBullish)
                {
                    if (!IsTradeOpen(TradeType.Buy))
                    {
                        OpenTrade(TradeType.Buy);
                    }

                    SendTradeAlerts(TradeType.Buy);
                }

                IsBullish = true;
            }
            else
            {
                IsBullish = false;
            }
        }


        // parent method to check rules and open bearish trade or send signal.
        private void TradeRulesBearish()
        {
            // flag to open a trade if all rules true.
            bool OpenSellTrade = false;

           if (IsBearishSignal())
            {
                OpenSellTrade = true;
            }

            if (OpenSellTrade)
            {
                if (!IsBearish)
                {
                    if (!IsTradeOpen(TradeType.Sell))
                    {
                        OpenTrade(TradeType.Sell);
                    }

                    SendTradeAlerts(TradeType.Sell);
                }

                IsBearish = true;
            }
            else
            {
                IsBearish = false;
            }
        }

        // returns true if all signals are bullish
        private bool IsBullishSignal() 
        {
            if (_rsi_Buy1.Result.LastValue > RsiLowerBuy1)
            {
                return false;
            }

            if (_macd_Buy2.MACD.LastValue !> _macd_Buy2.Signal.LastValue && _macd_Buy2.Signal.LastValue !< MacdLowerBuy2)
            {
                return false;
            }

            return true;
        }

        // returns true if all signals are bearish
        private bool IsBearishSignal() 
        {
            if (_rsi_Sell1.Result.LastValue < RsiUpperSell1)
            {
                return false;
            }

            if (_macd_Sell2.MACD.LastValue !< _macd_Sell2.Signal.LastValue && _macd_Sell2.Signal.LastValue !> MacdUpperSell2)
            {
                return false;
            }

            return true;
        }

        private void OpenTrade(TradeType type)
        {
            // calculate volume from lots based on % of the account balance
            var maxAmountRisked = Account.Equity * (RiskPerTrade / 100);
            var volume = Symbol.NormalizeVolumeInUnits(maxAmountRisked / (StopLoss * Symbol.PipValue), RoundingMode.Down);
            ExecuteMarketOrder(type, SymbolName, volume, StrategyName, StopLoss, TakeProfit);
        }

        // returns true if buy trade is open.
        private bool IsTradeOpen(TradeType type)
        {
            var positions = Positions.FindAll(StrategyName, SymbolName, type);
            if (positions.Count() > 0)
            {
                return true;
            }
            else return false;
        }

        // this method manages sending trade alerts
        private void SendTradeAlerts(TradeType type)
        {
            if (IsBacktesting)
            {
                return;
            }

            string direction = "Bullish";

            if (type == TradeType.Sell)
            {
                direction = "Bearish";
            }
            
            // send Telegram
            var Token = BotToken;
            var message = direction + " alert on " + SymbolName + " with " + TimeFrame.ToString();

            var result = Http.Get($"https://api.telegram.org/bot{Token}/sendMessage?chat_id={ChatID}&text={message}");

            // the following error codes may be incorrect and need updating.
            switch (result.StatusCode)
            {
                case 0:
                    Print("Telegram bot sleeping, wake it up.");
                    break;

                case 200:
                    Print("Telegram sent");
                    break;

                case 400:
                    Print("The chat id is incorrect.");
                    break;

                case 401:
                    Print("The bot token is incorrect.");
                    break;

                case 404:
                    Print("The bot token or chat id is missing or incorrect.");
                    break;

                default:
                    Print("unknown error code: " + result.StatusCode);
                    break;
            }

            // show popup
            MessageBox.Show(direction + " alert on " + SymbolName + " with " + TimeFrame.ToString(), StrategyName);
        }
    }
}