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)); } }