예제 #1
0
        /// <summary>
        /// Primary constructor
        /// </summary>
        public MarketRecorder(string u, string p)
        {
            m_username = u;
            m_password = p;

            OutputFolder = TA.DirectoryNames.GetDirectoryName(ext: "ttapiBidAsk") + TA.DirectoryNames.GetDirectoryExtension(DateTime.Now.Date);

            System.IO.Directory.CreateDirectory(OutputFolder);

            PriceFileDictionary = new Dictionary<string, StreamWriter>();
            FilteredList = new List<ttapiTicker>();

            DateTime referanceDate = DateTime.Today;
            EndTime = new DateTime(referanceDate.Year, referanceDate.Month, referanceDate.Day, 15, 45, 0); 


            ContractVolumeList = TA.LoadContractVolumeFile.GetContractVolumes(folderDate: BusinessDays.GetBusinessDayShifted(-1));
            FilteredList = ContractVolumeList.Where(x => x.Volume > 100).ToList().OfType<ttapiTicker>().ToList();

                for (int i = 0; i < FilteredList.Count;  i++)
                {
                    //Console.WriteLine(FilteredList[i].instrumentName);
                    PriceFileDictionary.Add(FilteredList[i].instrumentName, new StreamWriter(OutputFolder + "/" + FilteredList[i].instrumentName.Replace("/", "-").Replace(":", "-") + ".csv"));
                }

                TTAPISubs = new ttapiUtils.Subscription(m_username, m_password);
                TTAPISubs.TTAPITickerList = FilteredList;
                TTAPISubs.ilsUpdateList = new List<EventHandler<InstrumentLookupSubscriptionEventArgs>> { TTAPISubs.startPriceSubscriptions };
                TTAPISubs.asu_update = TTAPISubs.startInstrumentLookupSubscriptionsFromTTAPITickers;
                TTAPISubs.priceUpdatedEventHandler = m_ps_FieldsUpdated;

        }
예제 #2
0
        /// <summary>
        /// Primary constructor
        /// </summary>
        public MarketRecorder(string u, string p)
        {
            m_username = u;
            m_password = p;

            OutputFolder = TA.DirectoryNames.GetDirectoryName(ext: "ttapiBidAsk") + TA.DirectoryNames.GetDirectoryExtension(DateTime.Now.Date);

            System.IO.Directory.CreateDirectory(OutputFolder);

            PriceFileDictionary = new Dictionary <string, StreamWriter>();
            FilteredList        = new List <ttapiTicker>();

            DateTime referanceDate = DateTime.Today;

            EndTime = new DateTime(referanceDate.Year, referanceDate.Month, referanceDate.Day, 15, 45, 0);


            ContractVolumeList = TA.LoadContractVolumeFile.GetContractVolumes(folderDate: BusinessDays.GetBusinessDayShifted(-1));
            FilteredList       = ContractVolumeList.Where(x => x.Volume > 100).ToList().OfType <ttapiTicker>().ToList();

            string [] TickerHeadList = ContractUtilities.ContractMetaInfo.cmeFuturesTickerheadList.Union(ContractUtilities.ContractMetaInfo.iceFuturesTickerheadList).ToArray();

            LiquidContractList = new ContractUtilities.ContractList(TickerHeadList);
            //LiquidDbTickerList = LiquidContractList.dbTickerList;
            LiquidDbTickerList = new List <string>();

            for (int i = 0; i < FilteredList.Count; i++)
            {
                //Console.WriteLine(FilteredList[i].instrumentName);
                PriceFileDictionary.Add(FilteredList[i].instrumentName, new StreamWriter(OutputFolder + "/" + FilteredList[i].instrumentName.Replace("/", "-").Replace(":", "-") + ".csv"));
            }

            TTAPISubs = new ttapiUtils.Subscription(m_username, m_password);
            TTAPISubs.TTAPITickerList    = FilteredList;
            TTAPISubs.LiquidDbTickerList = LiquidDbTickerList;
            TTAPISubs.ilsUpdateList      = new List <EventHandler <InstrumentLookupSubscriptionEventArgs> > {
                TTAPISubs.startPriceSubscriptions
            };
            TTAPISubs.AsuUpdateList = new List <EventHandler <AuthenticationStatusUpdateEventArgs> > {
                TTAPISubs.startInstrumentLookupSubscriptionsFromTTAPITickers
            };
            TTAPISubs.priceUpdatedEventHandler = m_ps_FieldsUpdated;
        }
예제 #3
0
        public HedgeTTAPI(string u, string p)
        {
            m_username = u;
            m_password = p;

            PricesReceivedQ = false;

            connection = new mysql();
            conn       = connection.conn;

            UnderlyingTickerTable = Underlying.GetUnderlying2QueryTable(conn: conn);

            List <string> TickerHeadList = DataAnalysis.DataTableFunctions.GetColumnAsList <string>(dataTableInput: UnderlyingTickerTable, columnName: "TickerHead", uniqueQ: true);

            DateTo = CalendarUtilities.BusinessDays.GetBusinessDayShifted(shiftInDays: -1);
            DateTime TodayDate = DateTime.Now.Date;
            DateTime DateFrom  = CalendarUtilities.BusinessDays.GetBusinessDayShifted(shiftInDays: -10);

            DataTable HistoricPriceTable = GetPrice.GetFuturesPrice.getFuturesPrice4Ticker(tickerHeadList: TickerHeadList, dateTimeFrom: DateFrom, dateTimeTo: DateTo, conn: conn);

            SortedHistoricPriceTable = HistoricPriceTable.AsEnumerable()
                                       .OrderBy(r => r.Field <string>("ticker"))
                                       .ThenBy(r => r.Field <DateTime>("price_date"))
                                       .CopyToDataTable();

            TTAPISubs             = new ttapiUtils.Subscription(m_username, m_password);
            IlsDictionary         = TTAPISubs.IlsDictionary;
            TTAPISubs.TickerTable = UnderlyingTickerTable;
            ilsUpdateList         = new List <EventHandler <InstrumentLookupSubscriptionEventArgs> > {
                TTAPISubs.startPriceSubscriptions, TTAPISubs.startTradeSubscriptions
            };
            TTAPISubs.ilsUpdateList = ilsUpdateList;
            TTAPISubs.AsuUpdateList = new List <EventHandler <AuthenticationStatusUpdateEventArgs> > {
                TTAPISubs.startInstrumentLookupSubscriptionsFromDataTable, TTAPISubs.Subscribe2OrderFills
            };
            TTAPISubs.priceUpdatedEventHandler = GetBidAsk;
            TTAPISubs.FillAddedEventHandler    = OrderFilledEventHandler;

            PriceData = new DataTable();
            PriceData.Columns.Add("Ticker", typeof(string));
            PriceData.Columns.Add("TickerHead", typeof(string));
            PriceData.Columns.Add("TickerClass", typeof(string));
            PriceData.Columns.Add("ContINDX", typeof(int));
            PriceData.Columns.Add("IsSpreadQ", typeof(bool));

            PriceData.Columns.Add("BidPrice", typeof(decimal));
            PriceData.Columns.Add("AskPrice", typeof(decimal));
            PriceData.Columns.Add("MidPrice", typeof(decimal));
            PriceData.Columns.Add("SpreadCost", typeof(decimal));

            foreach (DataRow item in UnderlyingTickerTable.Rows)
            {
                DataRow Row = PriceData.NewRow();
                Row["Ticker"]      = item.Field <string>("Ticker");
                Row["TickerHead"]  = item.Field <string>("TickerHead");
                Row["TickerClass"] = item.Field <string>("TickerClass");
                Row["ContINDX"]    = item.Field <int>("ContINDX");
                Row["IsSpreadQ"]   = item.Field <bool>("IsSpreadQ");
                PriceData.Rows.Add(Row);
            }

            PriceData            = DataAnalysis.DataTableFunctions.Sort(dataTableInput: PriceData, columnList: new string[] { "TickerHead", "ContINDX" });
            UnderlyingTickerList = DataAnalysis.DataTableFunctions.GetColumnAsList <string>(dataTableInput: PriceData, columnName: "Ticker", uniqueQ: true);

            string       OutputFolder = TA.DirectoryNames.GetDirectoryName("daily");
            StreamWriter LogFile      = new StreamWriter(OutputFolder + "/Delta.txt", true);

            DeltaLogger = new Logger(LogFile);

            DeltaLogger.SW.WriteLine();
            DeltaLogger.Log("NOTES FOR " + TodayDate.ToString("MM/dd/yyyy"));
            DeltaLogger.Log(new String('-', 20));

            DeltaStrategyAlias = HedgeStrategies.GetActiveDeltaStrategy(conn: conn);
        }
        public FuturesButterflyTTAPI(string u, string p)
        {
            m_username = u;
            m_password = p;

            mysql connection = new mysql();

            conn = connection.conn;

            string       OutputFolder = TA.DirectoryNames.GetDirectoryName("daily");
            StreamWriter LogFile      = new StreamWriter(OutputFolder + "/FuturesButterfly.txt", true);

            ButterflyLogger = new Logger(LogFile);

            AutoSpreaderList             = new List <ttapiUtils.AutoSpreader>();
            AutoSpreaderDictionary       = new Dictionary <string, ttapiUtils.AutoSpreader>();
            Alias2AutoSpreaderDictionary = new Dictionary <string, string>();
            TagDictionary = new Dictionary <string, string>();
            LogTime1      = DateTime.MinValue;

            PriceTableSymbolsReceived  = new List <string>();
            StrategyPositionDictionary = new Dictionary <string, DataTable>();

            TTAPISubs  = new ttapiUtils.Subscription(m_username, m_password);
            SpreadList = new List <string>();

            DateTime ReportDate = CalendarUtilities.BusinessDays.GetBusinessDayShifted(shiftInDays: -1);
            DateTime TodayDate  = DateTime.Now.Date;



            ButterflyLogger.SW.WriteLine();
            ButterflyLogger.Log("NOTES FOR " + TodayDate.ToString("MM/dd/yyyy"));
            ButterflyLogger.Log(new String('-', 20));

            string DirectoryName = TA.DirectoryNames.GetDirectoryName(ext: "ta");
            string ButterflyOutputDirectoryName = TA.DirectoryNames.GetDirectoryName(ext: "futuresButterflyOutput");
            string DirectoryExtension           = TA.DirectoryNames.GetDirectoryExtension(directoryDate: ReportDate);

            DataSet   FollowupOutput           = IOUtilities.ExcelDataReader.LoadFile(DirectoryName + "/" + DirectoryExtension + "/followup.xlsx");
            DataTable ButterfliesFollowupSheet = FollowupOutput.Tables["butterflies"];

            DataSet   ButterfliesOutput = IOUtilities.ExcelDataReader.LoadFile(ButterflyOutputDirectoryName + "/" + DirectoryExtension + "/butterflies.xlsx");
            DataTable ButterfliesSheet  = ButterfliesOutput.Tables["good"];

            PeriodicTimer          = new System.Timers.Timer();
            PeriodicTimer.Elapsed += new ElapsedEventHandler(PeriodicCall);
            PeriodicTimer.Interval = 30000;
            // And start it
            PeriodicTimer.Enabled = true;



            DataColumn SizeColumn = new DataColumn("Size", typeof(double));

            SizeColumn.DefaultValue = 0;
            ButterfliesSheet.Columns.Add(SizeColumn);

            ButterfliesSheet.Columns.Add("Theme", typeof(string));

            DataColumn ExistingThemePositionColumn = new DataColumn("ExistingThemePosition", typeof(double));

            ExistingThemePositionColumn.DefaultValue = 0;
            ButterfliesSheet.Columns.Add(ExistingThemePositionColumn);

            ButterfliesSheet.Columns.Add("SlackFromTheme", typeof(double));



            for (int i = 0; i < ButterfliesFollowupSheet.Rows.Count; i++)
            {
                StrategyUtilities.PositionManagerOutput PositionManagerOut = PositionManager.GetFuturesButterflyPosition(alias: ButterfliesFollowupSheet.Rows[i].Field <string>("Alias"),
                                                                                                                         asOfDate: TodayDate, conn: conn);
                if (PositionManagerOut.CorrectPositionQ)
                {
                    StrategyPositionDictionary.Add(ButterfliesFollowupSheet.Rows[i].Field <string>("Alias"), PositionManagerOut.SortedPosition);
                }
            }


            DataTable ButterfliesFollowupSheetAdjusted = RiskManager.CalculateAdjustedDownside(dataTableInput: ButterfliesFollowupSheet, newTradesTable: ButterfliesSheet,
                                                                                               strategyPositionDictionary: StrategyPositionDictionary);

            DataTable RiskAcrossTickerhead = RiskManager.AggregateRiskAcrossTickerHead(dataTableInput: ButterfliesFollowupSheetAdjusted);

            Dictionary <string, double> RiskAcrossTheme = RiskManager.GetRiskAcrossTheme(dataTableInput: ButterfliesFollowupSheetAdjusted,
                                                                                         strategyPositionDictionary: StrategyPositionDictionary);



            ButterfliesSheetFiltered = Filtering.GetFilteredNewTrades(butterfliesSheet: ButterfliesSheet, riskAcrossTickerhead: RiskAcrossTickerhead, riskAcrossTheme: RiskAcrossTheme);

            DataColumn ButterflyQuantityColumn = new DataColumn("ButterflyQuantity", typeof(int));

            ButterflyQuantityColumn.DefaultValue = 0;
            ButterfliesSheetFiltered.Columns.Add(ButterflyQuantityColumn);

            DataColumn Spread1QuantityColumn = new DataColumn("Spread1Quantity", typeof(int));

            Spread1QuantityColumn.DefaultValue = 0;
            ButterfliesSheetFiltered.Columns.Add(Spread1QuantityColumn);

            DataColumn Spread2QuantityColumn = new DataColumn("Spread2Quantity", typeof(int));

            Spread2QuantityColumn.DefaultValue = 0;
            ButterfliesSheetFiltered.Columns.Add(Spread2QuantityColumn);

            ButterfliesSheetFiltered.Columns.Add("Alias", typeof(string));

            PriceTable = new DataTable();
            PriceTable.Columns.Add("Ticker", typeof(string));
            PriceTable.Columns.Add("TickerHead", typeof(string));
            PriceTable.Columns.Add("IsAutoSpreaderQ", typeof(bool));

            DataColumn BidPriceColumn = new DataColumn("BidPrice", typeof(double));

            BidPriceColumn.DefaultValue = Double.NaN;
            PriceTable.Columns.Add(BidPriceColumn);

            DataColumn AskPriceColumn = new DataColumn("AskPrice", typeof(double));

            AskPriceColumn.DefaultValue = Double.NaN;
            PriceTable.Columns.Add(AskPriceColumn);

            PriceTable.Columns.Add("BidQ", typeof(int));
            PriceTable.Columns.Add("AskQ", typeof(int));



            DataColumn ValidPriceColumn = new DataColumn("ValidPriceQ", typeof(bool));

            ValidPriceColumn.DefaultValue = false;
            PriceTable.Columns.Add(ValidPriceColumn);

            for (int i = 0; i < ButterfliesSheetFiltered.Rows.Count; i++)
            {
                DataRow SelectedRow = ButterfliesSheetFiltered.Rows[i];
                string  Alias       = "";
                string  Ticker1     = SelectedRow.Field <string>("ticker1");
                string  Ticker2     = SelectedRow.Field <string>("ticker2");
                string  Ticker3     = SelectedRow.Field <string>("ticker3");


                if (SelectedRow.Field <double>("z1") < 0)
                {
                    double FirstSpreadQuantity  = Math.Round(SelectedRow.Field <double>("Size") / Math.Abs(SelectedRow.Field <double>("Downside")));
                    double SecondSpreadQuantity = Math.Round(FirstSpreadQuantity * SelectedRow.Field <double>("second_spread_weight_1"));

                    if (FirstSpreadQuantity < SecondSpreadQuantity)
                    {
                        SelectedRow["ButterflyQuantity"] = (int)FirstSpreadQuantity;
                        SelectedRow["Spread2Quantity"]   = -(int)(SecondSpreadQuantity - FirstSpreadQuantity);
                    }
                    else if (FirstSpreadQuantity > SecondSpreadQuantity)
                    {
                        SelectedRow["ButterflyQuantity"] = (int)SecondSpreadQuantity;
                        SelectedRow["Spread1Quantity"]   = (int)(FirstSpreadQuantity - SecondSpreadQuantity);
                    }

                    else
                    {
                        ButterfliesSheetFiltered.Rows[i]["ButterflyQuantity"] = (int)FirstSpreadQuantity;
                    }

                    Alias = SelectedRow.Field <string>("tickerHead") + Ticker1.Substring(Ticker1.Count() - 5, 5) + Ticker2.Substring(Ticker2.Count() - 5, 5) +
                            Ticker2.Substring(Ticker2.Count() - 5, 5) + Ticker3.Substring(Ticker3.Count() - 5, 5);
                }
                else if (ButterfliesSheetFiltered.Rows[i].Field <double>("z1") > 0)
                {
                    double FirstSpreadQuantity  = Math.Round(ButterfliesSheetFiltered.Rows[i].Field <double>("Size") / Math.Abs(ButterfliesSheetFiltered.Rows[i].Field <double>("Upside")));
                    double SecondSpreadQuantity = Math.Round(FirstSpreadQuantity * ButterfliesSheetFiltered.Rows[i].Field <double>("second_spread_weight_1"));

                    if (FirstSpreadQuantity < SecondSpreadQuantity)
                    {
                        SelectedRow["ButterflyQuantity"] = -(int)FirstSpreadQuantity;
                        SelectedRow["Spread2Quantity"]   = (int)(SecondSpreadQuantity - FirstSpreadQuantity);
                    }
                    else if (FirstSpreadQuantity > SecondSpreadQuantity)
                    {
                        SelectedRow["ButterflyQuantity"] = -(int)SecondSpreadQuantity;
                        SelectedRow["Spread1Quantity"]   = -(int)(FirstSpreadQuantity - SecondSpreadQuantity);
                    }

                    else
                    {
                        SelectedRow["ButterflyQuantity"] = (int)FirstSpreadQuantity;
                    }

                    Alias = SelectedRow.Field <string>("tickerHead") + Ticker2.Substring(Ticker2.Count() - 5, 5) + Ticker3.Substring(Ticker3.Count() - 5, 5) +
                            Ticker1.Substring(Ticker1.Count() - 5, 5) + Ticker2.Substring(Ticker2.Count() - 5, 5);
                }

                SelectedRow["Alias"] = Alias;

                List <string> TickerList = new List <string> {
                    Ticker1 + "-" + Ticker2,
                    Ticker2 + "-" + Ticker3
                };

                ttapiUtils.AutoSpreader As = new ttapiUtils.AutoSpreader(dbTickerList: TickerList, payUpTicks: 2);

                SpreadList.AddRange(TickerList);
                AutoSpreaderList.Add(As);
                AutoSpreaderDictionary.Add(As.AutoSpreaderName, As);
                Alias2AutoSpreaderDictionary.Add(Alias, As.AutoSpreaderName);
                TagDictionary.Add(As.AutoSpreaderName, "fut_but_fol_" + i);

                DataRow PriceRow = PriceTable.NewRow();
                PriceRow["Ticker"]          = As.AutoSpreaderName;
                PriceRow["TickerHead"]      = SelectedRow.Field <string>("tickerHead");
                PriceRow["IsAutoSpreaderQ"] = true;
                PriceTable.Rows.Add(PriceRow);
            }



            HistoricPriceTable = GetPrice.GetFuturesPrice.getFuturesPrice4Ticker(tickerHeadList: ContractUtilities.ContractMetaInfo.FuturesButterflyTickerheadList,
                                                                                 dateTimeFrom: ReportDate, dateTimeTo: ReportDate, conn: conn);

            DataRow [] StopList = ButterfliesFollowupSheet.Select("Recommendation='STOP'");

            if (StopList.Length > 0)
            {
                ButterfliesStopSheet = StopList.CopyToDataTable();
                ButterfliesStopSheet.Columns.Add("PnlMid", typeof(double));
                ButterfliesStopSheet.Columns.Add("PnlWorst", typeof(double));
                ButterfliesStopSheet.Columns.Add("ButterflyMidPrice", typeof(double));
                ButterfliesStopSheet.Columns.Add("ButterflyWorstPrice", typeof(double));
                ButterfliesStopSheet.Columns.Add("ButterflyQuantity", typeof(int));
                ButterfliesStopSheet.Columns.Add("SpreadMidPrice", typeof(double));
                ButterfliesStopSheet.Columns.Add("SpreadWorstPrice", typeof(double));
                ButterfliesStopSheet.Columns.Add("SpreadQuantity", typeof(int));

                DataColumn WorkingButterflyOrdersColumn = new DataColumn("WorkingButterflyOrders", typeof(int));
                WorkingButterflyOrdersColumn.DefaultValue = 0;
                ButterfliesStopSheet.Columns.Add(WorkingButterflyOrdersColumn);

                DataColumn WorkingSpreadOrdersColumn = new DataColumn("WorkingSpreadOrders", typeof(int));
                WorkingSpreadOrdersColumn.DefaultValue = 0;
                ButterfliesStopSheet.Columns.Add(WorkingSpreadOrdersColumn);

                for (int i = 0; i < StopList.Length; i++)
                {
                    string Alias = StopList[i].Field <string>("Alias");
                    StrategyUtilities.PositionManagerOutput PositionManagerOut = PositionManager.GetFuturesButterflyPosition(alias: Alias, asOfDate: TodayDate, conn: conn);
                    DataTable StrategyPosition = PositionManagerOut.SortedPosition;

                    StrategyPosition.Columns.Add("ClosePrice", typeof(double));

                    for (int j = 0; j < StrategyPosition.Rows.Count; j++)
                    {
                        DataRow SelectedHistRow = HistoricPriceTable.Select("ticker='" + StrategyPosition.Rows[j].Field <string>("Ticker") + "'")[0];
                        StrategyPosition.Rows[j]["ClosePrice"] = SelectedHistRow.Field <decimal>("close_price");
                    }


                    List <string> TickerList = new List <string> {
                        StrategyPosition.Rows[0].Field <string>("Ticker") + "-" + StrategyPosition.Rows[1].Field <string>("Ticker"),
                        StrategyPosition.Rows[1].Field <string>("Ticker") + "-" + StrategyPosition.Rows[2].Field <string>("Ticker")
                    };
                    StrategyPositionDictionary[Alias] = StrategyPosition;

                    SpreadList.AddRange(TickerList);

                    if (PositionManagerOut.CorrectPositionQ)
                    {
                        ttapiUtils.AutoSpreader As = new ttapiUtils.AutoSpreader(dbTickerList: TickerList, payUpTicks: 2);

                        AutoSpreaderList.Add(As);
                        AutoSpreaderDictionary.Add(As.AutoSpreaderName, As);
                        Alias2AutoSpreaderDictionary.Add(Alias, As.AutoSpreaderName);
                        TagDictionary.Add(As.AutoSpreaderName, "fut_but_fol_" + (i + ButterfliesSheetFiltered.Rows.Count));


                        DataRow PriceRow = PriceTable.NewRow();
                        PriceRow["Ticker"]          = As.AutoSpreaderName;
                        PriceRow["TickerHead"]      = StrategyPosition.Rows[0].Field <string>("TickerHead");
                        PriceRow["IsAutoSpreaderQ"] = true;
                        PriceTable.Rows.Add(PriceRow);
                    }
                    else
                    {
                        ButterflyLogger.Log("Check " + Alias + " ! Position may be incorrect.");
                    }
                }


                SpreadList = SpreadList.Distinct().ToList();

                SpreadTable = new DataTable();
                SpreadTable.Columns.Add("Ticker", typeof(string));
                SpreadTable.Columns.Add("IsSpreadQ", typeof(bool));

                for (int i = 0; i < SpreadList.Count; i++)
                {
                    DataRow SpreadRow = SpreadTable.NewRow();
                    SpreadRow["Ticker"]    = SpreadList[i];
                    SpreadRow["IsSpreadQ"] = true;
                    SpreadTable.Rows.Add(SpreadRow);

                    DataRow PriceRow = PriceTable.NewRow();
                    PriceRow["Ticker"] = SpreadList[i];
                    string[] SpreadAsArray = SpreadList[i].Split(new char[] { '-' });
                    PriceRow["TickerHead"]      = ContractUtilities.ContractMetaInfo.GetContractSpecs(SpreadAsArray[0]).tickerHead;
                    PriceRow["IsAutoSpreaderQ"] = false;
                    PriceTable.Rows.Add(PriceRow);
                }
            }



            PriceTableSymbols = DataAnalysis.DataTableFunctions.GetColumnAsList <string>(dataTableInput: PriceTable, columnName: "Ticker");


            TTAPISubs.TickerTable      = SpreadTable;
            TTAPISubs.AutoSpreaderList = AutoSpreaderList;
            TTAPISubs.AsuUpdateList    = new List <EventHandler <AuthenticationStatusUpdateEventArgs> > {
                TTAPISubs.StartASESubscriptions, TTAPISubs.startInstrumentLookupSubscriptionsFromDataTable
            };
            //TTAPISubs.AsuUpdateList = new List<EventHandler<AuthenticationStatusUpdateEventArgs>> {TTAPISubs.startInstrumentLookupSubscriptionsFromDataTable };
            TTAPISubs.ilsUpdateList = new List <EventHandler <InstrumentLookupSubscriptionEventArgs> > {
                TTAPISubs.startPriceSubscriptions, TTAPISubs.startTradeSubscriptions
            };
            //TTAPISubs.ilsUpdateList = new List<EventHandler<InstrumentLookupSubscriptionEventArgs>> { TTAPISubs.startPriceSubscriptions};
            TTAPISubs.priceUpdatedEventHandler = m_ps_FieldsUpdated;
            TTAPISubs.orderFilledEventHandler  = m_ts_OrderFilled;
        }
예제 #5
0
        public Algo(string u, string p)
        {
            m_username = u;
            m_password = p;

            connection = new mysql();
            conn       = connection.conn;

            InstrumentArray = ContractUtilities.ContractMetaInfo.cmeFuturesTickerheadList.Union(ContractUtilities.ContractMetaInfo.iceFuturesTickerheadList).ToArray();

            List <string> InstrumentList = new List <string>(InstrumentArray);

            InstrumentList.Remove("ED");
            InstrumentList.Remove("TU");
            InstrumentArray = InstrumentList.ToArray();

            InstrumentArray = new string[] { "BP" };

            LiquidContractList = new ContractUtilities.ContractList(InstrumentArray);
            DbTickerList       = LiquidContractList.dbTickerList;

            ScalperPosition = new Portfolio.Position(fullTickerList: DbTickerList);

            string OutputFolder = TA.DirectoryNames.GetDirectoryName("daily");

            ITSLogger = new Logger(new StreamWriter(OutputFolder + "/TS.txt", true));

            TradeTimer          = new System.Timers.Timer();
            TradeTimer.Elapsed += new ElapsedEventHandler(PeriodicCall);
            TradeTimer.Interval = 10000;
            // And start it
            TradeTimer.Enabled = true;

            DateTime ReferanceDate = DateTime.Today;

            ITSLogger.Log("NOTES FOR " + ReferanceDate.ToString("MM/dd/yyyy"));
            ITSLogger.Log(new String('-', 20));

            MinInterval = 1;   //30
            MaxNumBets  = 5;
            NumBets     = 0;

            StartTime = new DateTime(ReferanceDate.Year, ReferanceDate.Month, ReferanceDate.Day, 8, 30, 0);  //830
            EndTime   = new DateTime(ReferanceDate.Year, ReferanceDate.Month, ReferanceDate.Day, 16, 0, 0);  //900

            MorningRangeStartTime   = StartTime;
            MorningRangeEndTime     = new DateTime(ReferanceDate.Year, ReferanceDate.Month, ReferanceDate.Day, 9, 0, 0);
            MorningRangeCalculatedQ = false;

            MorningMinDictionary      = new Dictionary <string, double>();
            MorningMaxDictionary      = new Dictionary <string, double>();
            WorkingLongEntryOrderKey  = new Dictionary <string, string>();
            WorkingLongExitOrderKey   = new Dictionary <string, string>();
            WorkingShortEntryOrderKey = new Dictionary <string, string>();
            WorkingShortExitOrderKey  = new Dictionary <string, string>();
            BidPriceDictionary        = new Dictionary <string, double>();
            AskPriceDictionary        = new Dictionary <string, double>();

            for (int i = 0; i < DbTickerList.Count; i++)
            {
                BidPriceDictionary.Add(DbTickerList[i], double.NaN);
                AskPriceDictionary.Add(DbTickerList[i], double.NaN);

                WorkingLongEntryOrderKey.Add(DbTickerList[i], "");
                WorkingLongExitOrderKey.Add(DbTickerList[i], "");
                WorkingShortEntryOrderKey.Add(DbTickerList[i], "");
                WorkingShortExitOrderKey.Add(DbTickerList[i], "");
            }

            LastProcessedCandleDatetime = StartTime;

            candleObj  = new DataAnalysis.CandleStick(StartTime, EndTime, DbTickerList.ToArray(), MinInterval);
            CandleData = candleObj.data;

            StochasticObj = new TechnicalSignals.StochasticOscillator(startDate: StartTime.AddMinutes(MinInterval), endDate: EndTime, instrumentList: DbTickerList.ToArray(),
                                                                      minInterval: MinInterval, lookBack1: 5, lookBack2: 3, lookBack3: 3);
            StochasticOscillator = StochasticObj.Data;

            TTAPISubs = new ttapiUtils.Subscription(m_username, m_password);

            List <EventHandler <InstrumentLookupSubscriptionEventArgs> > IlsUpdateList = new List <EventHandler <InstrumentLookupSubscriptionEventArgs> >();

            IlsUpdateList.Add(TTAPISubs.startPriceSubscriptions);
            IlsUpdateList.Add(TTAPISubs.startTradeSubscriptions);

            TTAPISubs.ilsUpdateList            = IlsUpdateList;
            TTAPISubs.dbTickerList             = DbTickerList;
            TTAPISubs.priceUpdatedEventHandler = m_ps_FieldsUpdated;
            TTAPISubs.orderFilledEventHandler  = OrderFilledLogic;
            TTAPISubs.AsuUpdateList            = new List <EventHandler <AuthenticationStatusUpdateEventArgs> > {
                TTAPISubs.startInstrumentLookupSubscriptions
            };
        }
        public FuturesButterflyTTAPI(string u, string p)
        {

            m_username = u;
            m_password = p;

            mysql connection = new mysql();
            conn = connection.conn;

            string OutputFolder = TA.DirectoryNames.GetDirectoryName("daily");
            StreamWriter LogFile = new StreamWriter(OutputFolder + "/FuturesButterfly.txt", true);
            ButterflyLogger = new Logger(LogFile);

            AutoSpreaderList = new List<ttapiUtils.AutoSpreader>();
            AutoSpreaderDictionary = new Dictionary<string, ttapiUtils.AutoSpreader>();
            AliasDictionary = new Dictionary<string, string>();
            TagDictionary = new Dictionary<string, string>();

            PriceTableSymbolsReceived = new List<string>();
            StrategyPositionDictionary = new Dictionary<string, DataTable>();

            TTAPISubs = new ttapiUtils.Subscription(m_username, m_password);
            SpreadList = new List<string>();

            DateTime ReportDate = CalendarUtilities.BusinessDays.GetBusinessDayShifted(shiftInDays: -1);
            DateTime TodayDate = DateTime.Now.Date;

            ButterflyLogger.SW.WriteLine();
            ButterflyLogger.Log("NOTES FOR " + TodayDate.ToString("MM/dd/yyyy"));
            ButterflyLogger.Log(new String('-', 20));

            string DirectoryName = TA.DirectoryNames.GetDirectoryName(ext: "ta");
            string DirectoryExtension = TA.DirectoryNames.GetDirectoryExtension(directoryDate: ReportDate);

            DataSet FollowupOutput = IOUtilities.ExcelDataReader.LoadFile(DirectoryName + "/" + DirectoryExtension + "/followup.xlsx");
            DataTable ButterfliesFollowupSheet = FollowupOutput.Tables["butterflies"];

            PriceTable = new DataTable();
            PriceTable.Columns.Add("Ticker", typeof(string));
            PriceTable.Columns.Add("TickerHead", typeof(string));
            PriceTable.Columns.Add("IsAutoSpreaderQ", typeof(bool));
            PriceTable.Columns.Add("BidPrice", typeof(double));
            PriceTable.Columns.Add("AskPrice", typeof(double));

            HistoricPriceTable = GetPrice.GetFuturesPrice.getFuturesPrice4Ticker(tickerHeadList: ContractUtilities.ContractMetaInfo.FuturesButterflyTickerheadList, 
                dateTimeFrom: ReportDate, dateTimeTo: ReportDate, conn: conn);

            DataRow [] StopList = ButterfliesFollowupSheet.Select("Recommendation='STOP'");

            if (StopList.Length>0)
            {
                ButterfliesStopSheet = StopList.CopyToDataTable();
                ButterfliesStopSheet.Columns.Add("PnlMid",typeof(double));
                ButterfliesStopSheet.Columns.Add("PnlWorst", typeof(double));

                for (int i = 0; i < StopList.Length; i++)
                {
                    string Alias = StopList[i].Field<string>("Alias");
                    StrategyUtilities.PositionManagerOutput PositionManagerOut = PositionManager.GetFuturesButterflyPosition(alias: Alias, asOfDate: TodayDate, conn: conn);
                    DataTable StrategyPosition = PositionManagerOut.SortedPosition;

                    StrategyPosition.Columns.Add("ClosePrice", typeof(double));

                    for (int j = 0; j < StrategyPosition.Rows.Count; j++)
                    {
                        DataRow SelectedHistRow = HistoricPriceTable.Select("ticker='" + StrategyPosition.Rows[j].Field<string>("Ticker") + "'")[0];
                        StrategyPosition.Rows[j]["ClosePrice"] = SelectedHistRow.Field<decimal>("close_price");
                    }


                    List<string> TickerList = new List<string> { StrategyPosition.Rows[0].Field<string>("Ticker") + "-" + StrategyPosition.Rows[1].Field<string>("Ticker"),
                                                             StrategyPosition.Rows[1].Field<string>("Ticker") + "-" + StrategyPosition.Rows[2].Field<string>("Ticker")};
                    StrategyPositionDictionary.Add(Alias, StrategyPosition);

                    SpreadList.AddRange(TickerList);

                    if (PositionManagerOut.CorrectPositionQ)
                    {
                        bool wuhu = TickerList[0].Contains("-");
                        string[] TickerListAux = TickerList[0].Split('-');

                        ttapiUtils.AutoSpreader As = new ttapiUtils.AutoSpreader(dbTickerList: TickerList, payUpTicks: 2);

                        AutoSpreaderList.Add(As);
                        AutoSpreaderDictionary.Add(As.AutoSpreaderName, As);
                        AliasDictionary.Add(As.AutoSpreaderName, Alias);
                        TagDictionary.Add(As.AutoSpreaderName, "fut_but_fol" + i);


                        DataRow PriceRow = PriceTable.NewRow();
                        PriceRow["Ticker"] = As.AutoSpreaderName;
                        PriceRow["TickerHead"] = StrategyPosition.Rows[0].Field<string>("TickerHead");
                        PriceRow["IsAutoSpreaderQ"] = true;
                        PriceTable.Rows.Add(PriceRow);

                    }
                    else
                    {
                        ButterflyLogger.Log("Check " + Alias + " ! Position may be incorrect.");
                    }
                }


                SpreadList = SpreadList.Distinct().ToList();

                SpreadTable = new DataTable();
                SpreadTable.Columns.Add("Ticker", typeof(string));
                SpreadTable.Columns.Add("IsSpreadQ", typeof(bool));

                for (int i = 0; i < SpreadList.Count; i++)
                {
                    DataRow SpreadRow = SpreadTable.NewRow();
                    SpreadRow["Ticker"] = SpreadList[i];
                    SpreadRow["IsSpreadQ"] = true;
                    SpreadTable.Rows.Add(SpreadRow);

                    DataRow PriceRow = PriceTable.NewRow();
                    PriceRow["Ticker"] = SpreadList[i];
                    string[] SpreadAsArray = SpreadList[i].Split(new char[] { '-' });
                    PriceRow["TickerHead"] = ContractUtilities.ContractMetaInfo.GetContractSpecs(SpreadAsArray[0]).tickerHead;
                    PriceRow["IsAutoSpreaderQ"] = false;
                    PriceTable.Rows.Add(PriceRow);
                }
    
            }

            

            

            PriceTableSymbols = DataAnalysis.DataTableFunctions.GetColumnAsList<string>(dataTableInput: PriceTable, columnName: "Ticker");


            TTAPISubs.TickerTable = SpreadTable;
            TTAPISubs.AutoSpreaderList = AutoSpreaderList;
            TTAPISubs.AsuUpdateList = new List<EventHandler<AuthenticationStatusUpdateEventArgs>> { TTAPISubs.StartASESubscriptions,TTAPISubs.startInstrumentLookupSubscriptionsFromDataTable };
            //TTAPISubs.AsuUpdateList = new List<EventHandler<AuthenticationStatusUpdateEventArgs>> {TTAPISubs.startInstrumentLookupSubscriptionsFromDataTable };
            TTAPISubs.ilsUpdateList = new List<EventHandler<InstrumentLookupSubscriptionEventArgs>> { TTAPISubs.startPriceSubscriptions, TTAPISubs.startTradeSubscriptions };
            //TTAPISubs.ilsUpdateList = new List<EventHandler<InstrumentLookupSubscriptionEventArgs>> { TTAPISubs.startPriceSubscriptions};
            TTAPISubs.priceUpdatedEventHandler = m_ps_FieldsUpdated;
            TTAPISubs.orderFilledEventHandler = m_ts_OrderFilled;

        }
예제 #7
0
        public Algo(string u, string p)
        {
            m_username = u;
            m_password = p;

            mysql connection = new mysql();

            conn = connection.conn;

            string       OutputFolder = TA.DirectoryNames.GetDirectoryName("daily");
            StreamWriter LogFile      = new StreamWriter(OutputFolder + "/IFS2.txt", true);

            IFSLogger = new Logger(LogFile);

            DateTime ReportDate = CalendarUtilities.BusinessDays.GetBusinessDayShifted(shiftInDays: -1);

            TodayDate = DateTime.Now.Date;

            DateTime startDate = DateTime.Now;

            DateTime StartTime = new DateTime(TodayDate.Year, TodayDate.Month, TodayDate.Day, 8, 30, 0);
            DateTime EndTime   = new DateTime(TodayDate.Year, TodayDate.Month, TodayDate.Day, 15, 0, 0);

            int minInterval = 1;

            IFSLogger.SW.WriteLine();
            IFSLogger.Log("NOTES FOR " + TodayDate.ToString("MM/dd/yyyy"));
            IFSLogger.Log(new String('-', 20));

            string DirectoryName      = TA.DirectoryNames.GetDirectoryName(ext: "ifsOutput");
            string DirectoryExtension = TA.DirectoryNames.GetDirectoryExtension(directoryDate: ReportDate);


            MyTimer          = new System.Timers.Timer();
            MyTimer.Elapsed += new ElapsedEventHandler(PeriodicCall);
            MyTimer.Interval = 30000;
            // And start it
            MyTimer.Enabled = true;

            DataSet   PythonOutput = IOUtilities.ExcelDataReader.LoadFile(DirectoryName + "/" + DirectoryExtension + "/ifs.xlsx");
            DataTable IfsSheet     = PythonOutput.Tables["all"];

            AutoSpreaderList       = new List <ttapiUtils.AutoSpreader>();
            AutoSpreaderDictionary = new Dictionary <string, ttapiUtils.AutoSpreader>();

            SummaryTable = new DataTable();
            SummaryTable.Columns.Add("Ticker", typeof(string));
            SummaryTable.Columns.Add("TickerHead", typeof(string));
            SummaryTable.Columns.Add("Bid", typeof(double));
            SummaryTable.Columns.Add("Ask", typeof(double));
            SummaryTable.Columns.Add("Mid", typeof(double));
            SummaryTable.Columns.Add("MidConverted", typeof(double));
            SummaryTable.Columns.Add("Tag", typeof(string));
            SummaryTable.Columns.Add("Alias", typeof(string));
            SummaryTable.Columns.Add("DescriptionString", typeof(string));

            DataColumn ValidPriceColumn = new DataColumn("ValidPrice", typeof(bool));

            ValidPriceColumn.DefaultValue = false;
            SummaryTable.Columns.Add(ValidPriceColumn);

            DataColumn WorkingOrdersColumn = new DataColumn("WorkingOrders", typeof(int));

            WorkingOrdersColumn.DefaultValue = 0;
            SummaryTable.Columns.Add(WorkingOrdersColumn);

            DataColumn WorkingOrderKeyColumn = new DataColumn("WorkingOrderKey", typeof(string));

            WorkingOrderKeyColumn.DefaultValue = "";
            SummaryTable.Columns.Add(WorkingOrderKeyColumn);

            DataColumn PositionColumn = new DataColumn("Position", typeof(int));

            PositionColumn.DefaultValue = 0;
            SummaryTable.Columns.Add(PositionColumn);

            DataColumn IndicatorLowerLimitColumn = new DataColumn("LowerLimit", typeof(double));

            IndicatorLowerLimitColumn.DefaultValue = Double.MinValue;
            SummaryTable.Columns.Add(IndicatorLowerLimitColumn);

            DataColumn IndicatorUpperLimitColumn = new DataColumn("UpperLimit", typeof(double));

            IndicatorUpperLimitColumn.DefaultValue = Double.MaxValue;
            SummaryTable.Columns.Add(IndicatorUpperLimitColumn);

            DataTable newDataTable = IfsSheet.AsEnumerable()
                                     .OrderBy(r => r.Field <string>("spread_description"))
                                     .ThenByDescending(r => r.Field <double>("min_volume"))
                                     .CopyToDataTable();

            LiquidSpreads = newDataTable.AsEnumerable().GroupBy(r => r["spread_description"]).Select(w => w.First()).CopyToDataTable();
            LiquidSpreads = LiquidSpreads.Select("spread_description='W_KW'").CopyToDataTable();

            for (int i = 0; i < LiquidSpreads.Rows.Count; i++)
            {
                List <string> TickerList = new List <string> {
                    LiquidSpreads.Rows[i].Field <string>("Contract1"), LiquidSpreads.Rows[i].Field <string>("Contract2"), LiquidSpreads.Rows[i].Field <string>("Contract3")
                };
                TickerList.RemoveAll(item => item == null);
                AutoSpreaderList.Add(new ttapiUtils.AutoSpreader(dbTickerList: TickerList, payUpTicks: 2));

                DataRow Row = SummaryTable.NewRow();
                Row["Ticker"]            = AutoSpreaderList[i].AutoSpreaderName;
                Row["TickerHead"]        = LiquidSpreads.Rows[i].Field <string>("spread_description");
                Row["LowerLimit"]        = LiquidSpreads.Rows[i].Field <double>("maSpreadLow");
                Row["UpperLimit"]        = LiquidSpreads.Rows[i].Field <double>("maSpreadHigh");
                Row["Tag"]               = "ifs_2_" + i.ToString();
                Row["Alias"]             = LiquidSpreads.Rows[i].Field <string>("spread_description") + "_ifs_2_" + DateTime.Now.ToString("MMM-yyyy");
                Row["DescriptionString"] = "strategy_class=ifs2&betsize=1000";

                AutoSpreaderDictionary.Add(AutoSpreaderList[i].AutoSpreaderName, AutoSpreaderList[i]);

                SummaryTable.Rows.Add(Row);
            }

            ASENameList = DataAnalysis.DataTableFunctions.GetColumnAsList <string>(dataTableInput: SummaryTable, columnName: "Ticker");
            TagList     = DataAnalysis.DataTableFunctions.GetColumnAsList <string>(dataTableInput: SummaryTable, columnName: "Tag");

            TTAPISubs = new ttapiUtils.Subscription(m_username, m_password);
            TTAPISubs.AutoSpreaderList = AutoSpreaderList;
            TTAPISubs.AsuUpdateList    = new List <EventHandler <AuthenticationStatusUpdateEventArgs> > {
                TTAPISubs.StartASESubscriptions
            };
            TTAPISubs.priceUpdatedEventHandler = m_ps_FieldsUpdated;
            TTAPISubs.orderFilledEventHandler  = m_ts_OrderFilled;
            TTAPISubs.OrderDeletedEventHandler = OrderDeleted;


            TimeSeriesObj = new DataAnalysis.TimeSeries(StartTime, EndTime, ASENameList.ToArray(), minInterval);
        }