public QualityMeasureValue Measure(DatePeriodValue period = null)
{
return(new QualityMeasureValue(
this.MeasureAvailability(period),
this.MeasureLatency(period),
this.MeasureExperience(period)));
}
public async Task <DatetimeSerieModel> GetDailySeriesById(int journeyId, DatePeriodValue period)
{
var journey = await this._dbContext.GetJourney(journeyId);
var sourceIds = journey.FeatureMap.SelectMany(c => c.Feature.Indicators)
.Select(c => c.SourceId).Distinct();
var sourceItems = await this._dbContext.GetSourceItems(sourceIds, period.Start, period.End);
foreach (var map in journey.FeatureMap)
{
foreach (var indicator in map.Feature.Indicators)
{
indicator.Source.SourceItems = sourceItems.Where(c => c.SourceId == indicator.SourceId).ToList();
}
}
var result = new DatetimeSerieModel
{
Start = period.Start,
End = period.End,
Name = journey.Name,
Avatar = journey.Avatar,
};
var aggregator = new JourneyDailyAggregate(journey, period);
var(availability, features) = aggregator.MeasureQuality;
result.Availability.AddItems(
availability.OrderBy(c => c.Date).Select(c => (c.Date, c.Measure.Availability)).ToList()
);
result.Latency.AddItems(
availability.OrderBy(c => c.Date).Select(c => (c.Date, c.Measure.Latency)).ToList()
);
result.Experience.AddItems(
availability.OrderBy(c => c.Date).Select(c => (c.Date, c.Measure.Experience)).ToList()
);
foreach (var(feature, avaValues) in features)
{
var pivotAvailability = new DatetimeSerieListModel(feature.Name, feature.Avatar);
pivotAvailability.AddItems(avaValues.OrderBy(c => c.Date)
.Select(c => (c.Date, QualityUtils.MeasureDebt(c.Measure.Availability, journey.AvailabilitySlo))).ToList());
result.AvailabilityDetail.Add(pivotAvailability);
var pivotLatency = new DatetimeSerieListModel(feature.Name, feature.Avatar);
pivotLatency.AddItems(avaValues.OrderBy(c => c.Date)
.Select(c => (c.Date, QualityUtils.MeasureLatencyDebt(c.Measure.Latency, journey.LatencySlo))).ToList());
result.LatencyDetail.Add(pivotLatency);
var pivotExperience = new DatetimeSerieListModel(feature.Name, feature.Avatar);
pivotExperience.AddItems(avaValues.OrderBy(c => c.Date)
.Select(c => (c.Date, QualityUtils.MeasureDebt(c.Measure.Experience, journey.ExperienceSlo))).ToList());
result.ExperienceDetail.Add(pivotExperience);
}
return(result);
}
public async Task <JourneyGetRp> GetJourneyByIdWithAvailabilities(int id, DateTime start, DateTime end)
{
var period = new DatePeriodValue(start, end);
var(before, previous) = period.CalculateBeforePreviousDates();
var entity = await this._dbContext.FullJourneyWithSourceItems(id, before.Start, end);
if (entity == null)
{
return(null);
}
var model = this._mapper.Map <JourneyGetRp>(entity);
foreach (var map in entity.FeatureMap)
{
var tmp = this._mapper.Map <SequenceFeatureGetListRp>(map.Feature);
var measure = map.Feature.Measure(new DatePeriodValue(start, end));
tmp.LoadMeasure(measure);
tmp.MapId = map.Id.Value;
model.Features.Add(tmp);
}
model.LoadMeasure(entity.Measure(new DatePeriodValue(start, end)));
model.LoadPrevious(entity.Measure(new DatePeriodValue(previous.Start, previous.End)));
model.LoadBefore(entity.Measure(new DatePeriodValue(before.Start, before.End)));
return(model);
}
private MultiSeriesGetRp InternalGetDailyJourneySeries(ProductEntity product, DateTime start, DateTime end)
{
var result = new MultiSeriesGetRp
{
Start = start,
End = end,
Name = product.Name,
Avatar = product.Avatar
};
var period = new DatePeriodValue(start, end);
var agg = new ProductDailyAggregate(product, period);
var response = agg.MeasureQuality();
var debtSerie = new MultiSerieItemGetRp()
{
Name = "Debt",
Avatar = product.Avatar
};
foreach (var item in response.OrderBy(c => c.Date))
{
debtSerie.Items.Add(new SeriesItemGetRp(item.Date, item.Measure.AvailabilityDebt));
}
result.Series.Add(debtSerie);
return(result);
}
public double?MeasureDailyCorrelation(DatePeriodValue period = null)
{
if (this.SourceItems.Count == 0)
{
return(0);
}
else
{
if (period == null)
{
period = new DatePeriodValue(
this.SourceItems.Min(c => c.Target),
this.SourceItems.Max(c => c.Target)
);
}
var groups = this.SourceItems.Where(c => c.Target >= period.Start && c.Target <= period.End)
.GroupBy(c => c.Target.Date).OrderBy(c => c.Key);
var totals = groups.Select(c => c.Sum(c => (double)c.Total.GetValueOrDefault())).ToArray();
var bad = groups.Select(c => c.Sum(c =>
(double)(c.Bad.GetValueOrDefault())
)).ToArray();
var correlation = QualityUtils.MeasureCorrelation(totals, bad);
return(correlation);
}
}
public async Task <IEnumerable <SquadGetListRp> > GetSquadsWithPoints(int customerId,
DatePeriodValue period)
{
var entities = await this._dbContext.Squads
.Include(c => c.Members)
.Where(c => c.Customer.Id.Equals(customerId)).ToListAsync();
List <SquadGetListRp> result = new List <SquadGetListRp>();
foreach (var squad in entities)
{
var tmp = await this.GetSquadByIdWithQuality(squad.Id.Value, period);
result.Add(new SquadGetListRp()
{
Id = tmp.Id,
Name = tmp.Name,
Avatar = tmp.Avatar,
Debt = tmp.Debt,
Features = tmp.Features.Select(c => c.Name).Distinct().Count(),
Members = squad.Members.Count()
});
}
return(result);
}
public void PeriodBuildSuccess()
{
var value = new DatePeriodValue(OwlveyCalendar.January201903, OwlveyCalendar.January201905);
Assert.Equal(OwlveyCalendar.January201903.Date, value.Start);
Assert.Equal(OwlveyCalendar.January201906.Add(-1 * TimeSpan.FromTicks(1)), value.End);
}
public void GenerateDaysMonth()
{
var target = new DatePeriodValue(new DateTime(2019, 4, 1), new DateTime(2019, 4, 30));
var periods = target.ToDaysPeriods();
Assert.Equal(30, periods.Count);
}
public QualityMeasureValue Measure(DatePeriodValue period = null)
{
var temp = new List <QualityMeasureValue>();
bool hasData = false;
foreach (var indicator in this.Indicators)
{
QualityMeasureValue quality = indicator.Source.Measure(period);
if (quality.HasData)
{
temp.Add(quality);
hasData = true;
}
}
if (hasData)
{
return(QualityMeasureValue.Merge(temp));
}
else
{
return(new QualityMeasureValue(false));
}
}
public void GenerateYear()
{
var value = new DateTime(2019, 1, 15);
var target = DatePeriodValue.ToYearFromStart(value);
Assert.Equal(365, target.Days);
}
public async Task <MemoryStream> ExportItems(int productId, DatePeriodValue period)
{
var stream = new MemoryStream();
using (var package = new ExcelPackage(stream))
{
var sources = await this._dbContext.Sources.Where(c => c.ProductId == productId).ToListAsync();
var ids = sources.Select(c => c.Id.Value).Distinct().ToList();
var sourceItems = await this._dbContext.GetSourceItems(ids, period.Start, period.End);
var aggregate = new Builders.SourceItemsExportBuilder(sources, sourceItems);
var model = aggregate.Execute();
var sourceSheet = package.Workbook.Worksheets.Add("Sources");
sourceSheet.Cells.LoadFromCollection(model.sources, true);
var sourceItemsSheet = package.Workbook.Worksheets.Add("SourceItems");
sourceItemsSheet.Cells.LoadFromCollection(model.items, true);
package.Save();
}
stream.Position = 0;
return(stream);
}
public async Task <SourceGetRp> GetByIdWithDetail(int id, DatePeriodValue period)
{
var entity = await this._dbContext.Sources
.SingleOrDefaultAsync(c => c.Id == id);
var product = await this._dbContext.FullLoadProduct(entity.ProductId);
entity = product.Sources.Where(c => c.Id == id).Single();
var result = this._mapper.Map <SourceGetRp>(entity);
if (entity != null)
{
var sourceItems = await this._dbContext.GetSourceItems(entity.Id.Value, period.Start, period.End);
var ids = sourceItems.Select(c => c.Id).ToList();
entity.SourceItems = sourceItems;
result.Quality = entity.Measure();
result.Features = this._mapper.Map <IEnumerable <FeatureGetListRp> >(entity.GetFeatures());
result.Journeys = this._mapper.Map <IEnumerable <JourneyGetListRp> >(entity.GetJourneys());
result.Debt = entity.MeasureDebt(period);
result.Daily = entity.GetDailySeries(period);
}
return(result);
}
public async Task SourceItemBatchInteractions()
{
var container = ComponentTestFactory.BuildContainer();
var customer = MockUtils.GenerateRandomName();
var product = MockUtils.GenerateRandomName();
var context = container.GetInstance <FalconDbContext>();
var(_, productId) = await ComponentTestFactory.BuildCustomerProduct(container,
customerName : customer, productName : product);
var itemComponent = container.GetInstance <SourceItemComponent>();
var sourceComponent = container.GetInstance <SourceComponent>();
var items = await itemComponent.CreateInteractionItems(new SourceItemBatchPostRp()
{
Customer = customer, Product = product, Kind = Core.Entities.SourceKindEnum.Interaction,
Items = new List <string>()
{
"Controller::sendAdvisor,2020-03-03 01:00:00,2020-03-03 01:59:59,24,22,20,14164.86935",
"Controller::sendAdvisor,2020-03-04 01:00:00,2020-03-04 01:59:59,24,23,21,14164.86935",
"Controller::getAdvisorInfo,2020-03-03 00:00:00,2020-03-03 23:59:59,200,196,195,18474.299049999998"
}
});
Assert.Equal(2, items.SourceCreated);
Assert.Equal(9, items.ItemsCreated);
var sourceSendAdvisor = await sourceComponent.GetByName(productId, "Controller::sendAdvisor");
Assert.NotNull(sourceSendAdvisor);
var period = new DatePeriodValue(DateTime.Parse("2020-03-03 00:00:00"),
DateTime.Parse("2020-03-03 23:59:59"));
var itemsSendAdvisor = await itemComponent.GetAvailabilityItems(sourceSendAdvisor.Id,
period
);
var all = context.SourcesItems.Where(c => c.SourceId == sourceSendAdvisor.Id && c.Group == Core.Entities.SourceGroupEnum.Availability &&
c.Target >= period.Start && c.Target <= period.End).ToList();
Assert.Equal(0.917m, itemsSendAdvisor.First().Measure);
var itemsSendAdvisorExperience = await itemComponent.GetExperienceItems(sourceSendAdvisor.Id,
new DatePeriodValue(
DateTime.Parse("2020-03-03 00:00:00"),
DateTime.Parse("2020-03-03 23:59:59")
)
);
Assert.Equal(0.833m, itemsSendAdvisorExperience.First().Measure);
var itemsSendAdvisorLatency = await itemComponent.GetLatencyItems(sourceSendAdvisor.Id,
new DatePeriodValue(DateTime.Parse("2020-03-03 00:00:00"),
DateTime.Parse("2020-03-03 23:59:59"))
);
Assert.Equal(14164.86935m, itemsSendAdvisorLatency.First().Measure);
}
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 <GraphGetRp> GetGraphExperience(int productId, DatePeriodValue period)
{
GraphGetRp result = new GraphGetRp();
var product = await this._dbContext.FullLoadProductWithSourceItems(productId, period.Start, period.End);
result.Name = product.Name;
result.Id = product.Id.Value;
result.Avatar = product.Avatar;
foreach (var journey in product.Journeys)
{
var measure = journey.Measure();
var snode = new GraphNode
{
Id = string.Format("journey_{0}", journey.Id),
Avatar = journey.Avatar,
Name = string.Format("{0} [ {1} | {2} ]", journey.Name,
Math.Round(journey.ExperienceSlo, 2),
Math.Round(measure.Experience, 2)),
Value = measure.Experience,
Group = "journeys",
Slo = journey.ExperienceSlo,
Budget = measure.ExperienceErrorBudget
};
result.Nodes.Add(snode);
foreach (var map in journey.FeatureMap)
{
var featureMeasure = map.Feature.Measure();
var Id = string.Format("feature_{0}", map.Feature.Id);
var fnode = result.Nodes.SingleOrDefault(c => c.Id == Id);
if (fnode == null)
{
fnode = new GraphNode
{
Id = Id,
Avatar = map.Feature.Avatar,
Name = map.Feature.Name,
Value = featureMeasure.Experience,
Group = "features"
};
result.Nodes.Add(fnode);
}
var fedge = new GraphEdge()
{
From = snode.Id,
To = fnode.Id,
Value = QualityUtils.MeasureBudget(fnode.Value, journey.ExperienceSlo),
Tags = new Dictionary <string, object>()
{
{ "Latency", fnode.Value }
}
};
result.Edges.Add(fedge);
}
}
return(result);
}
public DebtMeasureValue MeasureDebt(DatePeriodValue period = null)
{
QualityMeasureValue measure = this.Measure(period);
var result = new DebtMeasureValue();
var measures = this.JourneyMaps.Select(c => measure.MeasureDebt(c.Journey.GetSLO())).ToList();
result.AddRange(measures);
return(result);
}
public static async Task <SourceEntity> GetSourceWithItems(this FalconDbContext context,
int sourceId, DatePeriodValue period)
{
var source = await context.Sources.SingleOrDefaultAsync(c => c.Id == sourceId);
source.SourceItems = await context.GetSourceItems(sourceId, period.Start, period.End);
return(source);
}
public void GetDatesSuccess()
{
var value = new DatePeriodValue(OwlveyCalendar.January201903, OwlveyCalendar.January201905);
var intervals = value.GetDates();
Assert.Equal(3, intervals.Count());
Assert.Equal(OwlveyCalendar.January201903, intervals.ElementAt(0));
Assert.Equal(OwlveyCalendar.January201904, intervals.ElementAt(1));
Assert.Equal(OwlveyCalendar.January201905, intervals.ElementAt(2));
}
public DebtMeasureValue Measure(DatePeriodValue period = null)
{
var measure = new DebtMeasureValue();
foreach (var journey in this.Journeys)
{
measure.Add(journey.Measure(period));
}
return(measure);
}
public async Task <IActionResult> GetDailyGroups(int productId, string group, DateTime?start, DateTime?end)
{
if (!start.HasValue || !end.HasValue)
{
return(this.BadRequest("start is required"));
}
var period = new DatePeriodValue(start.Value, end.Value);
var model = await this._journeyQueryComponent.GetJourneyGroupDailyErrorBudget(productId, period, group);
return(this.Ok(model));
}
public ScalabilityMeasureAggregate(IEnumerable <SourceItemEntity> items, DatePeriodValue period = null)
{
if (period != null)
{
this.Items = items.Where(c => c.Target >= period.Start && c.Target <= period.End);
}
else
{
this.Items = items;
}
}
public async Task <JourneyGroupListRp> GetJourneyGroupReport(int productId, DatePeriodValue period)
{
var entity = await this._dbContext.FullLoadProductWithSourceItems(productId, period.Start, period.End);
var result = new JourneyGroupListRp();
var days = period.ToDaysPeriods();
foreach (var group in entity.Journeys.GroupBy(c => c.Group))
{
var serie = new MultiSerieItemGetRp()
{
Name = group.Key
};
foreach (var day in days)
{
serie.Items.Add(new SeriesItemGetRp(day.Start,
group.Select(c => c.Measure(day).AvailabilityDebt).Sum()));
}
var measures = group.Select(c =>
new { measure = c.Measure(period) }).ToList();
var temp = new JourneyGroupListRp.JourneyGrouptem
{
Name = group.Key,
AvailabilitySloAvg = QualityUtils.CalculateAverage(group.Select(c => c.AvailabilitySlo)),
AvailabilitySloMin = QualityUtils.CalculateMinimum(group.Select(c => c.AvailabilitySlo)),
LatencySloAvg = QualityUtils.CalculateAverage(group.Select(c => c.LatencySlo)),
LatencySloMin = QualityUtils.CalculateMinimum(group.Select(c => c.LatencySlo)),
ExperienceSloAvg = QualityUtils.CalculateAverage(group.Select(c => c.ExperienceSlo)),
ExperienceSloMin = QualityUtils.CalculateMinimum(group.Select(c => c.ExperienceSlo))
};
temp.AvailabilityAvg = QualityUtils.CalculateAverage(measures.Select(c => c.measure.Availability));
temp.AvailabilityMin = QualityUtils.CalculateMinimum(measures.Select(c => c.measure.Availability));
temp.LatencyAvg = QualityUtils.CalculateAverage(measures.Select(c => c.measure.Latency));
temp.LatencyMin = QualityUtils.CalculateMinimum(measures.Select(c => c.measure.Latency));
temp.ExperienceAvg = QualityUtils.CalculateAverage(measures.Select(c => c.measure.Experience));
temp.ExperienceMin = QualityUtils.CalculateMinimum(measures.Select(c => c.measure.Experience));
temp.Count = group.Count();
temp.AvailabilityDebt = measures.Sum(c => c.measure.AvailabilityDebt);
temp.ExperienceDebt = measures.Sum(c => c.measure.ExperienceDebt);
temp.LatencyDebt = measures.Sum(c => c.measure.LatencyDebt);
result.Series.Add(serie);
result.Items.Add(temp);
}
return(result);
}
public async Task <ScalabilitySourceGetRp> GetScalability(int sourceId, DatePeriodValue period)
{
var source = await this._dbContext.GetSourceWithItems(sourceId, period);
var model = new ScalabilitySourceGetRp
{
Period = period,
};
var agg = new ScalabilityMeasureAggregate(source.SourceItems);
(model.DailyCorrelation, model.DailyTotal, model.DailyBad, model.DailyIntercept,
model.DailySlope, model.DailyR2, model.DailyInteractions) = agg.Measure();
return(model);
}
public async Task <IActionResult> GetGraphExperience(int id, DateTime?start, DateTime?end)
{
DatePeriodValue period = new DatePeriodValue(start.Value, end.Value);
if (period.IsValid())
{
GraphGetRp result = await this._productQueryComponent.GetGraphExperience(id, period);
return(this.Ok(result));
}
else
{
return(this.BadRequest());
}
}
public async Task <DatetimeSerieModel> GetJourneyGroupDailyErrorBudget(int productId,
DatePeriodValue period, string group)
{
var product = await this._dbContext.FullLoadProductWithGroupAndSourceItems(productId, group, period.Start, period.End);
var result = new DatetimeSerieModel();
result.Start = period.Start;
result.End = period.End;
result.Name = product.Name;
var days = period.ToDaysPeriods();
foreach (var item in days)
{
var temp = product.Journeys.Select(c => c.Measure(item));
result.Availability.Items.Add(new DatetimeSerieItemModel(item.Start, temp.Sum(c => c.AvailabilityDebt)));
result.Latency.Items.Add(new DatetimeSerieItemModel(item.Start, temp.Sum(c => c.LatencyDebt)));
result.Experience.Items.Add(new DatetimeSerieItemModel(item.Start, temp.Sum(c => c.ExperienceDebt)));
}
foreach (var journey in product.Journeys)
{
var temp = new DatetimeSerieListModel()
{
Name = journey.Name,
Avatar = journey.Avatar
};
temp.AddItems(days.Select(c => (c.Start, journey.Measure(c).AvailabilityDebt)).ToList());
result.AvailabilityDetail.Add(temp);
var tempL = new DatetimeSerieListModel()
{
Name = journey.Name,
Avatar = journey.Avatar
};
tempL.AddItems(days.Select(c => (c.Start, journey.Measure(c).LatencyDebt)).ToList());
result.LatencyDetail.Add(tempL);
var tempE = new DatetimeSerieListModel()
{
Name = journey.Name,
Avatar = journey.Avatar
};
tempE.AddItems(days.Select(c => (c.Start, journey.Measure(c).ExperienceDebt)).ToList());
result.ExperienceDetail.Add(tempE);
}
return(result);
}
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 <CustomerGetRp> GetCustomerByIdWithQuality(int id, DatePeriodValue period)
{
var entities = await this._dbContext.Customers.Where(c => c.Id.Equals(id)).ToListAsync();
var entity = entities.FirstOrDefault();
if (entity == null)
{
return(null);
}
var result = this._mapper.Map <CustomerGetRp>(entity);
result.Products = await this._productQueryComponent.GetProductsWithInformation(id, period);
return(result);
}
public async Task <IEnumerable <CustomerGetListRp> > GetCustomersQuality(DatePeriodValue period)
{
var entities = await this._dbContext.Customers.Include(c => c.Products).ToListAsync();
var result = new List <CustomerGetListRp>();
foreach (var customer in entities)
{
var t = this._mapper.Map <CustomerGetListRp>(customer);
var temp = await this._productQueryComponent.GetProductsWithInformation(customer.Id.Value, period);
t.Debt.Add(temp.Debt);
t.PreviousDebt.Add(temp.PreviousDebt);
t.BeforeDebt.Add(temp.BeforeDebt);
result.Add(t);
}
return(result);
}
public async Task <FeatureQualityGetRp> GetFeatureByIdWithQuality(int id,
DatePeriodValue period)
{
var feature = await this._dbContext.Features
.Where(c => c.Id == id)
.SingleOrDefaultAsync();
if (feature == null)
{
return(null);
}
var product = await this._dbContext.FullLoadProduct(feature.ProductId);
feature = product.Features.Where(c => c.Id == id).Single();
foreach (var indicator in feature.Indicators)
{
var sourceItems = await this._dbContext.GetSourceItems(indicator.SourceId, period.Start, period.End);
indicator.Source.SourceItems = sourceItems;
}
var model = this._mapper.Map <FeatureQualityGetRp>(feature);
var measure = feature.Measure();
model.LoadQuality(measure);
model.Debt = feature.MeasureDebt();
foreach (var indicator in feature.Indicators)
{
var tmp = this._mapper.Map <IndicatorDetailRp>(indicator);
tmp.Measure = indicator.Source.Measure();
model.Indicators.Add(tmp);
}
foreach (var map in feature.JourneyMaps)
{
var tmp = this._mapper.Map <JourneyGetListRp>(map.Journey);
model.Journeys.Add(tmp);
}
model.Incidents = this._mapper.Map <List <IncidentGetListRp> >(await this._dbContext.GetIncidentsByFeature(feature.Id.Value));
return(model);
}
public JourneyQualityMeasureValue Measure(DatePeriodValue period = null)
{
var resultAvailability = new List <decimal>();
var resultLatency = new List <decimal>();
var resultExperience = new List <decimal>();
foreach (var map in this.FeatureMap)
{
QualityMeasureValue measure;
if (period != null)
{
measure = map.Feature.Measure(period);
}
else
{
measure = map.Feature.Measure();
}
if (measure.HasData)
{
resultAvailability.Add(measure.Availability);
resultLatency.Add(measure.Latency);
resultExperience.Add(measure.Experience);
}
}
if (resultAvailability.Count > 0 || resultExperience.Count > 0 || resultLatency.Count > 0)
{
return(new JourneyQualityMeasureValue(
this.AvailabilitySlo,
this.LatencySlo,
this.ExperienceSlo,
QualityUtils.CalculateMinimum(resultAvailability, round: 3),
QualityUtils.CalculateMaximum(resultLatency, round: 3),
QualityUtils.CalculateMinimum(resultExperience, round: 3)));
}
else
{
return(new JourneyQualityMeasureValue(this.AvailabilitySlo,
this.LatencySlo, this.ExperienceSlo, false));
}
}
