Ejemplo n.º 1
0
        private void StartDde()
        {
            if (_trader.IsDde)
            {
                _trader.StartExport(new[] { _trader.SecuritiesTable, _trader.TradesTable });
            }
            else
            {
                _trader.StartExport();
            }

            _isDdeStarted = true;
        }
Ejemplo n.º 2
0
        private void Check_Click(object sender, RoutedEventArgs e)
        {
            var terminal = this.SelectedTerminal;

            if (terminal.SystemProcess.MainModule == null)
            {
                throw new InvalidOperationException("Неподходящий процесс для обработки.");
            }

            this.OkResult.SetVisibility(false);

            _settingErrors.Clear();

            var trader = new QuikTrader(terminal.SystemProcess.MainModule.FileName);

            trader.Connected += () => this.GuiAsync(() =>
            {
                if (this.CheckDde.IsChecked == true)
                {
                    trader.StartExport();
                }

                OnConnect(trader, null);
            });

            trader.ConnectionError += error => this.GuiSync(() => OnConnect(trader, error));

            if (this.CheckDde.IsChecked == true)
            {
                trader.ProcessDataError += error => _settingErrors.Add(new SettingsError("Экспорт DDE. {0}".Put(error.Message), true));
            }

            trader.Connect();
        }
Ejemplo n.º 3
0
        private void Connect_Click(object sender, RoutedEventArgs e)
        {
            if (this.Path.Text.IsEmpty())
            {
                MessageBox.Show(this, "Путь к Quik не выбран");
            }
            else
            {
                if (_trader == null)
                {
                    // создаем шлюз
                    _trader = new QuikTrader(this.Path.Text);

                    this.Portfolio.Trader = _trader;

                    // изменяем метаданные так, чтобы начали обрабатывать дополнительные колонки опционов
                    var columns = _trader.SecuritiesTable.Columns;
                    columns.Add(DdeSecurityColumns.Strike);
                    columns.Add(DdeSecurityColumns.Volatility);
                    columns.Add(DdeSecurityColumns.UnderlyingSecurity);
                    columns.Add(DdeSecurityColumns.TheorPrice);
                    columns.Add(DdeSecurityColumns.OptionType);
                    columns.Add(DdeSecurityColumns.ExpiryDate);

                    // добавляем в выпадающий список только опционы
                    _trader.NewSecurities += securities =>
                                             this.GuiAsync(() => _options.AddRange(securities.Where(s => s.Type == SecurityTypes.Option)));

                    // подписываемся на событие новых сделок чтобы обновить текущую цену фьючерса
                    _trader.NewTrades += trades => this.GuiAsync(() =>
                    {
                        var option = this.SelectedOption;
                        if (option != null)
                        {
                            var future = option.GetUnderlyingAsset();
                            if (future.LastTrade != null)
                            {
                                this.BaseActivePrice.Text = future.LastTrade.Price.ToString();
                            }
                        }
                    });

                    _trader.Connected += () => _trader.StartExport();
                    _trader.Connect();
                }
            }
        }
Ejemplo n.º 4
0
        private void CheckClick(object sender, RoutedEventArgs e)
        {
            var terminal = SelectedTerminal;

            if (terminal.SystemProcess.MainModule == null)
            {
                throw new InvalidOperationException(LocalizedStrings.InvalidProcess);
            }

            OkResult.SetVisibility(false);

            _settingErrors.Clear();

            var isDde = IsDde.IsChecked == true;

            var connector = new QuikTrader(terminal.SystemProcess.MainModule.FileName)
            {
                IsDde = isDde
            };

            var checkDde = isDde && CheckDde.IsChecked == true;

            connector.Connected += () => this.GuiAsync(() =>
            {
                if (checkDde)
                {
                    connector.StartExport();
                }

                OnConnect(connector, null);
            });

            connector.ConnectionError += error => this.GuiSync(() => OnConnect(connector, error));

            if (checkDde)
            {
                connector.ProcessDataError += error => _settingErrors.Add(new SettingsError(LocalizedStrings.Str3030Params.Put(error.Message), true));
            }

            connector.Connect();
        }
Ejemplo n.º 5
0
 private void StartDde()
 {
     Trader.StartExport(_table);
     _isDdeStarted = true;
 }
Ejemplo n.º 6
0
 private void StartDde()
 {
     Trader.StartExport(new[] { Trader.SecuritiesTable });
     _isDdeStarted = true;
 }
Ejemplo n.º 7
0
        private void ConnectClick(object sender, RoutedEventArgs e)
        {
            if (!_isConnected)
            {
                if (Path.Text.IsEmpty())
                {
                    MessageBox.Show(this, "Путь к Quik не выбран");
                }
                else
                {
                    if (Trader == null)
                    {
                        // создаем шлюз
                        Trader = new QuikTrader(Path.Text);

                        //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                        Trader.SupportManualOrders = true;
                        //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

                        // возводим флаг, что соединение установлено
                        _isConnected = true;

                        // инициализируем механизм переподключения (будет автоматически соединяться
                        // каждые 10 секунд, если шлюз потеряется связь с сервером)
                        Trader.ReConnectionSettings.Interval = TimeSpan.FromSeconds(10);

                        // переподключение будет работать только во время работы биржи РТС
                        // (чтобы отключить переподключение когда торгов нет штатно, например, ночью)
                        Trader.ReConnectionSettings.WorkingTime = ExchangeBoard.Forts.WorkingTime;

                        // подписываемся на событие об успешном восстановлении соединения
                        Trader.ReConnectionSettings.ConnectionRestored += () => this.GuiAsync(() => MessageBox.Show(this, "Соединение восстановлено"));

                        // подписываемся на событие разрыва соединения

                        Trader.ConnectionError += error => this.GuiAsync(() => MessageBox.Show(this, error.ToString()));

                        Trader.NewSecurities    += securities => this.GuiAsync(() => _securitiesWindow.Securities.AddRange(securities));
                        Trader.NewMyTrades      += trades => this.GuiAsync(() => _myTradesWindow.Trades.AddRange(trades));
                        Trader.NewTrades        += trades => this.GuiAsync(() => _tradesWindow.Trades.AddRange(trades));
                        Trader.NewOrders        += orders => this.GuiAsync(() => _ordersWindow.Orders.AddRange(orders));
                        Trader.NewStopOrders    += orders => this.GuiAsync(() => _stopOrderWindow.Orders.AddRange(orders));
                        Trader.NewPortfolios    += portfolios => this.GuiAsync(() => _portfoliosWindow.Portfolios.AddRange(portfolios));
                        Trader.NewPositions     += positions => this.GuiAsync(() => _positionsWindow.Positions.AddRange(positions));
                        Trader.ProcessDataError += ex => System.Diagnostics.Debug.WriteLine(ex);
                        Trader.Connected        += () => this.GuiAsync(() =>
                        {
                            ExportDde.IsEnabled = true;
                            if (!Trader.IsExportStarted)
                            {
                                Trader.SecuritiesTable.Columns.Add(DdeSecurityColumns.MinStepPrice);
                                Trader.SecuritiesTable.Columns.Add(DdeSecurityColumns.Strike);
                                Trader.SecuritiesTable.Columns.Add(DdeSecurityColumns.OptionType);
                                Trader.SecuritiesTable.Columns.Add(DdeSecurityColumns.ExpiryDate);
                                Trader.SecuritiesTable.Columns.Add(DdeSecurityColumns.UnderlyingSecurity);
                                Trader.StartExport();
                            }
                            (new SoundPlayer(ConnectedSound)).Play();
                        });

                        ShowSecurities.IsEnabled         = ShowTrades.IsEnabled =
                            ShowMyTrades.IsEnabled       = ShowOrders.IsEnabled =
                                ShowPortfolios.IsEnabled = ShowStopOrders.IsEnabled = btnStart.IsEnabled = true;
                    }

                    Trader.Connect();

                    _isConnected       = true;
                    ConnectBtn.Content = "Отключиться";
                }
            }
            else
            {
                Trader.Disconnect();

                _isConnected       = false;
                ConnectBtn.Content = "Подключиться";
            }
        }
Ejemplo n.º 8
0
        static void Main()
        {
            try
            {
                // для теста выбираем бумагу Лукойл
                const string secCode = "LKOH";

                var quikPath = QuikTerminal.GetDefaultPath();

                if (quikPath.IsEmpty())
                {
                    Console.WriteLine("Не найден ни один запущенный Quik");
                    return;
                }

                Console.WriteLine("Запущенный Quik найден по пути " + quikPath);

                Console.Write("Введите код клиента, через который будет выставлена заявка: ");
                var account = Console.ReadLine();

                using (var waitHandle = new AutoResetEvent(false))
                {
                    // создаем шлюз к Quik-у
                    using (var trader = new QuikTrader(quikPath))
                    {
                        // необходимо раскомментировать, если идет работа с РТС Стандарт
                        //trader.FormatTransaction += builder => builder.RemoveInstruction(TransactionBuilder.ExecutionCondition);

                        // подписываемся на событие успешного подключения
                        // все действия необходимо производить только после подключения
                        trader.Connected += () =>
                        {
                            Console.WriteLine("Подключение было произведено успешно.");

                            // извещаем об успешном соединени
                            waitHandle.Set();
                        };

                        Console.WriteLine("Производим подключение...");

                        trader.Connect();

                        // дожидаемся события об успешном соединении
                        waitHandle.WaitOne();

                        trader.NewPortfolios += portfolios =>
                        {
                            if (_portfolio == null)
                            {
                                // находим Лукойл и присваиваем ее переменной lkoh
                                _portfolio = portfolios.FirstOrDefault(p => p.Name == account);

                                if (_portfolio != null)
                                {
                                    Console.WriteLine("Портфель {0} появился.", account);

                                    // если инструмент и стакан уже появились,
                                    // то извещаем об этом основной поток для выставления заявки
                                    if (_lkoh != null && _depth != null)
                                    {
                                        waitHandle.Set();
                                    }
                                }
                            }
                        };

                        // подписываемся на событие появление инструментов
                        trader.NewSecurities += securities =>
                        {
                            if (_lkoh == null)
                            {
                                // находим Лукойл и присваиваем ее переменной lkoh
                                _lkoh = securities.FirstOrDefault(sec => sec.Code == secCode);

                                if (_lkoh != null)
                                {
                                    Console.WriteLine("Инструмент Лукойл появился.");

                                    // запускаем экспорт стакана
                                    trader.RegisterQuotes(_lkoh);

                                    if (_portfolio != null && _depth != null)
                                    {
                                        waitHandle.Set();
                                    }
                                }
                            }
                        };

                        // подписываемся на событие появления моих новых сделок
                        trader.NewMyTrades += myTrades =>
                        {
                            foreach (var myTrade in myTrades)
                            {
                                var trade = myTrade.Trade;
                                Console.WriteLine("Сделка {0} по цене {1} по бумаге {2} по объему {3} в {4}.", trade.Id, trade.Price, trade.Security.Code, trade.Volume, trade.Time);
                            }
                        };

                        // подписываемся на событие обновления стакана
                        trader.QuotesChanged += depths =>
                        {
                            if (_depth == null && _lkoh != null)
                            {
                                _depth = depths.FirstOrDefault(d => d.Security == _lkoh);

                                if (_depth != null)
                                {
                                    Console.WriteLine("Стакан Лукойла появился.");

                                    // если портфель и инструмент уже появился, то извещаем об этом основной поток для выставления заявки
                                    if (_portfolio != null && _lkoh != null)
                                    {
                                        waitHandle.Set();
                                    }
                                }
                            }
                        };

                        Console.WriteLine("Дожидаемся появления в программе инструмента Лукойл и портфеля {0}...".Put(account));

                        // запускаем экспорт по DDE
                        trader.StartExport(trader.SecuritiesTable, trader.MyTradesTable, trader.EquityPositionsTable,
                                           trader.EquityPortfoliosTable, trader.OrdersTable);

                        // дожидаемся появления портфеля и инструмента
                        waitHandle.WaitOne();

                        // 0.1% от изменения цены
                        const decimal delta = 0.001m;

                        // запоминаем первоначальное значение середины спреда
                        var firstMid = _lkoh.BestPair.SpreadPrice / 2;
                        if (_lkoh.BestBid == null)
                        {
                            throw new Exception("Нет лучшего бида для котировки.");
                        }

                        Console.WriteLine("Первоначальное значение середины спреда {0:0.##}", _lkoh.BestBid.Price + firstMid);

                        while (true)
                        {
                            var mid = _lkoh.BestPair.SpreadPrice / 2;

                            // если спред вышел за пределы нашего диапазона
                            if (
                                ((firstMid + firstMid * delta) <= mid) ||
                                ((firstMid - firstMid * delta) >= mid)
                                )
                            {
                                var order = new Order
                                {
                                    Portfolio = _portfolio,
                                    Price     = _lkoh.ShrinkPrice(_lkoh.BestBid.Price + mid),
                                    Security  = _lkoh,
                                    Volume    = 1,
                                    Direction = OrderDirections.Buy,
                                };
                                trader.RegisterOrder(order);
                                Console.WriteLine("Заявка {0} зарегистрирована.", order.Id);
                                break;
                            }
                            else
                            {
                                Console.WriteLine("Текущее значение середины спреда {0:0.##}", _lkoh.BestBid.Price + mid);
                            }

                            // ждем 1 секунду
                            Thread.Sleep(1000);
                        }

                        // останавливаем экспорт по DDE
                        trader.StopExport(trader.SecuritiesTable, trader.MyTradesTable, trader.EquityPositionsTable,
                                          trader.EquityPortfoliosTable, trader.OrdersTable);
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
        }
Ejemplo n.º 9
0
 private void StartDde()
 {
     _trader.StartExport();
     _isDdeStarted = true;
 }
Ejemplo n.º 10
0
        static void Main()
        {
            try
            {
                Console.Write(LocalizedStrings.Str2992);
                var account1 = Console.ReadLine();

                Console.Write(LocalizedStrings.Str2993);
                var account2 = Console.ReadLine();

                using (var quikTrader1 = new QuikTrader {
                    LuaFixServerAddress = "127.0.0.1:5001".To <EndPoint>()
                })
                    using (var quikTrader2 = new QuikTrader {
                        LuaFixServerAddress = "127.0.0.1:5002".To <EndPoint>()
                    })
                    {
                        // подписываемся на событие ошибок обработки данных и разрыва соединения
                        //
                        quikTrader1.ProcessDataError += OnError;
                        quikTrader2.ProcessDataError += OnError;

                        quikTrader1.ConnectionError += OnError;
                        quikTrader2.ConnectionError += OnError;


                        var portfoliosWait = new ManualResetEvent(false);

                        Action <IEnumerable <Portfolio> > newPortfolios = portfolios =>
                        {
                            if (_portfolio1 == null)
                            {
                                _portfolio1 = portfolios.FirstOrDefault(p => p.Name == account1);
                            }

                            if (_portfolio2 == null)
                            {
                                _portfolio2 = portfolios.FirstOrDefault(p => p.Name == account2);
                            }

                            // если оба инструмента появились
                            if (_portfolio1 != null && _portfolio2 != null)
                            {
                                portfoliosWait.Set();
                            }
                        };

                        // подписываемся на события новых портфелей
                        quikTrader1.NewPortfolios += newPortfolios;
                        quikTrader2.NewPortfolios += newPortfolios;


                        var securitiesWait = new ManualResetEvent(false);

                        // подписываемся на события новых инструментов
                        quikTrader1.NewSecurities += securities =>
                        {
                            if (_lkoh == null)
                            {
                                _lkoh = securities.FirstOrDefault(s => s.Code == "LKOH");
                            }

                            // если оба инструмента появились
                            if (_lkoh != null && _riz0 != null)
                            {
                                securitiesWait.Set();
                            }
                        };
                        quikTrader2.NewSecurities += securities =>
                        {
                            if (_riz0 == null)
                            {
                                _riz0 = securities.FirstOrDefault(s => s.Code == "RIZ0");
                            }

                            // если оба инструмента появились
                            if (_lkoh != null && _riz0 != null)
                            {
                                securitiesWait.Set();
                            }
                        };


                        // запускаем экспорты в Quik-ах, когда получим событие об успешном соединении
                        //
                        quikTrader1.Connected += () =>
                        {
                            Console.WriteLine(LocalizedStrings.Str2994Params.Put(quikTrader1.LuaFixServerAddress));
                            quikTrader1.StartExport();
                        };
                        quikTrader2.Connected += () =>
                        {
                            Console.WriteLine(LocalizedStrings.Str2994Params.Put(quikTrader2.LuaFixServerAddress));
                            quikTrader2.StartExport();
                        };

                        // производим подключение каждого из QuikTrader-а
                        //
                        quikTrader1.Connect();
                        quikTrader2.Connect();

                        Console.WriteLine(LocalizedStrings.Str2995);
                        portfoliosWait.WaitOne();
                        securitiesWait.WaitOne();

                        Console.WriteLine(LocalizedStrings.Str2996);
                        if (_lkoh.BestBid == null || _riz0.BestBid == null)
                        {
                            throw new Exception(LocalizedStrings.Str2990);
                        }

                        quikTrader1.RegisterOrder(new Order
                        {
                            Portfolio = _portfolio1,
                            Volume    = 1,
                            Security  = _lkoh,
                            Price     = _lkoh.BestBid.Price
                        });
                        Console.WriteLine(LocalizedStrings.Str2997);

                        quikTrader2.RegisterOrder(new Order
                        {
                            Portfolio = _portfolio2,
                            Volume    = 1,
                            Security  = _riz0,
                            Price     = _riz0.BestBid.Price
                        });
                        Console.WriteLine(LocalizedStrings.Str2998);
                    }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
        }
Ejemplo n.º 11
0
        static void Main()
        {
            try
            {
                // для теста выбираем бумагу Лукойл
                const string secCode = "LKOH";

                var quikPath = QuikTerminal.GetDefaultPath();

                if (quikPath.IsEmpty())
                {
                    Console.WriteLine(LocalizedStrings.Str2984);
                    return;
                }

                Console.WriteLine(LocalizedStrings.Str2985 + quikPath);

                Console.Write(LocalizedStrings.Str2986);
                var account = Console.ReadLine();

                using (var waitHandle = new AutoResetEvent(false))
                {
                    // создаем подключение к Quik-у
                    using (var trader = new QuikTrader(quikPath)
                    {
                        IsDde = true
                    })
                    {
                        // необходимо раскомментировать, если идет работа с РТС Стандарт
                        //trader.FormatTransaction += builder => builder.RemoveInstruction(Transaction.TimeInForce);

                        // подписываемся на событие успешного подключения
                        // все действия необходимо производить только после подключения
                        trader.Connected += () =>
                        {
                            Console.WriteLine(LocalizedStrings.Str2169);

                            // извещаем об успешном соединени
                            waitHandle.Set();
                        };

                        Console.WriteLine(LocalizedStrings.Str2170);

                        trader.Connect();

                        // дожидаемся события об успешном соединении
                        waitHandle.WaitOne();

                        trader.NewPortfolios += portfolios =>
                        {
                            if (_portfolio == null)
                            {
                                // находим нужный портфель и присваиваем его переменной _portfolio
                                _portfolio = portfolios.FirstOrDefault(p => p.Name == account);

                                if (_portfolio != null)
                                {
                                    Console.WriteLine(LocalizedStrings.Str2171Params, account);

                                    // если инструмент и стакан уже появились,
                                    // то извещаем об этом основной поток для выставления заявки
                                    if (_lkoh != null && _depth != null)
                                    {
                                        waitHandle.Set();
                                    }
                                }
                            }
                        };

                        // подписываемся на событие появление инструментов
                        trader.NewSecurities += securities =>
                        {
                            if (_lkoh == null)
                            {
                                // находим Лукойл и присваиваем ее переменной lkoh
                                _lkoh = securities.FirstOrDefault(sec => sec.Code == secCode);

                                if (_lkoh != null)
                                {
                                    Console.WriteLine(LocalizedStrings.Str2987);

                                    // запускаем экспорт стакана
                                    trader.RegisterMarketDepth(_lkoh);

                                    if (_portfolio != null && _depth != null)
                                    {
                                        waitHandle.Set();
                                    }
                                }
                            }
                        };

                        // подписываемся на событие появления моих новых сделок
                        trader.NewMyTrades += myTrades =>
                        {
                            foreach (var myTrade in myTrades)
                            {
                                var trade = myTrade.Trade;
                                Console.WriteLine(LocalizedStrings.Str2173Params, trade.Id, trade.Price, trade.Security.Code, trade.Volume, trade.Time);
                            }
                        };

                        // подписываемся на событие обновления стакана
                        trader.MarketDepthsChanged += depths =>
                        {
                            if (_depth == null && _lkoh != null)
                            {
                                _depth = depths.FirstOrDefault(d => d.Security == _lkoh);

                                if (_depth != null)
                                {
                                    Console.WriteLine(LocalizedStrings.Str2988);

                                    // если портфель и инструмент уже появился, то извещаем об этом основной поток для выставления заявки
                                    if (_portfolio != null && _lkoh != null)
                                    {
                                        waitHandle.Set();
                                    }
                                }
                            }
                        };

                        Console.WriteLine(LocalizedStrings.Str2989Params.Put(account));

                        // запускаем экспорт по DDE
                        trader.StartExport(new[] { trader.SecuritiesTable, trader.MyTradesTable, trader.EquityPositionsTable,
                                                   trader.EquityPortfoliosTable, trader.OrdersTable });

                        // дожидаемся появления портфеля и инструмента
                        waitHandle.WaitOne();

                        // 0.1% от изменения цены
                        const decimal delta = 0.001m;

                        // запоминаем первоначальное значение середины спреда
                        var firstMid = _lkoh.BestPair.SpreadPrice / 2;
                        if (_lkoh.BestBid == null || firstMid == null)
                        {
                            throw new Exception(LocalizedStrings.Str2990);
                        }

                        Console.WriteLine(LocalizedStrings.Str2991Params, _lkoh.BestBid.Price + firstMid);

                        while (true)
                        {
                            var mid = _lkoh.BestPair.SpreadPrice / 2;

                            // если спред вышел за пределы нашего диапазона
                            if (mid != null &&
                                ((firstMid + firstMid * delta) <= mid ||
                                 (firstMid - firstMid * delta) >= mid)
                                )
                            {
                                var order = new Order
                                {
                                    Portfolio = _portfolio,
                                    Price     = _lkoh.ShrinkPrice(_lkoh.BestBid.Price + mid.Value),
                                    Security  = _lkoh,
                                    Volume    = 1,
                                    Direction = Sides.Buy,
                                };
                                trader.RegisterOrder(order);
                                Console.WriteLine(LocalizedStrings.Str1157Params, order.Id);
                                break;
                            }
                            else
                            {
                                Console.WriteLine(LocalizedStrings.Str2176Params, _lkoh.BestBid.Price + mid);
                            }

                            // ждем 1 секунду
                            Thread.Sleep(1000);
                        }

                        // останавливаем экспорт по DDE
                        trader.StopExport(new[] { trader.SecuritiesTable, trader.MyTradesTable, trader.EquityPositionsTable,
                                                  trader.EquityPortfoliosTable, trader.OrdersTable });
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
        }