public IComparablePeriod FindEndOfOndemandPeriod(DataTypeConfig dataType, string ticker, PeriodRange <IComparablePeriod> periodRange, bool IsOndemandEndpointEnabled, bool isConfigureAwait, bool useCache)
{
var fromTier = FindAvailableTier(dataType, ticker, periodRange.From, IsOndemandEndpointEnabled, isConfigureAwait, useCache);
var toTier = FindAvailableTier(dataType, ticker, periodRange.To, IsOndemandEndpointEnabled, isConfigureAwait, useCache);
if (fromTier.Equals(SupportedTier.FixedTier))
{
// use fixed tier endpoint for all
return(null);
}
else if (toTier.Equals(SupportedTier.OndemandTier))
{
return(periodRange.To);
}
else
{
// find end of ondemand tier period
var period = periodRange.From.Next();
while (period.CompareTo(periodRange.To) < 0)
{
var tier = FindAvailableTier(dataType, ticker, period.Next(), IsOndemandEndpointEnabled, isConfigureAwait, useCache);
if (tier.Equals(SupportedTier.FixedTier))
{
break;
}
else
{
period = period.Next();
}
}
return(period);
}
}
public SupportedTier FindAvailableTier(DataTypeConfig dataType, string ticker, IPeriod period, bool IsOndemandEndpointEnabled, bool isConfigureAwait, bool useCache)
{
var tier = tierResolver.Resolve(ticker, period,
isConfigureAwait, useCache);
switch (tier)
{
case SupportedTier.None:
throw new NotSupportedTierException($"there are no supported tier for {dataType}, {ticker},{period}");
case SupportedTier.FixedTier:
return(SupportedTier.FixedTier);
case SupportedTier.OndemandTier:
if (IsOndemandEndpointEnabled)
{
return(SupportedTier.OndemandTier);
}
else
{
throw new NotSupportedTierException($"fixed tier does not support the resource: {dataType}, {ticker}, {period}");
}
default:
throw new NotSupportedTierException($"unknown tier:{tier} for {dataType}, {ticker},{period}");
}
}
public string Execute(string ticker, DataTypeConfig dataType, string periodParam, string propertyName, bool isRawValue = false, bool isWithUnit = false)
{
var parameter = builder.SetTicker(ticker).SetPeriodParam(periodParam).Build();
var apiResource = fetcher.Fetch(dataType, parameter, true, true);
return(PropertySelector.SelectFormattedValue(propertyName, apiResource, isRawValue, isWithUnit, true));
}
public IList <IApiResource> GetApiResources(DataTypeConfig dataType, string ticker, IComparablePeriod from, IComparablePeriod to, bool isConfigureAwait = true, bool useCache = true)
{
UpdateApiKeyIfNeeded();
if (from.CompareTo(to) > 0)
{
throw new ArgumentException($"from={from} is more than to={to}");
}
var endOfOndemandPeriod = taskHelper.FindEndOfOndemandPeriod(dataType, ticker, PeriodRange <IComparablePeriod> .Create(from, to), config.IsOndemandEndpointEnabled, isConfigureAwait, useCache);
// use fixed tier from all range
if (endOfOndemandPeriod is null)
{
var parameter = TickerPeriodRangeParameter.Create(ticker, from, to);
var json = client.GetRange(dataType, parameter, false, isConfigureAwait, useCache);
return(parser.ParseRange(dataType, json));
}
else
{
var ondemandParameter = TickerPeriodRangeParameter.Create(ticker, from, endOfOndemandPeriod);
var fixedParameter = TickerPeriodRangeParameter.Create(ticker, endOfOndemandPeriod.Next(), to);
var ondemandTierJson = client.GetRange(dataType, ondemandParameter, true, isConfigureAwait, useCache);
var fixedTierJson = client.GetRange(dataType, fixedParameter, false, isConfigureAwait, useCache);
var ondemandResources = parser.ParseRange(dataType, ondemandTierJson);
var fixedTierResource = parser.ParseRange(dataType, fixedTierJson);
return(ondemandResources.Concat(fixedTierResource).ToList());
}
}
public IApiResource Parse(DataTypeConfig dataType, JObject json)
{
var columnDescriptions = FindProperty(PropertyNames.ColumnDescription, json);
var data = FindProperty(PropertyNames.Data, json);
if (data.Count() == 0)
{
return(EmptyResource.GetInstance());
}
else
{
var descriptions = ColumnDescriptionParser.Parse(columnDescriptions.ToList());
var properties = ParseProperties(data.Children().First());
switch (dataType)
{
case DataTypeConfig.Company:
return(ParseCompany(properties, descriptions));
case DataTypeConfig.Quarter:
return(ParseQuarter(properties, descriptions));
case DataTypeConfig.Daily:
return(ParseDaily(properties, descriptions));
default:
throw new NotSupportedDataTypeException($"Parse {dataType} is not supported at V3");
}
}
}
public IApiResource GetApiResource(DataTypeConfig dataType, ITickerPeriodParameter parameter, bool isConfigureAwait = true, bool useCache = true)
{
UpdateApiKeyIfNeeded();
var useOndemand = config.IsForceOndemandApi ? true : taskHelper.ShouldUseOndemandEndpoint(dataType, parameter.GetTicker(), parameter.GetPeriod(), config.IsOndemandEndpointEnabled, isConfigureAwait, useCache);
client.UpdateApiKey(config.ApiKey);
var json = client.Get(dataType, parameter, useOndemand, isConfigureAwait, useCache);
return(parser.Parse(dataType, json));
}
public bool ShouldUseOndemandEndpoint(DataTypeConfig dataType, string ticker, IPeriod period, bool IsOndemandEndpointEnabled, bool isConfigureAwait, bool useCache)
{
if (dataType == DataTypeConfig.Indicator)
{
return(false);
}
else
{
return(FindAvailableTier(dataType, ticker, period, IsOndemandEndpointEnabled, isConfigureAwait, useCache).Equals(SupportedTier.OndemandTier));
}
}
public JObject GetRange(DataTypeConfig dataType, TickerPeriodRangeParameter parameter, bool useOndemand, bool isConfigureAwait, bool useCache)
{
switch (dataType)
{
case DataTypeConfig.Quarter:
return(GetQuarterRange(parameter, isConfigureAwait, useCache));
default:
throw new NotSupportedDataTypeException($"Get {dataType} is not supported at V3");
}
}
public JObject Get(DataTypeConfig dataType, ITickerPeriodParameter parameter, bool useOndemand, bool isConfigureAwait = true, bool useCache = true)
{
switch (dataType)
{
case DataTypeConfig.Quarter:
return(GetQuarter(parameter as TickerQuarterParameter, useOndemand, isConfigureAwait, useCache));
case DataTypeConfig.Indicator:
return(GetIndicator(parameter as TickerEmptyPeriodParameter, isConfigureAwait, useCache));
case DataTypeConfig.Company:
return(GetCompany(parameter as TickerEmptyPeriodParameter, isConfigureAwait, useCache));
default:
throw new NotSupportedDataTypeException($"Get {dataType} is not supported at V2");
}
}
public IList <IApiResource> ParseRange(DataTypeConfig dataType, JObject json)
{
var columnDescriptions = FindColumnDescriptions(json);
var data = FindDataBody(json);
if (data.Count() == 0)
{
// return Empty
return(new List <IApiResource>().ToList());
}
switch (dataType)
{
case DataTypeConfig.Quarter:
return(ParseQuarterRange(columnDescriptions, data).Cast <IApiResource>().ToList());
default:
throw new NotSupportedDataTypeException($"ParseRange {dataType} is not supported at V2");
}
}
private ApiV2LegacyDataTypeResolver()
{
var supportedDataTypes = new DataTypeConfig[] { DataTypeConfig.Quarter, DataTypeConfig.Indicator };
mappingTable = new Dictionary <string, DataTypeConfig>();
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
foreach (var dataType in supportedDataTypes)
{
var url = propertyDescriptionDefinitions[dataType];
var req = WebRequest.Create(url);
var reader = new StreamReader(req.GetResponse().GetResponseStream());
var descriptions = Parse(reader.ReadToEnd());
foreach (var description in descriptions)
{
// Quarter を優先してmapping table を作る
if (!mappingTable.ContainsKey(description.Name))
{
mappingTable[description.Name] = dataType;
}
}
}
}
public IList <IApiResource> ParseRange(DataTypeConfig dataType, JObject json)
{
var columnDescriptions = FindProperty(PropertyNames.ColumnDescription, json);
var data = FindProperty(PropertyNames.Data, json);
if (data.Count() == 0)
{
// return Empty
return(new List <IApiResource>().ToList());
}
else
{
var descriptions = ColumnDescriptionParser.Parse(columnDescriptions.ToList());
switch (dataType)
{
case DataTypeConfig.Quarter:
return(data.Children().Children().Children().Select(d => ParseQuarter(ParseProperties(d), descriptions)).Cast <IApiResource>().ToList());
default:
throw new NotSupportedDataTypeException($"Parse {dataType} is not supported at V3");
}
}
}
public IApiResource Parse(DataTypeConfig dataType, JObject json)
{
var columnDescriptions = FindColumnDescriptions(json);
var data = FindDataBody(json);
if (data.Count() == 0)
{
return(EmptyResource.GetInstance());
}
switch (dataType)
{
case DataTypeConfig.Quarter:
return(ParseQuarter(columnDescriptions, data));
case DataTypeConfig.Indicator:
return(ParseIndicator(columnDescriptions, data));
case DataTypeConfig.Company:
return(ParseCompany(columnDescriptions, data));
default:
throw new NotSupportedDataTypeException($"Parse {dataType} is not supported at V2");
}
}
public TickerParameterBuilderForLegacy SetDataType(DataTypeConfig dataType)
{
this.dataType = dataType;
return(this);
}
public IApiResource Fetch(DataTypeConfig dataType, ITickerPeriodParameter parameter, bool isConfigureAwait, bool useCache) => processor.GetApiResource(dataType, parameter, isConfigureAwait, useCache);