public void GenerateYear()
{
var value = new DateTime(2019, 1, 15);
var target = DatePeriodValue.ToYearFromStart(value);
Assert.Equal(365, target.Days);
}
public void GenerateDays()
{
var value = new DateTime(2019, 1, 15);
var target = DatePeriodValue.ToYearFromStart(value);
var periods = target.ToDaysPeriods();
Assert.Equal(365, periods.Count);
}
public async Task <MultiSerieItemGetRp> GetAnnualJourneyGroupCalendarReport(int journeyId, DateTime start)
{
var result = new MultiSerieItemGetRp();
var period = DatePeriodValue.ToYearFromStart(start);
var journey = await this._dbContext.FullJourneyWithSourceItems(journeyId, period.Start, period.End);
var days = period.ToDaysPeriods();
result.Avatar = journey.Avatar;
result.Name = journey.Name;
foreach (var day in days)
{
var measure = journey.Measure(day);
result.Items.Add(new SeriesItemGetRp(day.Start, measure.Availability));
}
return(result);
}
public async Task <MemoryStream> ExportAnnualAvailabilityInteractions(int productId)
{
var period = DatePeriodValue.ToYearFromStart(this._datetimeGateway.GetCurrentDateTime());
var stream = new MemoryStream();
using (var package = new ExcelPackage(stream))
{
var product = await this._dbContext.FullLoadProductWithSourceItems(productId, period.Start, period.End);
var agg = new AnnualAvailabilityInteractionsAggregate(product, this._datetimeGateway.GetCurrentDateTime());
var model = agg.Execute();
var journeySheet = package.Workbook.Worksheets.Add("journeys");
journeySheet.Cells.LoadFromCollection(model.journeys, true);
var sourceSheet = package.Workbook.Worksheets.Add("Sources");
sourceSheet.Cells.LoadFromCollection(model.sources, true);
package.Save();
}
stream.Position = 0;
return(stream);
}
public async Task <IEnumerable <MultiSerieItemGetRp> > GetAnnualJourneyGroupCalendarReport(int productId, string group, DateTime start)
{
var period = DatePeriodValue.ToYearFromStart(start);
var product = await this._dbContext.FullLoadProductWithGroupAndSourceItems(productId, group, period.Start, period.End);
var result = new List <MultiSerieItemGetRp>();
var root = new MultiSerieItemGetRp();
root.Name = group;
var days = period.ToDaysPeriods();
foreach (var day in days)
{
root.Items.Add(
new SeriesItemGetRp(day.Start,
product.Journeys.Select(c => c.Measure(day).AvailabilityDebt).Sum())
);
}
result.Add(root);
return(result);
}
public AnnualAvailabilityInteractionsAggregate(ProductEntity product,
DateTime target)
{
this.Product = product;
this.Period = DatePeriodValue.ToYearFromStart(target);
}
public async Task <AnnualJourneyListRp> GetAnnualReport(int productId, DateTime start)
{
var result = new AnnualJourneyListRp();
var period = DatePeriodValue.ToYearFromStart(start);
var product = await this._dbContext.FullLoadProductWithSourceItems(productId, period.Start, period.End);
var months = period.ToYearPeriods();
var pivot = new Dictionary <JourneyEntity, List <JourneyQualityMeasureValue> >();
foreach (var monthperiod in months)
{
foreach (var journey in product.Journeys)
{
var measure = journey.Measure(monthperiod);
if (!pivot.ContainsKey(journey))
{
pivot.Add(journey, new List <JourneyQualityMeasureValue>());
}
pivot[journey].Add(measure);
}
}
if (pivot.Count == 0)
{
return(result);
}
result.Availability = pivot.Select(c =>
{
var tmp = new MonthRp()
{
Id = c.Key.Id.Value, Name = string.Format("{0} | SLO:{1}", c.Key.Name, c.Key.AvailabilitySlo)
};
for (int i = 0; i < c.Value.Count; i++)
{
tmp.SetMonthValue(i, c.Value[i].Availability);
}
return(tmp);
}).ToList();
result.Latency = pivot.Select(c =>
{
var tmp = new MonthRp()
{
Id = c.Key.Id.Value, Name = string.Format("{0} | SLO:{1}", c.Key.Name, c.Key.LatencySlo)
};
for (int i = 0; i < c.Value.Count; i++)
{
tmp.SetMonthValue(i, c.Value[i].Latency);
}
return(tmp);
}).ToList();
result.Experience = pivot.Select(c =>
{
var tmp = new MonthRp()
{
Id = c.Key.Id.Value, Name = string.Format("{0} | SLO:{1}", c.Key.Name, c.Key.ExperienceSlo)
};
for (int i = 0; i < c.Value.Count; i++)
{
tmp.SetMonthValue(i, c.Value[i].Experience);
}
return(tmp);
}).ToList();
return(result);
}
public async Task <AnnualJourneyGroupListRp> GetAnnualGroupReport(int productId, DateTime start)
{
var result = new AnnualJourneyGroupListRp();
var period = DatePeriodValue.ToYearFromStart(start);
var product = await this._dbContext.FullLoadProductWithSourceItems(productId, period.Start, period.End);
var months = period.ToYearPeriods();
var journeysGroups = product.Journeys.GroupBy(c => c.Group).ToList();
var pivot = new Dictionary <string, List <(int count, decimal availability, decimal latency, decimal experience)> >();
foreach (var monthperiod in months)
{
var groupsReport = new List <(string name, int count, decimal availability, decimal latency, decimal experience)>();
foreach (var group in journeysGroups)
{
var measures = group.Select(c => new { measure = c.Measure(monthperiod), slo = c.AvailabilitySlo }).ToList();
groupsReport.Add((group.Key, group.Count(),
measures.Sum(c => c.measure.AvailabilityDebt),
measures.Sum(c => c.measure.LatencyDebt),
measures.Sum(c => c.measure.ExperienceDebt)
));
}
foreach (var group in groupsReport)
{
if (!pivot.ContainsKey(group.name))
{
pivot.Add(group.name, new List <(int count, decimal availability, decimal latency, decimal experience)>());
}
pivot[group.name].Add((group.count, group.availability, group.latency, group.experience));
}
if (!pivot.ContainsKey("[Total]"))
{
pivot.Add("[Total]", new List <(int count, decimal availability, decimal latency, decimal experience)>());
}
pivot["[Total]"].Add(
(
groupsReport.Sum(c => c.count),
groupsReport.Sum(c => c.availability),
groupsReport.Sum(c => c.latency),
groupsReport.Sum(c => c.experience)
));
}
if (pivot.Count == 0)
{
return(result);
}
result.Availability = pivot.Select(c =>
{
var tmp = new MonthRp()
{
Name = c.Key, Count = c.Value.ElementAt(0).count
};
for (int i = 0; i < c.Value.Count; i++)
{
tmp.SetMonthValue(i, c.Value[i].availability);
}
return(tmp);
}).ToList();
result.Latency = pivot.Select(c =>
{
var tmp = new MonthRp()
{
Name = c.Key, Count = c.Value.ElementAt(0).count
};
for (int i = 0; i < c.Value.Count; i++)
{
tmp.SetMonthValue(i, c.Value[i].latency);
}
return(tmp);
}).ToList();
result.Experience = pivot.Select(c =>
{
var tmp = new MonthRp()
{
Name = c.Key, Count = c.Value.ElementAt(0).count
};
for (int i = 0; i < c.Value.Count; i++)
{
tmp.SetMonthValue(i, c.Value[i].experience);
}
return(tmp);
}).ToList();
var weeks = period.ToWeeksPeriods();
var days = period.ToDaysPeriods();
var dayli_measures = days.Select(date => (date, product.Journeys.Select(d => d.Measure(date)))).ToList();
foreach (var item in dayli_measures)
{
result.Series.Availability.Items.Add(new DatetimeSerieItemModel(item.date.Start, item.Item2.Sum(c => c.AvailabilityDebt)));
result.Series.Latency.Items.Add(new DatetimeSerieItemModel(item.date.Start, item.Item2.Sum(c => c.LatencyDebt)));
result.Series.Experience.Items.Add(new DatetimeSerieItemModel(item.date.Start, item.Item2.Sum(c => c.ExperienceDebt)));
}
foreach (var item in journeysGroups)
{
var measures_weeks = weeks.Select(week => (week, item.Select(c => c.Measure(week))));
var temp = new DatetimeSerieListModel(item.Key);
temp.Items.AddRange(measures_weeks.Select(c => new DatetimeSerieItemModel(c.week.Start, c.Item2.Sum(d => d.AvailabilityDebt))).ToList());
result.Series.AvailabilityDetail.Add(temp);
var tempLatency = new DatetimeSerieListModel(item.Key);
tempLatency.Items.AddRange(measures_weeks.Select(c => new DatetimeSerieItemModel(c.week.Start, c.Item2.Sum(d => d.LatencyDebt))).ToList());
result.Series.LatencyDetail.Add(tempLatency);
var tempExperience = new DatetimeSerieListModel(item.Key);
tempExperience.Items.AddRange(measures_weeks.Select(c => new DatetimeSerieItemModel(c.week.Start, c.Item2.Sum(d => d.ExperienceDebt))).ToList());
result.Series.ExperienceDetail.Add(tempExperience);
}
return(result);
}