Ejemplo n.º 1
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.º 2
0
		private void ConnectClick(object sender, RoutedEventArgs e)
		{
			if (Path.Text.IsEmpty())
				MessageBox.Show(this, LocalizedStrings.Str2969);
			else
			{
				Trader = new QuikTrader(Path.Text) { IsDde = true, IsAsyncMode = true };

				Portfolios.Portfolios = new PortfolioDataSource(Trader);

				Trader.NewSecurities += securities => _securitiesWindow.SecurityPicker.Securities.AddRange(securities);

				// подписываемся на событие о неудачной регистрации заявок
				Trader.OrdersRegisterFailed += OrdersFailed;
				// подписываемся на событие о неудачном снятии заявок
				Trader.OrdersCancelFailed += OrdersFailed;

				// подписываемся на событие о неудачной регистрации стоп-заявок
				Trader.StopOrdersRegisterFailed += OrdersFailed;
				// подписываемся на событие о неудачном снятии стоп-заявок
				Trader.StopOrdersCancelFailed += OrdersFailed;

				// добавляем экспорт дополнительных колонок из стакана (своя покупка и продажа)
				Trader.QuotesTable.Columns.Add(DdeQuoteColumns.OwnBidVolume);
				Trader.QuotesTable.Columns.Add(DdeQuoteColumns.OwnAskVolume);

				Trader.Connect();

				ShowSecurities.IsEnabled = true;
				ConnectBtn.IsEnabled = false;
			}
		}
Ejemplo n.º 3
0
		private void ConnectClick(object sender, RoutedEventArgs e)
		{
			if (!_isConnected)
			{
				if (Path.Text.IsEmpty())
					MessageBox.Show(this, LocalizedStrings.Str2969);
				else
				{
					if (Trader == null)
					{
						// создаем подключение
						Trader = new QuikTrader(Path.Text) { IsDde = true };

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

						// подписываемся на событие ошибки соединения
						Trader.ConnectionError += error => this.GuiAsync(() => MessageBox.Show(this, error.ToString()));

						Trader.NewSecurities += securities => _securitiesWindow.SecurityPicker.Securities.AddRange(securities);

						Trader.Error += error => System.Diagnostics.Debug.WriteLine(error);

						// добавляем на экспорт необходимые колонки
						Trader.SecuritiesTable.Columns.Add(DdeSecurityColumns.ImpliedVolatility);
						Trader.SecuritiesTable.Columns.Add(DdeSecurityColumns.TheorPrice);
						Trader.SecuritiesTable.Columns.Add(DdeSecurityColumns.UnderlyingSecurity);
						Trader.SecuritiesTable.Columns.Add(DdeSecurityColumns.StepPrice);

						// добавляем экспорт дополнительных колонок из стакана (своя продажа и покупка)
						Trader.QuotesTable.Columns.Add(DdeQuoteColumns.OwnAskVolume);
						Trader.QuotesTable.Columns.Add(DdeQuoteColumns.OwnBidVolume);

						Trader.DdeTables = new[] { Trader.SecuritiesTable };

						Trader.Connected += () => this.GuiAsync(() =>
						{
							ShowSecurities.IsEnabled = true;

							_isConnected = true;
							ConnectBtn.Content = LocalizedStrings.Disconnect;
						});

						Trader.Disconnected += () => this.GuiAsync(() =>
						{
							_isConnected = false;
							ConnectBtn.Content = LocalizedStrings.Connect;
						});
					}
					
					Trader.Connect();
				}
			}
			else
				Trader.Disconnect();
		}
Ejemplo n.º 4
0
		private void ConnectClick(object sender, RoutedEventArgs e)
		{
			if (!_isConnected)
			{
				if (Path.Text.IsEmpty())
					MessageBox.Show(this, LocalizedStrings.Str2969);
				else
				{
					if (Trader == null)
					{
						// создаем подключение
						Trader = new QuikTrader(Path.Text) { IsDde = true };

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

						// подписываемся на событие ошибки соединения
						Trader.ConnectionError += error => this.GuiAsync(() => MessageBox.Show(this, error.ToString()));

						// добавляем тип QuikCandle для преобразования строчки из таблица Исторические свечи в объект QuikCandle
						_table = new DdeCustomTable(typeof(QuikCandle));
						Trader.CustomTables.Add(_table);

						Trader.NewCustomTables += (type, objects) =>
						{
							// нас интересует только QuikCandle
							if (type == typeof(QuikCandle))
								_candlesWindow.Candles.AddRange(objects.Cast<QuikCandle>());
						};

						Trader.Connected += () => this.GuiAsync(() =>
						{
							ShowCandles.IsEnabled = true;
							ExportDde.IsEnabled = true;

							_isConnected = true;
							ConnectBtn.Content = LocalizedStrings.Disconnect;
						});

						Trader.Disconnected += () => this.GuiAsync(() =>
						{
							_isConnected = false;
							ConnectBtn.Content = LocalizedStrings.Connect;
						});
					}
					
					Trader.Connect();
				}
			}
			else
				Trader.Disconnect();
		}
Ejemplo n.º 5
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.º 6
0
		private void ConnectClick(object sender, RoutedEventArgs e)
		{
			var isLua = IsLua.IsChecked == true;

			if (isLua)
			{
				if (Address.Text.IsEmpty())
				{
					MessageBox.Show(this, LocalizedStrings.Str2977);
					return;
				}

				if (Login.Text.IsEmpty())
				{
					MessageBox.Show(this, LocalizedStrings.Str2978);
					return;
				}

				if (Password.Password.IsEmpty())
				{
					MessageBox.Show(this, LocalizedStrings.Str2979);
					return;
				}
			}
			else
			{
				if (Path.Text.IsEmpty())
				{
					MessageBox.Show(this, LocalizedStrings.Str2983);
					return;
				}
			}

			if (_trader == null)
			{
				// создаем подключение
				_trader = isLua
					? new QuikTrader
					{
						LuaFixServerAddress = Address.Text.To<EndPoint>(),
						LuaLogin = Login.Text,
						LuaPassword = Password.Password.To<SecureString>()
					}
					: new QuikTrader(Path.Text) { IsDde = true };

				if (_trader.IsDde)
				{
					_trader.DdeTables = new[] { _trader.SecuritiesTable, _trader.TradesTable };
				}

				_logManager.Sources.Add(_trader);
				// подписываемся на событие об успешном восстановлении соединения
				_trader.Restored += () => this.GuiAsync(() => MessageBox.Show(this, LocalizedStrings.Str2958));

				// подписываемся на событие разрыва соединения
				_trader.ConnectionError += error => this.GuiAsync(() => MessageBox.Show(this, error.ToString()));

				// подписываемся на ошибку обработки данных (транзакций и маркет)
				_trader.Error += error =>
					this.GuiAsync(() => MessageBox.Show(this, error.ToString(), "Ошибка обработки данных"));

				// подписываемся на ошибку подписки маркет-данных
				_trader.MarketDataSubscriptionFailed += (security, type, error) =>
					this.GuiAsync(() => MessageBox.Show(this, error.ToString(), LocalizedStrings.Str2956Params.Put(type, security)));
				
				_trader.NewSecurities += securities => this.GuiAsync(() => Security.ItemsSource = _trader.Securities);

				_trader.Connect();

				_candleManager = new CandleManager(_trader);
				_candleManager.Processing += DrawCandle;

				ConnectBtn.IsEnabled = false;
			}
		}
		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;

			if ((connector != null) && (!connector.IsDisposed))
				connector.Dispose();

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

			if (isDde && CheckDde.IsChecked == false)
				connector.Adapter.InnerAdapters.Remove(connector.MarketDataAdapter);

			connector.Connected += () => this.GuiAsync(() =>
			{
				OnConnect(connector, null);
			});

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

			if (connector.MarketDataAdapter != null)
				connector.Error += error => _settingErrors.Add(new SettingsError(LocalizedStrings.Str3030Params.Put(error.Message), true));	

			connector.Connect();
		}
		private void OnConnect(QuikTrader trader, Exception connectionError)
		{
			if (connectionError == null)
			{
				_settingErrors.AddRange(trader.Terminal.GetTableSettings()
					.Select(r => new SettingsError(LocalizedStrings.Str3031Params.Put(r.Table.Caption, r.Error.Message), r.IsCritical)));

				if (_settingErrors.Count == 0)
					OkResult.SetVisibility(true);
			}
			else
				MessageBox.Show(this, connectionError.ToString(), "Verifier");

			trader.Dispose();
		}
Ejemplo n.º 9
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.DdeTables = new[] { trader.SecuritiesTable, trader.MyTradesTable, trader.EquityPositionsTable,
						                   trader.EquityPortfoliosTable, trader.OrdersTable };

						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));

						// дожидаемся появления портфеля и инструмента
						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);
						}

						// останавливаем подключение
						trader.Disconnect();
					}
				}
			}
			catch (Exception ex)
			{
				Console.WriteLine(ex);
			}
		}
Ejemplo n.º 10
0
		private void ConnectClick(object sender, RoutedEventArgs e)
		{
			if (_connector == null)
			{
				if (IsQuik.IsChecked == true)
				{
					var isDde = IsDde.IsChecked == true;

					if (isDde && Path.Text.IsEmpty())
					{
						MessageBox.Show(this, LocalizedStrings.Str2969);
						return;
					}

					// создаем подключение
					var trader = new QuikTrader(Path.Text)
					{
						IsDde = isDde
					};

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

						trader.DdeTables = new[] { trader.SecuritiesTable, trader.TradesTable };
					}

					_connector = trader;
				}
				else
				{
					var trader = new PlazaTrader
					{
						Address = Address.Text.To<EndPoint>(),
						IsCGate = IsCGate.IsChecked == true
					};

					trader.Tables.Add(trader.TableRegistry.Volatility);

					if (IsAutorization.IsChecked == true)
					{
						trader.Login = Login.Text;
						trader.Password = Password.Password;
					}

					_connector = trader;
				}

				Desk.MarketDataProvider = _connector;
				Desk.SecurityProvider = _connector;
				Desk.CurrentTime = null;

				// добавляем в выпадающий список только фьючерсы
				_connector.NewSecurities += securities =>
					this.GuiAsync(() =>
					{
						_assets.AddRange(securities.Where(s => s.Type == SecurityTypes.Future));

						if (SelectedAsset == null && _assets.Count > 0)
							SelectedAsset = _assets.First();

						if (SelectedAsset != null)
						{
							var newStrikes = securities
								.Where(s => s.Type == SecurityTypes.Option && s.UnderlyingSecurityId.CompareIgnoreCase(SelectedAsset.Id))
								.ToArray();

							if (newStrikes.Length > 0)
							{
								_options.AddRange(newStrikes);
								Desk.Options = _options;
								Desk.RefreshOptions();
							}
						}
					});

				_connector.SecuritiesChanged += securities =>
				{
					this.GuiAsync(() =>
					{
						if (SelectedAsset == null)
							return;

						var newStrikes = securities
								.Where(s => s.Type == SecurityTypes.Option && s.UnderlyingSecurityId.CompareIgnoreCase(SelectedAsset.Id))
								.Where(s => !_options.Contains(s))
								.ToArray();

						if (newStrikes.Length > 0)
						{
							_options.AddRange(newStrikes);
							Desk.Options = _options;
							Desk.RefreshOptions();
						}

						if (Desk.Options.Intersect(securities).Any())
							Desk.RefreshOptions();
					});
				};

				// подписываемся на событие новых сделок чтобы обновить текущую цену фьючерса
				_connector.NewTrades += trades => this.GuiAsync(() =>
				{
					var asset = SelectedAsset;
					if (asset == null)
						return;

					if (asset.LastTrade != null)
						LastPrice.Text = asset.LastTrade.Price.To<string>();
				});
			}

			if (_connector.ConnectionState == ConnectionStates.Connected)
				_connector.Disconnect();
			else
				_connector.Connect();
		}
Ejemplo n.º 11
0
 private void Button_Click_1(object sender, RoutedEventArgs e)
 {
     QuikTrader q = new QuikTrader(QuikTerminal.GetDefaultPath());
     q.Connect();
 }
Ejemplo n.º 12
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.º 13
0
		private void ConnectClick(object sender, RoutedEventArgs e)
		{
			if (_trader == null || _trader.ConnectionState == ConnectionStates.Disconnected)
			{
				if (_trader == null)
				{
					if (Path.Text.IsEmpty())
					{
						MessageBox.Show(this, LocalizedStrings.Str2983);
						return;
					}

					// создаем подключение
					_trader = new QuikTrader(Path.Text) { IsDde = true };

					Portfolios.Connector = _trader;

					_trader.Connected += () =>
					{
						_candleManager = new CandleManager(_trader);

						_trader.NewSecurities += securities =>
						{
							// находим нужную бумагу
							var lkoh = securities.FirstOrDefault(s => s.Code == "LKOH");

							if (lkoh != null)
							{
								_lkoh = lkoh;

								this.GuiAsync(() =>
								{
									Start.IsEnabled = true;
								});
							}
						};

						_trader.NewMyTrades += trades =>
						{
							if (_strategy != null)
							{
								// найти те сделки, которые совершила стратегия скользящей средней
								trades = trades.Where(t => _strategy.Orders.Any(o => o == t.Order));

								Trades.Trades.AddRange(trades);
							}
						};

						_candleManager.Processing += (series, candle) =>
						{
							// если скользящие за сегодняшний день отрисованы, то рисуем в реальном времени текущие скользящие
							if (_isTodaySmaDrawn && candle.State == CandleStates.Finished)
								ProcessCandle(candle);
						};
						//_trader.Error += ex => this.GuiAsync(() => MessageBox.Show(this, ex.ToString()));
						_trader.ConnectionError += ex =>
						{
							if (ex != null)
								this.GuiAsync(() => MessageBox.Show(this, ex.ToString()));
						};

						this.GuiAsync(() =>
						{
							ConnectBtn.IsEnabled = false;
							Report.IsEnabled = true;
						});
					};
				}

				_trader.Connect();
			}
			else
				_trader.Disconnect();
		}
Ejemplo n.º 14
0
		private void ConnectClick(object sender, RoutedEventArgs e)
		{
			if (!_isConnected)
			{
				var isLua = IsLua.IsChecked == true;

				if (isLua)
				{
					if (Address.Text.IsEmpty())
					{
						MessageBox.Show(this, LocalizedStrings.Str2977);
						return;
					}

					if (Login.Text.IsEmpty())
					{
						MessageBox.Show(this, LocalizedStrings.Str2978);
						return;
					}

					if (Password.Password.IsEmpty())
					{
						MessageBox.Show(this, LocalizedStrings.Str2979);
						return;
					}
				}
				else
				{
					if (Path.Text.IsEmpty())
					{
						MessageBox.Show(this, LocalizedStrings.Str2969);
						return;
					}
				}

				if (Trader == null)
				{
					// создаем подключение
					Trader = isLua
						? new QuikTrader
						{
							LuaFixServerAddress = Address.Text.To<EndPoint>(),
							LuaLogin = Login.Text,
							LuaPassword = Password.Password.To<SecureString>()
						}
						: new QuikTrader(Path.Text) { IsDde = true };

					Trader.LogLevel = LogLevels.Debug;

					_logManager.Sources.Add(Trader);

					// отключение автоматического запроса всех инструментов.
					Trader.RequestAllSecurities = AllSecurities.IsChecked == true;

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

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

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

					// подписываемся на событие разрыва соединения
					Trader.ConnectionError += error => this.GuiAsync(() => MessageBox.Show(this, error.ToString()));

					// подписываемся на ошибку обработки данных (транзакций и маркет)
					//Trader.Error += error =>
					//	this.GuiAsync(() => MessageBox.Show(this, error.ToString(), "Ошибка обработки данных"));

					// подписываемся на ошибку подписки маркет-данных
					Trader.MarketDataSubscriptionFailed += (security, type, error) =>
						this.GuiAsync(() => MessageBox.Show(this, error.ToString(), LocalizedStrings.Str2956Params.Put(type, security)));

					Trader.NewSecurities += securities => _securitiesWindow.SecurityPicker.Securities.AddRange(securities);
					Trader.NewMyTrades += trades => _myTradesWindow.TradeGrid.Trades.AddRange(trades);
					Trader.NewTrades += trades => _tradesWindow.TradeGrid.Trades.AddRange(trades);
					Trader.NewOrders += orders => _ordersWindow.OrderGrid.Orders.AddRange(orders);
					Trader.NewStopOrders += orders => _stopOrderWindow.OrderGrid.Orders.AddRange(orders);
					Trader.OrdersRegisterFailed += fails => fails.ForEach(fail => this.GuiAsync(() => MessageBox.Show(this, fail.Error.Message, LocalizedStrings.Str2960)));
					Trader.OrdersCancelFailed += fails => fails.ForEach(fail => this.GuiAsync(() => MessageBox.Show(this, fail.Error.Message, LocalizedStrings.Str2981)));
					Trader.StopOrdersRegisterFailed += fails => fails.ForEach(fail => this.GuiAsync(() => MessageBox.Show(this, fail.Error.Message, LocalizedStrings.Str2960)));
					Trader.StopOrdersCancelFailed += fails => fails.ForEach(fail => this.GuiAsync(() => MessageBox.Show(this, fail.Error.Message, LocalizedStrings.Str2981)));
					Trader.NewPortfolios += portfolios => _portfoliosWindow.PortfolioGrid.Portfolios.AddRange(portfolios);
					Trader.NewPositions += positions => _portfoliosWindow.PortfolioGrid.Positions.AddRange(positions);

					// устанавливаем поставщик маркет-данных
					_securitiesWindow.SecurityPicker.MarketDataProvider = Trader;

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

				Trader.Connect();

				_isConnected = true;
				ConnectBtn.Content = LocalizedStrings.Disconnect;
			}
			else
			{
				Trader.Disconnect();

				_isConnected = false;
				ConnectBtn.Content = LocalizedStrings.Connect;
			}
		}
Ejemplo n.º 15
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.Error += OnError;
					quikTrader2.Error += 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));
					};
					quikTrader2.Connected += () =>
					{
						Console.WriteLine(LocalizedStrings.Str2994Params.Put(quikTrader2.LuaFixServerAddress));
					};

					// производим подключение каждого из 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);
			}
		}