Example #1
0
        //private static Strategy strategyHeader = new Strategy(1, "Sample strategyHeader", "ST46520-RF-01", "RIH4", 1);

        static void Main(string[] args)
        {
            AddStrategySettings();

/*
 *          TradingData.Instance.Get<ICollection<Strategy>>().Add(strategyHeader);
 *
 *          BarSettings barSettings = new BarSettings(strategyHeader, "RIH4", 3600, 3);
 *          TradingData.Instance.Get<ICollection<BarSettings>>().Add(barSettings);
 *
 *          BreakOutOnBar breakOnBar =
 *              new BreakOutOnBar(strategyHeader,
 *                  TradingData.Instance,
 *                  SignalQueue.Instance,
 *                  DefaultLogger.Instance);
 *
 *          StopLossOnBar stopLossOnBar =
 *              new StopLossOnBar(strategyHeader,
 *                  100,
 *                  TradingData.Instance,
 *                  SignalQueue.Instance,
 *                  DefaultLogger.Instance);
 */
            AddStrategyHandlers();

/*            TakeProfitOnBar takeProfitOnBar =
 *              new TakeProfitOnBar(strategyHeader,
 *                  100,
 *                  TradingData.Instance,
 *                  SignalQueue.Instance,
 *                  DefaultLogger.Instance);
 */
            AddStrategySubscriptions();

            adapter.Start();

/*            Transaction importBars =
 *              new ImportBarsTransaction(TradingData.Instance.Get<ObservableCollection<Bar>>(),
 *                  "bars.txt");
 *
 *          importBars.Execute();
 */
            while (true)
            {
                try
                {
                    string command = Console.ReadLine();

                    if (command == "stop")
                    {
                        adapter.Stop();
                        break;
                    }

                    if (command == "pnl")
                    {
                        Console.WriteLine(String.Format("Реализованный профит и лосс составляет {0} пунктов",
                                                        TradingData.Instance.GetProfitAndLossPoints(strategyHeader)));
                    }
                }
                catch (System.Runtime.InteropServices.COMException e)
                {
                    DefaultLogger.Instance.Log(e.Message);
                    //adapter.Restart();
                }
            }
        }
Example #2
0
        static void Main(string[] args)
        {
            try
            {
                Console.BufferHeight = 300;
                Console.BufferWidth  = 230;

                Console.WindowHeight = 90;
                Console.WindowWidth  = 110;

                Console.WindowTop  = 0;
                Console.WindowLeft = 0;
            }
            catch
            {
                Console.WriteLine(String.Format("Error Console.Window Size"));
            }

            Console.WriteLine(String.Format("Console.BufferHeight {0}", Console.BufferHeight));
            Console.WriteLine(String.Format("Console.BufferWidth {0}", Console.BufferWidth));
            Console.WriteLine(String.Format("Console.WindowHeight {0}", Console.WindowHeight));
            Console.WriteLine(String.Format("Console.WindowWidth {0}", Console.WindowWidth));
            Console.WriteLine(String.Format("Console.WindowTop {0}", Console.WindowTop));
            Console.WriteLine(String.Format("Console.WindowLeft {0}", Console.WindowLeft));

            LogAssemblyInfo();

            //AddStrategySettings();
            {
                TradingData.Instance.Get <ICollection <Strategy> >().Add(strategy);
                TradingData.Instance.Get <ICollection <BarSettings> >().Add(barSettings);
                TradingData.Instance.Get <ICollection <ProfitPointsSettings> >().Add(ppSettings);
                TradingData.Instance.Get <ICollection <TakeProfitOrderSettings> >().Add(poSettings);
                TradingData.Instance.Get <ICollection <StopPointsSettings> >().Add(spSettings);
                TradingData.Instance.Get <ICollection <StopLossOrderSettings> >().Add(soSettings);

                //SMASettings smaSettings = new SMASettings(strategy, 7, 14);
                int         maf         = AppSettings.GetValue <int>("MaFast");
                int         mas         = AppSettings.GetValue <int>("MaSlow");
                SMASettings smaSettings = new SMASettings(strategy, maf, mas);
                TradingData.Instance.Get <ICollection <SMASettings> >().Add(smaSettings);
            }

            ////stopLoss
            //StrategiesPlaceStopLossByPointsOnTradeHandlers stopLossOnTradeHandlers =
            //    new StrategiesPlaceStopLossByPointsOnTradeHandlers(TradingData.Instance,
            //        SignalQueue.Instance,
            //        DefaultLogger.Instance,
            //        AppSettings.GetValue<bool>("MeasureStopFromSignalPrice"));
            ////stopLoss
            //StrategiesStopLossByPointsOnTickHandlers stopLossOnTickHandlers =
            //    new StrategiesStopLossByPointsOnTickHandlers(TradingData.Instance,
            //        SignalQueue.Instance,
            //        DefaultLogger.Instance,
            //        AppSettings.GetValue<bool>("MeasureStopFromSignalPrice"));
            ////takeProfit
            //StrategiesPlaceTakeProfitByPointsOnTradeHandlers takeProfitOnTradeHandlers =
            //    new StrategiesPlaceTakeProfitByPointsOnTradeHandlers(TradingData.Instance,
            //        SignalQueue.Instance,
            //        DefaultLogger.Instance,
            //        AppSettings.GetValue<bool>("MeasureProfitFromSignalPrice"));
            ////takeProfit
            //StrategiesTakeProfitByPointsOnTickHandlers takeProfitOnTickHandlers =
            //    new StrategiesTakeProfitByPointsOnTickHandlers(TradingData.Instance,
            //        SignalQueue.Instance,
            //        DefaultLogger.Instance,
            //        AppSettings.GetValue<bool>("MeasureProfitFromSignalPrice"));

            SmartComHandlers.Instance.Add <_IStClient_DisconnectedEventHandler>(ScalperIsDisconnected);
            SmartComHandlers.Instance.Add <_IStClient_ConnectedEventHandler>(ScalperIsConnected);

            //BreakOutOnTick openHandler =
            //    new BreakOutOnTick(strategy,
            //        TradingData.Instance,
            //        SignalQueue.Instance,
            //        DefaultLogger.Instance);

            //ReversOnTick openHandler =
            //    new ReversOnTick(strategy,
            //        TradingData.Instance,
            //        SignalQueue.Instance,
            //        DefaultLogger.Instance);


            //UpdateBarsOnTick updateBarsHandler =
            //    new UpdateBarsOnTick(barSettings,
            //        new TimeTracker(),
            //        TradingData.Instance,
            //        DefaultLogger.Instance);

            MakeRangeBarsOnTick updateBarsHandler =
                new MakeRangeBarsOnTick(barSettings,
                                        new TimeTracker(),
                                        TradingData.Instance,
                                        DefaultLogger.Instance);

            //отправляем бар через signalR
            SendItemOnBar barItemSender =
                new SendItemOnBar(barSettings,
                                  TradingData.Instance);

            barItemSender.AddItemHandler(TradeHubStarter.sendBar);
            barItemSender.AddItemHandler(ConsoleWriteLineBar);

            ReversOnBar reversHandler =
                new ReversOnBar(strategy,
                                TradingData.Instance,
                                SignalQueue.Instance,
                                DefaultLogger.Instance);

            reversHandler.AddMa1Handler(TradeHubStarter.sendIndicator1);
            reversHandler.AddMa2Handler(TradeHubStarter.sendIndicator2);


            //отправляем бар через signalR
            SendItemOnTrade tradeItemSender =
                new SendItemOnTrade(TradingData.Instance, DefaultLogger.Instance);

            tradeItemSender.AddItemHandler(TradeHubStarter.sendTrade);

            //отправляем ордер через signalR
            //SendItemOnOrder senderItemOrder =
            //    new SendItemOnOrder(TradingData.Instance.Get<ObservableQueue<Order>>());
            //senderItemOrder.AddedItemHandler(TradeHubStarter.sendOrder);

            //список доступных команд
            ConsoleWriteCommands();

            //AddStrategySubscriptions();
            {
                DefaultSubscriber.Instance.Portfolios.Add(strategy.Portfolio);
                DefaultSubscriber.Instance.BidsAndAsks.Add(strategy.Symbol);
                DefaultSubscriber.Instance.Ticks.Add(strategy.Symbol);
            }

            TradeHubStarter tradeHubStarter = new TradeHubStarter();

            //StartServer();
            Task.Run(() => tradeHubStarter.StartServer());
            Console.WriteLine(String.Format("Starting server..."));

            if (AppSettings.GetValue <bool>("ConsoleReadKey"))
            {
                Console.WriteLine(String.Format("Press 's' to start..."));
                while (Console.ReadKey().KeyChar != 's')
                {
                    Console.WriteLine(String.Format("Press 's' to start..."));
                }
            }

            adapter.Start();

            while (true)
            {
                try
                {
                    string command = Console.ReadLine();

                    if (command == "x")
                    {
                        adapter.Stop();

                        ExportData <Order>(AppSettings.GetValue <bool>("ExportOrdersOnExit"));
                        ExportData <Trade>(AppSettings.GetValue <bool>("ExportTradesOnExit"));
                        ExportData <Bar>(AppSettings.GetValue <bool>("ExportBarsOnExit"));

                        break;
                    }

                    if (command == "p")
                    {
                        Console.Clear();

                        Console.WriteLine(String.Format("Реализованный профит и лосс составляет {0} пунктов",
                                                        TradingData.Instance.GetProfitAndLossPoints(strategy)));
                    }

                    if (command == "t")
                    {
                        Console.Clear();

                        foreach (Trade item in TradingData.Instance.Get <IEnumerable <Trade> >())
                        {
                            Console.WriteLine(item.ToString());
                        }
                    }

                    if (command == "b")
                    {
                        Console.Clear();
                        foreach (Bar item in TradingData.Instance.Get <IEnumerable <Bar> >().OrderBy(i => i.DateTime))
                        //foreach (Bar item in TradingData.Instance.Get<IEnumerable<Bar>>())
                        {
                            ConsoleWriteLineBar(item);
                            //TradeHubStarter.sendBarString(item);
                            TradeHubStarter.sendBar(item);
                        }
                    }
                    if (command == "c")
                    {
                        //Console.Clear();
                        Console.WriteLine("clearChart");
                        TradeHubStarter.clearChart();
                    }
                    if (command == "h")
                    {
                        Console.Clear();
                        ConsoleWriteCommands();
                    }

                    if (command == "d")
                    {
                        TradeHubStarter.ConsoleWriteTime = !TradeHubStarter.ConsoleWriteTime;
                        Console.WriteLine(String.Format("ConsoleWriteTime {0}",
                                                        TradeHubStarter.ConsoleWriteTime));
                    }
                }
                catch (System.Runtime.InteropServices.COMException e)
                {
                    DefaultLogger.Instance.Log(e.Message);

                    adapter.Restart();
                }
            }
            if (tradeHubStarter.SignalR != null)
            {
                tradeHubStarter.SignalR.Dispose();
            }
        }
Example #3
0
File: Proboy.cs Project: w1r2p1/TRx
        static void Main(string[] args)
        {
            LogAssemblyInfo();

            AddStrategySettings();

            StrategiesPlaceStopLossByPointsOnTradeHandlers stopLossOnTradeHandlers =
                new StrategiesPlaceStopLossByPointsOnTradeHandlers(TradingData.Instance,
                                                                   SignalQueue.Instance,
                                                                   DefaultLogger.Instance,
                                                                   AppSettings.GetValue <bool>("MeasureStopFromSignalPrice"));

            StrategiesStopLossByPointsOnTickHandlers stopLossOnTickHandlers =
                new StrategiesStopLossByPointsOnTickHandlers(TradingData.Instance,
                                                             SignalQueue.Instance,
                                                             DefaultLogger.Instance,
                                                             AppSettings.GetValue <bool>("MeasureStopFromSignalPrice"));

            StrategiesPlaceTakeProfitByPointsOnTradeHandlers takeProfitOnTradeHandlers =
                new StrategiesPlaceTakeProfitByPointsOnTradeHandlers(TradingData.Instance,
                                                                     SignalQueue.Instance,
                                                                     DefaultLogger.Instance,
                                                                     AppSettings.GetValue <bool>("MeasureProfitFromSignalPrice"));

            StrategiesTakeProfitByPointsOnTickHandlers takeProfitOnTickHandlers =
                new StrategiesTakeProfitByPointsOnTickHandlers(TradingData.Instance,
                                                               SignalQueue.Instance,
                                                               DefaultLogger.Instance,
                                                               AppSettings.GetValue <bool>("MeasureProfitFromSignalPrice"));

            SmartComHandlers.Instance.Add <_IStClient_DisconnectedEventHandler>(ScalperIsDisconnected);
            SmartComHandlers.Instance.Add <_IStClient_ConnectedEventHandler>(ScalperIsConnected);

            BreakOutOnTick openHandler =
                new BreakOutOnTick(strategyHeader,
                                   TradingData.Instance,
                                   SignalQueue.Instance,
                                   DefaultLogger.Instance);

            UpdateBarsOnTick updateBarsHandler =
                new UpdateBarsOnTick(barSettings,
                                     new TimeTracker(),
                                     TradingData.Instance,
                                     DefaultLogger.Instance);

            AddStrategySubscriptions();

            adapter.Start();

            while (true)
            {
                try
                {
                    string command = Console.ReadLine();

                    if (command == "x")
                    {
                        adapter.Stop();

                        ExportData <Order>(AppSettings.GetValue <bool>("ExportOrdersOnExit"));
                        ExportData <Trade>(AppSettings.GetValue <bool>("ExportTradesOnExit"));

                        break;
                    }

                    if (command == "p")
                    {
                        Console.Clear();

                        Console.WriteLine(String.Format("Реализованный профит и лосс составляет {0} пунктов",
                                                        TradingData.Instance.GetProfitAndLossPoints(strategyHeader)));
                    }

                    if (command == "t")
                    {
                        Console.Clear();

                        foreach (Trade item in TradingData.Instance.Get <IEnumerable <Trade> >())
                        {
                            Console.WriteLine(item.ToString());
                        }
                    }

                    if (command == "b")
                    {
                        Console.Clear();

                        foreach (Bar item in TradingData.Instance.Get <IEnumerable <Bar> >())
                        {
                            Console.WriteLine(item.ToString());
                        }
                    }
                }
                catch (System.Runtime.InteropServices.COMException e)
                {
                    DefaultLogger.Instance.Log(e.Message);

                    adapter.Restart();
                }
            }
        }