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 async Task <IActionResult> GetSquadGraph(int id, DateTime?start, DateTime?end)
{
if (start.HasValue && end.HasValue)
{
GraphGetRp result = await this._customerQueryComponent.GetSquadsGraph(id, new DatePeriodValue(start.Value, end.Value));
return(this.Ok(result));
}
else
{
return(this.BadRequest());
}
}
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 <GraphGetRp> GetSquadsGraph(int customerId, DatePeriodValue period)
{
GraphGetRp result = new GraphGetRp();
var root = await this._dbContext.Customers.Include(c => c.Products).Where(c => c.Id == customerId).SingleOrDefaultAsync();
var temp = new List <ProductEntity>();
foreach (var item in root.Products)
{
var p = await this._dbContext.FullLoadProductWithSourceItems(item.Id.Value, period.Start, period.End);
temp.Add(p);
}
root.Products = temp;
result.Name = root.Name;
result.Id = root.Id.Value;
result.Avatar = root.Avatar;
var squads = await this._dbContext.Squads.Where(c => c.Customer.Id.Equals(customerId)).ToListAsync();
var squadsDetail = new List <SquadQualityGetRp>();
foreach (var item in squads)
{
var detail = await this._squadQueryComponent.GetSquadByIdWithQuality(item.Id.Value,
period);
squadsDetail.Add(detail);
}
foreach (var node in squadsDetail)
{
var snode = new GraphNode
{
Id = string.Format("squad_{0}", node.Id),
Avatar = node.Avatar,
Name = node.Name,
Value = node.Debt.Availability,
Group = "squads",
};
result.Nodes.Add(snode);
foreach (var feature in node.Features)
{
var feature_id = string.Format("feature_{0}", feature.Id);
var fnode = result.Nodes.SingleOrDefault(c => c.Id == feature_id);
if (fnode == null)
{
fnode = new GraphNode
{
Id = feature_id,
Avatar = feature.Avatar,
Name = feature.Name,
Value = feature.Debt.Availability,
Group = string.Format("features_{0}", feature.Product),
};
result.Nodes.Add(fnode);
}
var edge_squad_feature = result.Edges.Where(c => c.From == snode.Id && c.To == fnode.Id).SingleOrDefault();
if (edge_squad_feature == null)
{
var fedge = new GraphEdge()
{
From = snode.Id,
To = fnode.Id,
Value = feature.Debt.Availability
};
result.Edges.Add(fedge);
}
}
}
return(result);
}
public async Task <GraphGetRp> GetGraph(int id, DatePeriodValue period)
{
GraphGetRp result = new GraphGetRp();
var rootJourney = await this._dbContext.Journeys
.Include(c => c.FeatureMap)
.SingleAsync(c => c.Id == id);
var rootFeatures = rootJourney.FeatureMap.Select(c => c.FeatureId).Distinct().ToList();
var extendedJourneysIds = await this._dbContext.JourneyMaps
.Where(c => rootFeatures.Contains(c.FeatureId)).Select(c => c.JourneyId)
.ToListAsync();
var extendedJourneys = await this._dbContext.Journeys
.Include(c => c.FeatureMap)
.Where(c => extendedJourneysIds.Contains(c.Id.Value))
.ToListAsync();
var featuresExtended = extendedJourneys.SelectMany(c => c.FeatureMap.Select(d => d.FeatureId));
var featuresRoot = rootJourney.FeatureMap.Select(c => c.FeatureId);
var featuresIds = featuresExtended.Union(featuresRoot).ToList();
var features = await this._dbContext.Features
.Include(c => c.Indicators)
.ThenInclude(c => c.Source)
.Where(c => featuresIds.Contains(c.Id.Value))
.ToListAsync();
var sources = features.SelectMany(c => c.Indicators.Select(d => d.SourceId));
var sourceItems = await this._dbContext.GetSourceItems(sources, period.Start, period.End);
var journeys = new List <JourneyEntity>(extendedJourneys);
journeys.Add(rootJourney);
foreach (var feature in features)
{
foreach (var indicator in feature.Indicators)
{
indicator.Source.SourceItems = sourceItems.Where(c => c.SourceId == indicator.Source.Id).ToList();
}
feature.Measure();
}
foreach (var journey in journeys)
{
foreach (var map in journey.FeatureMap)
{
map.Feature = features.Where(c => c.Id == map.FeatureId).Single();
if (map.Feature.JourneyMaps.Where(
c => c.FeatureId == map.Feature.Id.Value &&
c.JourneyId == journey.Id.Value
).Count() == 0)
{
map.Feature.JourneyMaps.Add(new JourneyMapEntity()
{
FeatureId = map.Feature.Id.Value,
JourneyId = journey.Id.Value,
Feature = map.Feature,
Journey = journey
});
}
}
}
var rootMeasure = rootJourney.Measure();
var snode = new GraphNode("journeys", "journey",
rootJourney.Id.Value,
rootJourney.Avatar,
string.Format("{0} [ {1} | {2} ]", rootJourney.Name,
Math.Round(rootJourney.AvailabilitySlo, 2),
Math.Round(rootMeasure.Availability, 2))
, rootMeasure.Availability, rootJourney.AvailabilitySlo);
result.Nodes.Add(snode);
foreach (var map in rootJourney.FeatureMap)
{
var feature = map.Feature;
var Id = string.Format("feature_{0}", feature.Id);
var fnode = result.Nodes.SingleOrDefault(c => c.Id == Id);
if (fnode == null)
{
fnode = new GraphNode("features", "feature", feature.Id.Value,
feature.Avatar,
feature.Name,
feature.Measure().Availability, 0);
result.Nodes.Add(fnode);
}
var fedge = new GraphEdge(snode.Id, fnode.Id,
fnode.Value - rootJourney.AvailabilitySlo,
new Dictionary <string, object>()
{
{ "Availability", fnode.Value }
});
result.Edges.Add(fedge);
foreach (var extended in extendedJourneys)
{
var temporal = extended.FeatureMap.Where(c => c.FeatureId == feature.Id).SingleOrDefault();
if (temporal != null && temporal.Feature.JourneyMaps.Count <= 10)
{
var extendedMeasure = extended.Measure();
var temp_node = new GraphNode("journeys",
"journey",
extended.Id.Value,
extended.Avatar,
string.Format("{0} [ {1} | {2} ]", extended.Name,
Math.Round(extended.AvailabilitySlo, 2),
Math.Round(extendedMeasure.Availability, 2))
, extendedMeasure.Availability, extended.AvailabilitySlo);
if (result.Nodes.Count(c => c.Id == temp_node.Id) == 0)
{
result.Nodes.Add(temp_node);
var tmp_edge = new GraphEdge(
temp_node.Id,
fnode.Id,
fnode.Value - extended.AvailabilitySlo,
new Dictionary <string, object>()
{
{ "Availability", fnode.Value }
});
result.Edges.Add(tmp_edge);
}
}
}
}
return(result);
}
