Example #1
0
        public void UpdateBrokerAccount(
            IBroker broker,
            IBrokersCandlesService candleService,
            IMarketDetailsService marketsService,
            ITradeDetailsAutoCalculatorService tradeCalculateService,
            UpdateOption option = UpdateOption.OnlyIfNotRecentlyUpdated)
        {
            void UpdateProgressAction(string txt)
            {
            }

            UpdateBrokerAccount(broker, candleService, marketsService, tradeCalculateService, UpdateProgressAction, option);
        }
Example #2
0
        public void SetTrades(List <Trade> trades, ITradeDetailsAutoCalculatorService tradeCalculateService, IBroker broker)
        {
            AccountLastUpdated = DateTime.UtcNow;

            foreach (var t in Trades)
            {
                tradeCalculateService.RemoveTrade(t);
            }

            Trades.Clear();
            Trades.AddRange(trades);

            Log.Debug($"Completed updating {broker.Name} trades");
            _brokerAccountUpdatedSubject.OnNext(new BrokerAccountUpdated(this));
        }
        public void LoadBrokerAccounts(ITradeDetailsAutoCalculatorService tradeCalculatorService, string mainDirectoryWithApplicationName)
        {
            foreach (var broker in Brokers)
            {
                var account = BrokerAccount.LoadAccount(broker, mainDirectoryWithApplicationName);

                if (account == null)
                {
                    account = new BrokerAccount
                    {
                        BrokerName = broker.Name
                    };
                }

                AccountsLookup[broker] = account;
            }
        }
Example #4
0
        public void UpdateBrokerAccount(
            IBroker broker,
            IBrokersCandlesService candleService,
            IMarketDetailsService marketsService,
            ITradeDetailsAutoCalculatorService tradeCalculateService,
            Action <string> updateProgressAction,
            UpdateOption option = UpdateOption.OnlyIfNotRecentlyUpdated)
        {
            if (option == UpdateOption.OnlyIfNotRecentlyUpdated && (AccountLastUpdated != null && (DateTime.UtcNow - AccountLastUpdated.Value).TotalHours < 24))
            {
                return;
            }

            Log.Debug($"Updating {broker.Name} account");

            foreach (var t in Trades)
            {
                tradeCalculateService.RemoveTrade(t);
            }

            try
            {
                broker.UpdateAccount(this, candleService, marketsService, updateProgressAction, out var addedOrUpdatedTrades);

                foreach (var trade in addedOrUpdatedTrades)
                {
                    RecalculateTrade(trade, candleService, marketsService, broker);
                }
            }
            catch (Exception ex)
            {
                Log.Error("Unable to update account", ex);
                MessageBox.Show($"Unable to update account - {ex.Message}", "Unable to update account", MessageBoxButtons.OK);
            }

            AccountLastUpdated = DateTime.UtcNow;

            Log.Debug($"Completed updating {broker.Name} trades");
            _brokerAccountUpdatedSubject.OnNext(new BrokerAccountUpdated(this));
        }
        public List <Trade> CreateNewTrades(
            MarketDetails market,
            TimeframeLookup <List <CandleAndIndicators> > candlesLookup,
            List <Trade> existingTrades,
            ITradeDetailsAutoCalculatorService calculatorService,
            DateTime currentTime)
        {
            if (candlesLookup[Timeframe.M1].Count == 0)
            {
                return(null);
            }

            var candle = candlesLookup[Timeframe.M1][candlesLookup[Timeframe.M1].Count - 1];

            ProcessExistingTrades(existingTrades, currentTime, candle, candlesLookup);

            List <Trade> ret = null;

            for (var i = _trades.Count - 1; i >= 0; i--)
            {
                var t = _trades[i];
                if (t.OriginalTrade.OrderPrices.Count > 0 && t.OriginalTrade.OrderPrices[0].Date <= currentTime || t.OriginalTrade.EntryDateTime <= currentTime)
                {
                    if (ret == null)
                    {
                        ret = new List <Trade>();
                    }

                    ret.Add(t);
                    _trades.RemoveAt(i);
                }
            }

            if (ret != null)
            {
                ProcessExistingTrades(ret, currentTime, candle, candlesLookup);
            }

            return(ret);
        }