Beispiel #1
0
    //public async Task<BarsAvailable> ListExchanges()
    //{

    //}
    //public async Task<BarsAvailable> ListExchangeAreas(string exchange)
    //{

    //}
    //public async Task<BarsAvailable> ListSymbols(string exchange, string exchangeArea)
    //{

    //}
    //public async Task<BarsAvailable> ListSymbols()
    //{

    //}

    public async Task <BarsAvailable> List(string exchange, string exchangeArea, string symbol, TimeFrame timeFrame)
    {
        var result = new BarsAvailable();

        var hdp = OptionsMonitor.CurrentValue;

        var dir = hdp.GetDataDir(exchange, exchangeArea, symbol, timeFrame);

        if (!Directory.Exists(dir))
        {
            return(result);
        }

        await Task.Run(() =>
        {
            foreach (var path in Directory.GetFiles(dir))
            {
                var extension = Path.GetExtension(path);
                var filename  = Path.GetFileName(path);
                KlineArrayInfo info;
                try
                {
                    info = KlineFileDeserializer.DeserializeInfo(path);
                }
                catch (Exception)
                {
                    Logger.LogTrace($"Unrecognized file: {Path.GetFileName(path)}");
                    continue;
                }

                var item = new BarsChunkInfo()
                {
                    ChunkName    = Path.GetFileNameWithoutExtension(path).Replace(KlineArrayFileConstants.PartialFileExtension, ""),
                    Bars         = info.Bars,
                    ExpectedBars = timeFrame.GetExpectedBarCount(info.Start, info.EndExclusive),
                    Start        = info.Start,
                    EndExclusive = info.EndExclusive,
                };
                item.Percent = item.ExpectedBars.HasValue ? (info.Bars / (double)item.ExpectedBars).ToString("P1") : 0;
                result.Chunks.Add(item);
            }
        });

        return(result);
    }
Beispiel #2
0
    public override async Task <bool> Execute(DumpBarsHierarchicalDataInput input)
    {
        var host = input.BuildHost();

        var source = host.Services.GetService <BarsFileSource>();

        var hdp = host.Services.GetService <IOptionsMonitor <HistoricalDataPaths> >()?.CurrentValue;
        //var logger = host.Services.GetService<ILogger<ListAvailableHierarchicalDataCommand>>();

        var dir = hdp.GetDataDir(input.ExchangeFlag, input.ExchangeAreaFlag, input.Symbol, input.TimeFrame);

        if (Directory.Exists(dir))
        {
            DateTime openTime;

            foreach (var path in Directory.GetFiles(dir))
            {
                var filename = Path.GetFileName(path);

                bool isFirstBarForFile = true;
                var(info, bars) = KlineFileDeserializer.Deserialize(path);

                openTime = info.Start;
                foreach (var bar in bars)
                {
                    try
                    {
                        if (input.TimeFrame.TimeSpan.HasValue)
                        {
                            if (openTime < input.FromFlag)
                            {
                                continue;
                            }
                            Console.Write($"{openTime.ToString("yyyy-MM-dd HH:mm")} ");
                        }

                        if (isFirstBarForFile && input.VerboseFlag)
                        {
                            isFirstBarForFile = false;
                            Console.WriteLine($" - {filename}");
                            Console.WriteLine(info.Dump().ToString());
                        }

                        Console.WriteLine(bar.ToString());
                    }
                    finally
                    {
                        if (input.TimeFrame.TimeSpan.HasValue)
                        {
                            openTime += input.TimeFrame.TimeSpan.Value;
                        }
                    }
                    if (openTime >= input.ToFlag)
                    {
                        break;
                    }
                }
            }
        }

        return(false);
    }