///////////////////////////////////////////////////////////////////////
public HistoryData(
int levels,
HistoryFlags flags
)
: this()
{
this.levels = levels;
this.flags = flags;
}
///////////////////////////////////////////////////////////////////////
#region Public Constructors
public HistoryClientData(
object data,
ArgumentList arguments,
int levels,
HistoryFlags flags
)
: this(data)
{
this.arguments = arguments;
this.levels = levels;
this.flags = flags;
}
///////////////////////////////////////////////////////////////////////
#if HISTORY
public static bool HasFlags(
HistoryFlags flags,
HistoryFlags hasFlags,
bool all
)
{
if (all)
{
return((flags & hasFlags) == hasFlags);
}
else
{
return((flags & hasFlags) != HistoryFlags.None);
}
}
///////////////////////////////////////////////////////////////////////
public HistoryFilter(
int startLevel,
int stopLevel,
HistoryFlags hasFlags,
HistoryFlags notHasFlags,
bool hasAll,
bool notHasAll
)
: this()
{
this.startLevel = startLevel;
this.stopLevel = stopLevel;
this.hasFlags = hasFlags;
this.notHasFlags = notHasFlags;
this.hasAll = hasAll;
this.notHasAll = notHasAll;
}
public async Task Run(int number, HistoryFlags flags, string baseCurrency)
{
List <Symbol> symbols = GetSymbols(number);
Console.WriteLine($"Loaded {symbols.Count} symbols.");
Console.WriteLine($"Retrieving values...");
Stopwatch watch = new();
watch.Start();
Dictionary <string, Security?> securities = await YahooQuotes.GetAsync(symbols.Select(x => x.Name), flags, baseCurrency);
watch.Stop();
int n = securities.Values.Select(x => x).NotNull().Count();
double s = watch.Elapsed.TotalSeconds;
double rate = n / s;
Logger.LogWarning($"Rate = {n}/{s} = {rate}Hz");
Analyze(securities);
}
///////////////////////////////////////////////////////////////////////
public static bool MatchData(
int levels,
HistoryFlags flags,
IHistoryFilter historyFilter
)
{
if (historyFilter != null)
{
if ((historyFilter.StartLevel != Level.Invalid) &&
(levels < historyFilter.StartLevel))
{
return(false);
}
if ((historyFilter.StopLevel != Level.Invalid) &&
(levels > historyFilter.StopLevel))
{
return(false);
}
if ((historyFilter.HasFlags != HistoryFlags.None) &&
!FlagOps.HasFlags(flags, historyFilter.HasFlags,
historyFilter.HasAll))
{
return(false);
}
if ((historyFilter.NotHasFlags != HistoryFlags.None) &&
FlagOps.HasFlags(flags, historyFilter.NotHasFlags,
historyFilter.NotHasAll))
{
return(false);
}
}
return(true);
}
private async Task <Dictionary <Symbol, Security?> > GetSecuritiesyAsync(HashSet <Symbol> symbols, HistoryFlags historyFlags, Symbol historyBase, CancellationToken ct)
{
HashSet <Symbol> stockAndCurrencyRateSymbols = symbols.Where(s => s.IsStock || s.IsCurrencyRate).ToHashSet();
if (historyBase.IsStock)
{
stockAndCurrencyRateSymbols.Add(historyBase);
}
Dictionary <Symbol, Security?> securities = await Snapshot.GetAsync(stockAndCurrencyRateSymbols, ct).ConfigureAwait(false);
if (historyFlags == HistoryFlags.None)
{
return(securities);
}
if (!historyBase.IsEmpty)
{
await AddCurrencies(symbols, historyBase, securities, ct).ConfigureAwait(false);
}
await AddHistoryToSecurities(securities, historyFlags, ct).ConfigureAwait(false);
if (!historyBase.IsEmpty)
{
HistoryBaseComposer.Compose(symbols, historyBase, securities);
}
return(securities);
}
public async Task <Dictionary <Symbol, Security?> > GetAsync(IEnumerable <Symbol> symbols, HistoryFlags historyFlags, Symbol historyBase, CancellationToken ct = default)
{
HashSet <Symbol> syms = symbols.ToHashSet();
if (syms.Any(s => s.IsEmpty))
{
throw new ArgumentException("Empty symbol.");
}
if (historyBase.IsCurrencyRate)
{
throw new ArgumentException($"Invalid base symbol: {historyBase}.");
}
if (!historyBase.IsEmpty && syms.Any(s => s.IsCurrencyRate))
{
throw new ArgumentException($"Invalid symbol: {syms.First(s => s.IsCurrencyRate)}.");
}
if (historyBase.IsEmpty && syms.Any(s => s.IsCurrency))
{
throw new ArgumentException($"Invalid symbol: {syms.First(s => s.IsCurrency)}.");
}
if (!historyBase.IsEmpty && !historyFlags.HasFlag(HistoryFlags.PriceHistory))
{
throw new ArgumentException("PriceHistory must be enabled when historyBase is specified.");
}
try
{
Dictionary <Symbol, Security?> securities = await GetSecuritiesyAsync(syms, historyFlags, historyBase, ct).ConfigureAwait(false);
return(syms.ToDictionary(symbol => symbol, symbol => securities[symbol]));
}
catch (Exception e)
{
Logger.LogCritical(e, "YahooQuotes: GetAsync() error.");
throw;
}
}
public async Task <Security?> GetAsync(Symbol symbol, HistoryFlags historyFlags, Symbol historyBase, CancellationToken ct = default) =>
(await GetAsync(new[] { symbol }, historyFlags, historyBase, ct).ConfigureAwait(false)).Values.Single();
public async Task <Dictionary <string, Security?> > GetAsync(IEnumerable <string> symbols, HistoryFlags historyFlags = HistoryFlags.None, string historyBase = "", CancellationToken ct = default)
{
Symbol historyBaseSymbol = Symbol.TryCreate(historyBase, true) ?? throw new ArgumentException($"Invalid base symbol: {historyBase}.");
List <Symbol> syms = symbols.ToSymbols();
Dictionary <Symbol, Security?> securities = await GetAsync(syms, historyFlags, historyBaseSymbol, ct).ConfigureAwait(false);
return(syms.ToDictionary(s => s.Name, s => securities[s], StringComparer.OrdinalIgnoreCase));
}
private async Task AddHistoryToSecurities(Dictionary <Symbol, Security?> securities, HistoryFlags historyFlags, CancellationToken ct)
{
List <Security> secs = securities.Values.NotNull().ToList();
var dividendJobs = secs.Where(_ => historyFlags.HasFlag(HistoryFlags.DividendHistory))
.Select(sec => (sec, History.GetTicksAsync <DividendTick>(sec.Symbol, ct))).ToList();
var splitJobs = secs.Where(_ => historyFlags.HasFlag(HistoryFlags.SplitHistory))
.Select(sec => (sec, History.GetTicksAsync <SplitTick>(sec.Symbol, ct))).ToList();
var priceJobs = secs.Where(_ => historyFlags.HasFlag(HistoryFlags.PriceHistory))
.Select(sec => (sec, History.GetTicksAsync <PriceTick>(sec.Symbol, ct))).ToList();
List <Task> tasks = new();
tasks.AddRange(dividendJobs.Select(t => t.Item2));
tasks.AddRange(splitJobs.Select(t => t.Item2));
tasks.AddRange(priceJobs.Select(t => t.Item2));
await TaskExt.WhenAll(tasks).ConfigureAwait(false);
foreach (var(security, task) in dividendJobs)
{
security.DividendHistory = task.Result;
}
foreach (var(security, task) in splitJobs)
{
security.SplitHistory = task.Result;
}
foreach (var(security, task) in priceJobs)
{
security.PriceHistory = task.Result;
security.PriceHistoryBase = GetPriceHistoryBase(task.Result, security);
}
}
