Copy Trades from JSON

using System;
using System.Linq;
using System.IO;
using System.Text;
using cAlgo.API;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;
using cAlgo.Indicators;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Collections.Generic;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.FullAccess)]
    public class StrxCopyTradesJSON : Robot
    {
        [Parameter(DefaultValue = "C:\\YOUR MT4 PATH\\MQL4\\Files\\trades.json")]
        public string FileTradesJSON { get; set; }

        [Parameter(DefaultValue = "")]
        public string SymbolToCopyFrom { get; set; }

        private JSONTrades trades;
        protected SortedSet<int> managedTickets;
        protected DateTime lastFileWriteDT;

        protected override void OnStart()
        {
            CheckParameters();

            managedTickets = new SortedSet<int>();
            lastFileWriteDT = new DateTime(2000, 1, 1);

            UpdateJSONTrades();
            UpdateManagedTickets();
        }

        protected void CheckParameters()
        {
            if (SymbolToCopyFrom.Length == 0)
            {
                Print("Error SymbolToCopyFrom Mandatory");
                Stop();
            }
            else
            {
                FileInfo f = new FileInfo(FileTradesJSON);
                if (!f.Exists)
                {
                    Print("JSON File does not exists!");
                    Stop();
                }
            }
        }

        protected override void OnTick() {
            if (UpdateJSONTrades()) {
                CheckNewTrades();
                UpdateManagedTickets();
                CheckClosedTrades();
            }
        }

        protected override void OnStop() {
        }

        protected bool UpdateJSONTrades() {
            FileInfo f = new FileInfo(FileTradesJSON);
            if (f.LastWriteTime <= lastFileWriteDT)
                return false;

            lastFileWriteDT = f.LastWriteTime;

            Print("LastWriteTime " + lastFileWriteDT + " checking trades");

            string content = File.ReadAllText(FileTradesJSON);
            MemoryStream ms = new MemoryStream(Encoding.Unicode.GetBytes(content));
            DataContractJsonSerializer deserializer = new DataContractJsonSerializer(typeof(JSONTrades));
            trades = (JSONTrades)deserializer.ReadObject(ms);

            return true;
        }

        protected void UpdateManagedTickets() {
            foreach (JSONTrade o in trades.trades) {
                if (!o.pending && !managedTickets.Contains(o.ticket))
                    managedTickets.Add(o.ticket);
            }
        }

        protected void CheckNewTrades() {
            IList<JSONTrade> unmanaged = unmanagedTrades();
            foreach (JSONTrade o in unmanaged) {
                if (o.symbol == SymbolToCopyFrom && !o.pending) {
                    ExecuteMarketOrderAsync(o.buy ? TradeType.Buy : TradeType.Sell, SymbolName, o.lots, "o:" + o.ticket);
                }
            }
        }

        protected void CheckClosedTrades() {
            foreach (Position p in Positions) {
                if (p.SymbolName == SymbolName && p.Label.IndexOf("o:") == 0) {
                    int ticket = int.Parse(p.Label.Substring(2));
                    bool exists = false;
                    foreach (JSONTrade o in trades.trades)
                    {
                        if (o.ticket == ticket)
                        {
                            exists = true;
                            break;
                        }
                    }
                    if (!exists)
                        ClosePositionAsync(p);
                }
            }
        }

        private IList<JSONTrade> unmanagedTrades()
        {
            IList<JSONTrade> rv = new List<JSONTrade>();
            for (int i = 0; i < trades.trades.Length; i++)
            {
                if (!managedTickets.Contains(trades.trades[i].ticket))
                {
                    rv.Add(trades.trades[i]);
                }
            }
            return rv;
        }
    }

    [DataContract()]
    class JSONTrade
    {
        [DataMember()]
        public string symbol { get; set; }

        [DataMember()]
        public int ticket { get; set; }

        [DataMember()]
        public bool buy { get; set; }

        [DataMember()]
        public bool pending { get; set; }

        [DataMember()]
        public bool limit { get; set; }

        [DataMember()]
        public bool stop { get; set; }

        [DataMember()]
        public double openPrice { get; set; }

        [DataMember()]
        public int openTime { get; set; }

        [DataMember()]
        public double lots { get; set; }

        [DataMember()]
        public double sl { get; set; }

        [DataMember()]
        public double tp { get; set; }

        [DataMember()]
        public string comment { get; set; }

        [DataMember()]
        public double swap { get; set; }

        [DataMember()]
        public double commission { get; set; }
    }

    [DataContract()]
    class JSONTrades
    {
        [DataMember()]
        public JSONTrade[] trades { get; set; }
    }
}