public void FindEndOfOndemandPeriodTest()
{
var tierResolver = CreatTierResolver();
var helper = new ApiTaskHelper(tierResolver);
// for fixed tier range, return null
// quarter
var tierRange = PeriodRange <IComparablePeriod> .Create(fixedOldestQuarter, fixedLatestQuarter);
Assert.IsNull(helper.FindEndOfOndemandPeriod(DataTypeConfig.Quarter, ticker, tierRange, true, true, true) as FiscalQuarterPeriod);
Assert.IsNull(helper.FindEndOfOndemandPeriod(DataTypeConfig.Quarter, ticker, tierRange, false, true, true) as FiscalQuarterPeriod);
// daily
tierRange = PeriodRange <IComparablePeriod> .Create(fixedTierOldestDay, fixedTierLatestDay);
Assert.IsNull(helper.FindEndOfOndemandPeriod(DataTypeConfig.Daily, ticker, tierRange, true, true, true) as DayPeriod);
Assert.IsNull(helper.FindEndOfOndemandPeriod(DataTypeConfig.Daily, ticker, tierRange, false, true, true) as DayPeriod);
// for ondemand range
// quarter
tierRange
= PeriodRange <IComparablePeriod> .Create(ondemandOldestQuarter, ondemandLatestQuarter);
Assert.AreEqual(ondemandLatestQuarter, helper.FindEndOfOndemandPeriod(DataTypeConfig.Quarter, ticker, tierRange, true, true, true) as FiscalQuarterPeriod);
Assert.ThrowsException <NotSupportedTierException>(() => helper.FindEndOfOndemandPeriod(DataTypeConfig.Quarter, ticker, tierRange, false, true, true));
tierRange
= PeriodRange <IComparablePeriod> .Create(ondemandOldestDay, ondemandLatestDay);
Assert.AreEqual(ondemandLatestDay, helper.FindEndOfOndemandPeriod(DataTypeConfig.Daily, ticker, tierRange, true, true, true) as DayPeriod);
Assert.ThrowsException <NotSupportedTierException>(() => helper.FindEndOfOndemandPeriod(DataTypeConfig.Daily, ticker, tierRange, false, true, true));
}
public static CsvDownloadParameters Create(string ticker, FiscalQuarterPeriod from, FiscalQuarterPeriod to, CsvDownloadOutputSettings outputSettings)
{
JpTickerValidator.Validate(ticker);
var range = PeriodRange <FiscalQuarterPeriod> .Create(from, to);
return(new CsvDownloadParameters(ticker, range, outputSettings));
}
public void FixedTierRengeLengthTest()
{
var from = FiscalQuarterPeriod.Create(2020, 1);
var to = FiscalQuarterPeriod.Create(2021, 2);
var range = PeriodRange <FiscalQuarterPeriod> .Create(from, to);
var supportedTierRange = new SupportedTierRange <FiscalQuarterPeriod>(range, null);
Assert.AreEqual((uint)5, supportedTierRange.FixedTierRengeLength());
}
public void CreateForDayPeriodTest()
{
var from = DayPeriod.Create(2020, 1, 1);
var to = DayPeriod.Create(2020, 1, 2);
var fqRange = PeriodRange <DayPeriod> .Create(from, to);
Assert.AreEqual(from, fqRange.From);
Assert.AreEqual(to, fqRange.To);
Assert.ThrowsException <ValidationError>(() => PeriodRange <DayPeriod> .Create(to, from));
}
public IEnumerable <Quarter> GetQuarters(CsvDownloadParameters parameters)
{
// set isConfigureAwait for performance
// https://devblogs.microsoft.com/dotnet/configureawait-faq/#why-would-i-want-to-use-configureawaitfalse
var quarters = PeriodRange <FiscalQuarterPeriod> .Slice(parameters.Range, 4)
.SelectMany
(r => processor.GetApiResources(DataTypeConfig.Quarter, parameters.Ticker, r.From, r.To, false, true)
).Cast <Quarter>();
return(quarters.Distinct().OrderBy(q => q.Period));
}
public static Company Create(
string ticker,
PeriodRange <FiscalQuarterPeriod> fixedTierQuarterRange,
PeriodRange <FiscalQuarterPeriod> ondemandQuarterTierRange,
PeriodRange <DayPeriod> fixedTierDayRange,
PeriodRange <DayPeriod> ondemandTierDayRange,
PropertyDictionary properties,
PropertyDescriptionDictionary descriptions)
{
JpTickerValidator.Validate(ticker);
return(new Company(ticker, fixedTierQuarterRange, ondemandQuarterTierRange, fixedTierDayRange, ondemandTierDayRange, properties, descriptions));
}
public void IncludesTest()
{
var from = FiscalQuarterPeriod.Create(2020, 1);
var to = FiscalQuarterPeriod.Create(2020, 3);
var range = PeriodRange <FiscalQuarterPeriod> .Create(from, to);
Assert.IsTrue(range.Includes(from));
Assert.IsTrue(range.Includes(FiscalQuarterPeriod.Create(2020, 2)));
Assert.IsTrue(range.Includes(to));
Assert.IsFalse(range.Includes(FiscalQuarterPeriod.Create(2020, 4)));
Assert.IsFalse(range.Includes(FiscalQuarterPeriod.Create(2019, 4)));
}
private Company(string ticker,
PeriodRange <FiscalQuarterPeriod> fixedTierQuarterRange,
PeriodRange <FiscalQuarterPeriod> ondemandTierQuarterRange,
PeriodRange <DayPeriod> fixedTierDayRange,
PeriodRange <DayPeriod> ondemandTierDayRange,
PropertyDictionary properties,
PropertyDescriptionDictionary descriptions)
{
this.ticker = ticker;
this.supportedQuarterRanges = new SupportedTierRange <FiscalQuarterPeriod>(fixedTierQuarterRange, ondemandTierQuarterRange);
this.supportedDayRanges = new SupportedTierRange <DayPeriod>(fixedTierDayRange, ondemandTierDayRange);
this.properties = properties;
this.descriptions = descriptions;
}
public void TotalGapTest()
{
// quarter
var fromFqp = FiscalQuarterPeriod.Create(2020, 1);
var toFqp = FiscalQuarterPeriod.Create(2021, 2);
Assert.AreEqual((uint)5, PeriodRange <FiscalQuarterPeriod> .Create(fromFqp, toFqp).TotalGap());
// day
var fromDay = DayPeriod.Create(2016, 1, 1);
var toDay = DayPeriod.Create(2016, 2, 1);
Assert.AreEqual((uint)31, PeriodRange <DayPeriod> .Create(fromDay, toDay).TotalGap());
}
public void SliceDayTest()
{
var from = DayPeriod.Create(2016, 1, 1);
var to = DayPeriod.Create(2016, 2, 1);
var dayRange = PeriodRange <DayPeriod> .Create(from, to);
// size = 1
var chunks = PeriodRange <DayPeriod> .Slice(dayRange, 1).ToArray();
Assert.AreEqual(32, chunks.Length);
Assert.AreEqual(from, chunks[0].From);
Assert.AreEqual(from, chunks[0].To);
Assert.AreEqual(from.Next(), chunks[1].From);
Assert.AreEqual(to, chunks[31].From);
Assert.AreEqual(to, chunks[31].To);
for (uint i = 0; i < chunks.Length; i++)
{
Assert.AreEqual(0, ComparablePeriodUtil.GetGap(chunks[i].From, chunks[i].To));
}
// size = 2
chunks = PeriodRange <DayPeriod> .Slice(dayRange, 2).ToArray();
Assert.AreEqual(16, chunks.Length);
Assert.AreEqual(from, chunks[0].From);
Assert.AreEqual(from.Next(), chunks[0].To);
Assert.AreEqual(from.Next().Next(), chunks[1].From);
Assert.AreEqual(to, chunks[15].To);
for (uint i = 0; i < chunks.Length; i++)
{
Assert.AreEqual(1, ComparablePeriodUtil.GetGap(chunks[i].From, chunks[i].To));
}
// size = 3
chunks = PeriodRange <DayPeriod> .Slice(dayRange, 3).ToArray();
Assert.AreEqual(11, chunks.Length);
Assert.AreEqual(from, chunks[0].From);
Assert.AreEqual(from.Next().Next(), chunks[0].To);
Assert.AreEqual(from.Next().Next().Next(), chunks[1].From);
Assert.AreEqual(to, chunks[10].To);
for (uint i = 0; i < chunks.Length - 1; i++)
{
Assert.AreEqual(2, ComparablePeriodUtil.GetGap(chunks[i].From, chunks[i].To));
}
Assert.AreEqual(1, ComparablePeriodUtil.GetGap(chunks.Last().From, chunks.Last().To));
}
static string ConvertDateToPeriod(DateTime dt, PeriodRange p)
{
switch (p)
{
case PeriodRange.Year:
return Convert.ToString(dt.Year);
case PeriodRange.Semester:
return string.Format("{0}_S{1}", dt.Year, dt.Month <= 6 ? "1" : "2");
case PeriodRange.Trimester:
return string.Format("{0}_Q{1}", dt.Year, dt.Month <= 3 ? "1" : dt.Month <= 6 ? "2" : dt.Month <= 9 ? "3" : "4");
case PeriodRange.Month:
return string.Format("{0}_M{1}", dt.Year, dt.Month);
default:
throw new ArgumentException();
}
}
public void SliceFiscalQuarterTest()
{
var from = FiscalQuarterPeriod.Create(2016, 1);
var to = FiscalQuarterPeriod.Create(2020, 4);
var quarterRange = PeriodRange <FiscalQuarterPeriod> .Create(from, to);
// size = 1
var chunks = PeriodRange <FiscalQuarterPeriod> .Slice(quarterRange, 1).ToArray();
Assert.AreEqual(20, chunks.Length);
Assert.AreEqual(from, chunks[0].From);
Assert.AreEqual(from, chunks[0].To);
Assert.AreEqual(from.Next(), chunks[1].From);
Assert.AreEqual(to, chunks[19].From);
Assert.AreEqual(to, chunks[19].To);
for (uint i = 0; i < chunks.Length; i++)
{
Assert.AreEqual(0, ComparablePeriodUtil.GetGap(chunks[i].From, chunks[i].To));
}
// size = 2
chunks = PeriodRange <FiscalQuarterPeriod> .Slice(quarterRange, 2).ToArray();
Assert.AreEqual(10, chunks.Length);
Assert.AreEqual(from, chunks[0].From);
Assert.AreEqual(from.Next(), chunks[0].To);
Assert.AreEqual(from.Next().Next(), chunks[1].From);
Assert.AreEqual(to, chunks[9].To);
for (uint i = 0; i < chunks.Length; i++)
{
Assert.AreEqual(1, ComparablePeriodUtil.GetGap(chunks[i].From, chunks[i].To));
}
// size = 3
chunks = PeriodRange <FiscalQuarterPeriod> .Slice(quarterRange, 3).ToArray();
Assert.AreEqual(7, chunks.Length);
Assert.AreEqual(from, chunks[0].From);
Assert.AreEqual(from.Next().Next(), chunks[0].To);
Assert.AreEqual(from.Next().Next().Next(), chunks[1].From);
Assert.AreEqual(to, chunks[6].To);
for (uint i = 0; i < chunks.Length - 1; i++)
{
Assert.AreEqual(2, ComparablePeriodUtil.GetGap(chunks[i].From, chunks[i].To));
}
Assert.AreEqual(1, ComparablePeriodUtil.GetGap(chunks.Last().From, chunks.Last().To));
}
public static IEnumerable<TotalsByCountryByPeriod> TotalsByCountryByPeriodSortedByCountry(PeriodRange periodRange)
{
//var query = from c in SampleData.LoadCustomersFromXML()
// group c by c.Country into g
// select
// select new TotalsByCountryByPeriod { Country = g.Key, NumCustomers = g.Count(), TotalSales = g.SelectMany(c => c.Orders).Sum(o => o.Total) }
return SampleData.LoadCustomersFromXML().GroupBy(c => c.Country).
SelectMany(g => g.SelectMany(c => c.Orders, (c, o) => new {Customer = c, Order = o}).GroupBy(
co => ToPeriod(co.Order.OrderDate, periodRange))
,(g, period) => new TotalsByCountryByPeriod {
Country = g.Key,
NumCustomers = period.Select(co => co.Customer).Distinct().Count(),
PeriodRange = periodRange,
Period = period.Key,
TotalSales = period.Sum(co => co.Order.Total)
}).OrderBy(cwc => cwc.Country).ThenBy(cwc => cwc.Period);
}
private static Company ParseCompany(
PropertyDictionary properties,
PropertyDescriptionDictionary descriptions)
{
var fixedTierRangeJson = JObject.Parse(properties.Get(PropertyNames.FixedTierRange));
var fixedTierRange = FixedTierRangeParser.Parse(fixedTierRangeJson.Properties());
var oldestFy = uint.Parse(properties.Get(PropertyNames.OldestFiscalYear));
var oldestFq = uint.Parse(properties.Get(PropertyNames.OldestFiscalQuarter));
var latestFy = uint.Parse(properties.Get(PropertyNames.LatestFiscalYear));
var latestFq = uint.Parse(properties.Get(PropertyNames.LatestFiscalQuarter));
var oldestDate = DayPeriod.Parse(properties.Get(PropertyNames.OldestDate));
// use today as latest date
var latestDate = DayPeriod.Create(DateTime.Today);
var fixedTierQuarterRange = PeriodRange <FiscalQuarterPeriod> .Create(fixedTierRange.OldestQuarter, fixedTierRange.LatestQuarter);
var fixedTierDayRange = PeriodRange <DayPeriod> .Create(fixedTierRange.OldestDate, fixedTierRange.LatestDate);
var ondemandPeriodRange = PeriodRange <FiscalQuarterPeriod> .Create(
FiscalQuarterPeriod.Create(oldestFy, oldestFq),
FiscalQuarterPeriod.Create(latestFy, latestFq)
);
var ondemandTierDayRange = PeriodRange <DayPeriod> .Create(oldestDate, latestDate);
return(Company.Create(
properties.Get(PropertyNames.Ticker),
fixedTierQuarterRange,
ondemandPeriodRange,
fixedTierDayRange,
ondemandTierDayRange,
properties,
descriptions
));
}
public SupportedTierRange(
PeriodRange <T> fixedTierRange, PeriodRange <T> ondemandTierRange)
{
this.fixedTierRange = fixedTierRange;
this.ondemandTierRange = ondemandTierRange;
}
public static IEnumerable<TotalsByCountryByPeriod> TotalsByCountryByPeriodSortedByCountry(PeriodRange periodRange)
{
var range = (int) periodRange;
return SampleData.LoadCustomersFromXML()
.SelectMany(s => s.Orders, (f, o) => new
{
f.Country,
f.CustomerID,
o.Total,
Range = o.OrderDate.Year.ToString()
+ f.Country
+ GetYearPart(o.OrderDate,periodRange),
periodRange,
o.OrderDate.Year,
YearPart = GetYearPart(o.OrderDate, periodRange)
})
.GroupBy(z => z.Range)
.Select(g => new TotalsByCountryByPeriod()
{
Country = g.Select(t => t.Country).First(),
NumCustomers = g.Select(c => c.CustomerID).Distinct().Count(),
PeriodRange = g.Select(p => p.periodRange).First(),
TotalSales = g.Sum(x => x.Total),
Year = g.Select(h=>h.Year).First(),
YearPart = g.Select(h=>h.YearPart).First()
})
.OrderBy(k=>k.Country)
.ThenBy(i=>i.Year)
.ThenBy(z=>z.YearPart);
}
public static int GetYearPart(DateTime date, PeriodRange range)
{
var i = 0;
switch (range)
{
case PeriodRange.Year:
i = 0;
break;
case PeriodRange.Semester:
i = date.Month/6;
break;
case PeriodRange.Trimester:
i = date.Month/3;
break;
case PeriodRange.Month:
i = date.Month;
break;
default:
throw new ArgumentOutOfRangeException("range");
}
return i;
}
public static IEnumerable<TotalsByCountryByPeriod> TotalsByCountryByPeriodSortedByCountry(PeriodRange periodRange)
{
var list = SampleData.LoadCustomersFromXML();
return list.SelectMany(c => c.Orders, (c, o) => new { Country = c.Country, CustName = c.Name, Order = o }).
GroupBy(co => co.Country).SelectMany(gc => gc.
GroupBy(o => ConvertDateToPeriod(o.Order.OrderDate, periodRange)).
Select(g => new TotalsByCountryByPeriod
{
NumCustomers = g.Select(co => co.CustName).Distinct().Count(),
TotalSales = g.Sum(o => o.Order.Total),
Country = gc.Key,
PeriodRange = g.Key
}));
}
private CsvDownloadParameters(string ticker, PeriodRange <FiscalQuarterPeriod> range, CsvDownloadOutputSettings outputSettings)
{
Ticker = ticker;
Range = range;
OutputSettings = outputSettings;
}
public static TickerPeriodRangeParameter Create(string ticker, IComparablePeriod from, IComparablePeriod to)
{
JpTickerValidator.Validate(ticker);
return(new TickerPeriodRangeParameter(ticker, PeriodRange <IComparablePeriod> .Create(from, to)));
}
public static TickerPeriodRangeParameter Create(string ticker, PeriodRange <IComparablePeriod> periodRange)
{
JpTickerValidator.Validate(ticker);
return(new TickerPeriodRangeParameter(ticker, periodRange));
}
private TickerPeriodRangeParameter(string ticker, PeriodRange <IComparablePeriod> periodRange)
{
this.ticker = ticker;
this.periodRange = periodRange;
}
private static string ToPeriod(DateTime d, PeriodRange p)
{
return d.Year.ToString() + (d.Month-1) / (int)p;
}
public static IEnumerable<TotalsByCountryByPeriod> TotalsByCountryByPeriodSortedByCountry(PeriodRange periodRange)
{
// TODO
throw new NotImplementedException();
}
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 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 EventStatisticsViewModelBuilder(IMediator mediator) : base(mediator)
{
this.mediator = mediator;
periodRange = PeriodRange.AllTime;
}
public IPageViewModelBuilder <EventStatisticsViewModel> WithPeriodRange(PeriodRange periodRange)
{
this.periodRange = periodRange;
return(this);
}
