public AccountItem GetAccount(int id)
        {
            decimal brokerLeverage;
            AccountItem account;
            try
            {
                using (var ctx = DatabaseContext.Instance.Make())
                {
                    var accountDb = ctx.ACCOUNT.FirstOrDefault(x => x.ID == id);
                    account = new AccountItem(accountDb)
                    {
                        CountOpenPosition = ctx.POSITION.Count(x => x.AccountID == id)
                    };

                    brokerLeverage = ctx.ACCOUNT_GROUP.Single(x => x.Code == account.Group).BrokerLeverage;
                }
            }
            catch (Exception ex)
            {
                Logger.Error(String.Format("GetAccount() - Не удалось получить счет {0}", id), ex);
                return null;
            }

            // инициализация "расчётных" параметров счёта таких ка баланс и профит
            try
            {
                List<MarketOrder> marketOrders;

                TradeSharpAccount.Instance.proxy.GetMarketOrders(account.ID, out marketOrders);

                var quoteStorage = new QuoteStorageProxy("IQuoteStorageBinding");
                var currentQuotes = quoteStorage.GetQuoteData(); // актуальные значения катировок на текущий момент (всех катировок, зарегистрированных в терминале)

                account.Equity = account.Balance + (decimal)DalSpot.Instance.CalculateOpenedPositionsCurrentResult(marketOrders,
                    currentQuotes, account.Currency);

                var processingErrors = new List<string>();
                account.Exposure = DalSpot.Instance.CalculateExposure(marketOrders, currentQuotes, account.Currency, processingErrors);
                if (brokerLeverage != 0 && account.Exposure != 0)
                    account.UsedMargin = (account.Exposure / brokerLeverage);
            }
            catch (Exception ex)
            {
                Logger.Error("GetAccount() не удалось расчитать текущий profit по открытым сделкам", ex);
                return null;
            }
            return account;
        }
        public static void LoadCandlesSilent(
            Dictionary<string, Cortege2<DateTime, DateTime>> tickersToUpload,
            QuoteStorageProxy quoteStorage,
            string quoteFolder,
            int minMinutesOfGap)
        {
            const int daysInRequest = 5, minDaysInRequest = 2;
            foreach (var ticker in tickersToUpload)
            {
                var pointCost = DalSpot.Instance.GetPrecision10(ticker.Key);
                var filePath = string.Format("{0}\\{1}.quote",
                                             ExecutablePath.ExecPath + quoteFolder,
                                             ticker.Key);

                DateTime? lastDateStore = null;
                DateTime? oldStart = null, oldEnd = null;
                bool endsUpNewLine;

                if (File.Exists(filePath))
                    GetFirstAndLastFileDates(filePath, out oldStart, out oldEnd, out endsUpNewLine);
                else
                {
                    var dirName = Path.GetDirectoryName(filePath);
                    if (!Directory.Exists(dirName))
                    {
                        try
                        {
                            Directory.CreateDirectory(dirName);
                        }
                        catch (Exception ex)
                        {
                            Logger.Error(String.Format("Невозможно создать каталог котировок \"{0}\": {1}", dirName, ex));
                            throw;
                        }
                    }
                }

                if (oldStart.HasValue && oldEnd.HasValue)
                {
                    var deltaStart = (oldStart.Value - ticker.Value.a).TotalMinutes;
                    var deltaEnd = (ticker.Value.b - oldEnd.Value).TotalMinutes;
                    if (deltaStart <= minMinutesOfGap &&
                        deltaEnd <= minMinutesOfGap) continue;

                    if (deltaStart <= minMinutesOfGap)
                    {
                        lastDateStore = oldEnd.Value;
                    }
                }

                var dateLast = DateTime.Now;
                for (var dateStart = lastDateStore.HasValue ? lastDateStore.Value.AddMinutes(1) : ticker.Value.a;
                    dateStart < ticker.Value.b; )
                {
                    var dateEnd = dateStart.AddDays(daysInRequest);
                    if ((dateLast - dateEnd).TotalDays < minDaysInRequest) dateEnd = dateLast;

                    // запрос
                    List<CandleData> curCandles = null;
                    var numFaultsLeft = 2;
                    while (numFaultsLeft > 0)
                    {
                        // попытка подгрузить котировки
                        try
                        {
                            var packedQuotes = quoteStorage.GetMinuteCandlesPacked(ticker.Key, dateStart, dateEnd);
                            if (packedQuotes != null && packedQuotes.count > 0)
                            {
                                var denseCandles = packedQuotes.GetCandles();
                                if (denseCandles != null && denseCandles.Count > 0)
                                {
                                    curCandles = denseCandles.Select(c => new CandleData(c, pointCost)).ToList();
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Logger.ErrorFormat("Ошибка закачки котировок {0} c {1:dd.MM.yyyy}: {2}",
                                                ticker.Key, dateStart, ex.Message);
                            curCandles = null;
                        }

                        if (curCandles == null)
                        {
                            // попытка неуспешна - еще одна?
                            numFaultsLeft--;
                            if (numFaultsLeft > 0) continue;
                            break;
                        }
                        break;
                    }

                    if (curCandles != null && curCandles.Count > 0)
                    {
                        // записать в файл прочитанные из БД котировки
                        try
                        {
                            var existData = CandleData.LoadFromFile(filePath, ticker.Key);
                            if (existData != null && existData.Count > 0)
                                CandleData.MergeCandles(ref curCandles, existData, true);
                        }
                        catch (Exception ex)
                        {
                            Logger.ErrorFormat("QuoteCacheManager.LoadQuotesSilent() - ошибка чтения / склейки котировок \"{0}\": {1}",
                                filePath, ex);
                        }
                        try
                        {

                            CandleData.SaveInFile(filePath, ticker.Key, curCandles);
                        }
                        catch (Exception ex)
                        {
                            Logger.ErrorFormat("QuoteCacheManager.LoadQuotesSilent() - ошибка сохранения котировок \"{0}\": {1}",
                                filePath, ex);
                        }

                    }
                    dateStart = dateEnd;
                }
            }
        }