private GraphXAxisRootDto GetRoot(DimensionTree allDimensionsTree, DimensionDto xDimension, Measure measure,
IEnumerable <DimensionValueDto> filteredXValues, List <FlatDimensionDto> filters,
DimensionValueDto xValue = null, DimensionDto legendDimension = null)
{
GraphXAxisRootDto xAxisRoot;
if (legendDimension == null)
{
xAxisRoot = new DrilldownGraphXAxisRootDto
{
Id = xValue?.Id ?? 0,
Name = xValue?.Value ?? string.Empty,
XAxisLeaves = new List <GraphXAxisLeafDto>()
};
var leaf = GetLeaf(allDimensionsTree, xDimension, xValue, measure, filters);
xAxisRoot.XAxisLeaves.Add(leaf);
}
else
{
xAxisRoot = new GroupedGraphXAxisRootDto
{
Id = xValue?.Id ?? 0,
Name = xValue?.Value ?? string.Empty,
XAxisLeaves = new List <GraphXAxisLeafDto>()
};
foreach (var dimValue in filteredXValues)
{
var leaf = GetLeaf(allDimensionsTree, xDimension, dimValue, measure, filters, legendDimension);
xAxisRoot.XAxisLeaves.Add(leaf);
}
}
return(xAxisRoot);
}
private void SetDimensionAndValuesHierarchy(DimensionDto dimension, List <DimensionValueDto> allDimensionsValues)
{
foreach (var value in dimension.DimensionValues)
{
var broaderValueTriple = _graph.GetTriplesWithSubjectPredicate
(_graphHelper.CreateUriNode(UriFactory.Create(value.RdfUri)), RdfConstants.Broader).SingleOrDefault();
if (broaderValueTriple != null)
{
var broaderValue = allDimensionsValues.Single(dv => dv.RdfUri.Equals(broaderValueTriple.Object.ToString()));
var parentDimension = broaderValue.Dimension;
if (dimension.ParentDimension == null)
{
dimension.ParentDimension = parentDimension;
}
else
{
if (dimension.ParentDimension != parentDimension)
{
throw new InvalidDataException($"Invalid hierarchy. Not clear if parent of dimension {dimension.Name} is {dimension.ParentDimension.Name} or {parentDimension.Name}.");
}
}
value.ParentDimensionValue = broaderValue;
}
}
}
private List <DimensionValueDto> GetDimensionValues(DimensionDto dimension)
{
var values = new List <Tuple <string, string> >();
var observations = _graph.GetTriplesWithPredicateObject(RdfConstants.Type, RdfConstants.Observation);
foreach (var observation in observations)
{
// Find triple where observation subject is subject and dimension is predicate
var observationOfDimension = _graph.GetTriplesWithSubjectPredicate
(observation.Subject, _graphHelper.CreateUriNode(UriFactory.Create(dimension.RdfUri))).SingleOrDefault();
if (observationOfDimension == null)
{
throw new InvalidDataException($"Observation {observation.Subject} has no value of dimension {dimension.Name}. ");
}
var objectUri = observationOfDimension.Object.ToString();
if (!values.Select(v => v.Item1).Contains(objectUri))
{
values.Add(Tuple.Create(objectUri, RdfConstants.GetNodeName(_graph, objectUri)));
}
}
return(values.Select(value => new DimensionValueDto
{
Dimension = dimension,
RdfUri = value.Item1,
Value = value.Item2
}).ToList());
}
public GroupedGraphDto GetGroupedGraph(DimensionTree allDimensionsTree, TreeDimensionDto xDimension,
DimensionDto legendDimension, Measure measure, List <FlatDimensionDto> filterDimensions, bool group)
{
var graph = new GroupedGraphDto
{
Name = $"Grouped graph of {measure.Name} by {xDimension.Name} and {legendDimension.Name}",
Roots = new List <GraphXAxisRootDto>()
};
var xDimIsRoot = allDimensionsTree.IsRoot(xDimension.Id);
var filteredXValues = GetFilteredValues(allDimensionsTree, xDimension, filterDimensions);
// if x-dimension is root dimension, its values will be leaves
// x-dim values will be also leaves if graph should not be grouped
if (xDimIsRoot || !group)
{
graph.Roots.Add(GetRoot(allDimensionsTree, xDimension, measure, filteredXValues, filterDimensions, null, legendDimension));
}
// otherwise its values will be root and its parents values will be leaves
else
{
foreach (var xValue in filteredXValues)
{
graph.Roots.Add(GetParentRoot(allDimensionsTree, xDimension, measure, xValue, filterDimensions, legendDimension));
}
}
return(graph);
}
public DimensionDto DimensionToDto(Dimension dimension)
{
var dto = new DimensionDto();
dto.Description = dimension.Description;
dto.DisplayName = dimension.DisplayName;
dto.DataType = dimension.DataType;
dto.Mnemonic = dimension.Mnemonic;
dto.DimensionId = dimension.DimensionId;
dto.Group = dimension.Group;
return(dto);
}
public ProductWithIdDto(Product product)
{
Id = (Guid)product.Id;
Name = (string)product.Name;
Description = (string)product.Description;
Dimension =
new DimensionDto
{
Length = product.Dimension.Length.ToCm(),
Width = product.Dimension.Width.ToCm(),
Height = product.Dimension.Height.ToCm()
};
Weight = product.Weight.ToGrams();
CategoryIds =
product.CategoryIds
.Select(id => (int)id)
.ToList();
}
public List <DimensionValueDto> GetValuesOfDimension(DimensionDto dimension, Column selector = null)
{
DataTable table = selector == null
? QueryBuilder.Select(dimension.TableName, new List <Column>())
: QueryBuilder.Select(dimension.TableName, selector);
var valuesToReturn = (from DataRow row
in table.Rows
select new DimensionValueDto
{
Id = Convert.ToInt32(row["Id"]),
Value = dimension.Type == typeof(DateTime)
? ((DateTime)row[Constants.String.Value]).ToString("dd.MM.yyyy")
: row[Constants.String.Value].ToString()
})
.ToList();
return(valuesToReturn);
}
private IEnumerable <DimensionValueDto> GetDimensionValues(DimensionDto dimension, Triple triple)
{
var rangeTriple = _graph.GetTriplesWithSubjectPredicate(triple.Object, RdfConstants.Range).SingleOrDefault();
if (rangeTriple.Object.Equals(RdfConstants.Concept))
{
var codeList = _graph.GetTriplesWithSubjectPredicate(triple.Object, RdfConstants.Codelist).Single().Object;
var values = _graph.GetTriplesWithPredicateObject(RdfConstants.InScheme, codeList);
foreach (var value in values)
{
yield return(new DimensionValueDto
{
Dimension = dimension,
Value = RdfConstants.GetNodeName(_graph, value.Subject),
RdfUri = value.Subject.ToString()
});
}
}
}
public async Task <IActionResult> ChangeDimensionAsync(Guid id, [FromBody] DimensionDto dto)
{
try
{
var dimension = dto.Validate();
await _useCase.ChangeDimensionsAsync(new ProductId(id), dimension.Value);
return(Ok());
}
catch (NotFoundException <ProductId> )
{
return(NotFound());
}
catch (ValidationException)
{
return(BadRequest());
}
}
public IEnumerable <DimensionValueDto> GetCorrespondingValues(DimensionTree tree, int dimensionId, DimensionDto child)
{
var childDimension = tree.GetDimensionDto(child.Id);
var oldIds = new List <int>();
oldIds.AddRange(child.DimensionValues.Select(dv => dv.Id));
var newIds = new List <int>();
while (childDimension.Id != dimensionId)
{
var parentDimension = tree.GetDimensionDto((int)childDimension.ParentId);
var selectors = new List <List <Column> >
{
oldIds.Select(childId => new Column {
Name = childDimension.IdName, Value = childId.ToString()
})
.ToList()
};
oldIds = newIds;
var currentIds = QueryBuilder.Select(parentDimension.TableName, selectors);
newIds.Clear();
newIds.AddRange(from DataRow currentId in currentIds.Rows select Convert.ToInt32(currentId[Constants.String.Id]));
childDimension = parentDimension;
}
var ret = new List <DimensionValueDto>();
foreach (var newId in newIds)
{
ret.AddRange(GetValuesOfDimension(tree.GetDimensionDto(dimensionId), new Column {
Name = Constants.String.Id, Value = newId.ToString()
}));
}
return(ret);
}
private GroupedChartViewModel GetGroupedChart(DimensionTree tree, TreeDimensionDto xDimension, DimensionDto legendDimension,
Measure measure, List <FlatDimensionDto> filters, bool group)
{
var groupedGraphDto = _graphService.GetGroupedGraph(tree, xDimension, legendDimension, measure, filters, group);
return(_browseCubeMapper.Map(groupedGraphDto));
}
public DimensionResponse(DimensionDto dimensionDto)
{
DimensionDtos = new List<DimensionDto> { dimensionDto };
}
private IEnumerable <DimensionValueDto> GetFilteredValues(DimensionTree allDimensionsTree, DimensionDto dimension,
List <FlatDimensionDto> filterDimensions, List <DimensionValueDto> dimensionValues = null)
{
var dimensionFilter = filterDimensions.SingleOrDefault(fd => fd.Id == dimension.Id);
if (dimensionValues == null)
{
dimensionValues = _querier.GetValuesOfDimension(dimension);
}
var childrenInFilters = filterDimensions.Where(fd => allDimensionsTree.GetDimensionDto(dimension.Id).GetSubtreeIds().Contains(fd.Id)).ToList();
var valuesFromFilter = new List <DimensionValueDto>();
var valuesFromAncestors = new List <DimensionValueDto>();
if (dimensionFilter != null)
{
valuesFromFilter =
dimensionFilter.DimensionValues
.Select(filterValue => dimensionValues.SingleOrDefault(v => v.Id == filterValue.Id))
.Where(v => v != null).ToList();
}
if (childrenInFilters.Any())
{
foreach (var child in childrenInFilters)
{
var dimensionCorrespondingValues = _querier.GetCorrespondingValues(allDimensionsTree, dimension.Id, child);
foreach (var correspondingValue in dimensionCorrespondingValues)
{
if (dimensionValues.Select(dv => dv.Id).Contains(correspondingValue.Id))
{
valuesFromAncestors.Add(correspondingValue);
}
}
}
}
if (valuesFromFilter.Any() && valuesFromAncestors.Any())
{
var filteredValues = valuesFromFilter.Select(v1 => v1.Id)
.Where(v => valuesFromAncestors.Select(v2 => v2.Id)
.Contains(v)).ToList();
return(filteredValues.Any() ? dimensionValues.Where(xdv => filteredValues.Contains(xdv.Id)) : dimensionValues);
}
else if (valuesFromFilter.Any())
{
return(valuesFromFilter);
}
else if (valuesFromAncestors.Any())
{
return(valuesFromAncestors);
}
return(dimensionValues);
}
private GraphXAxisLeafDto GetLeaf(DimensionTree allDimensionsTree, DimensionDto xDimension, DimensionValueDto xValue, Measure measure,
List <FlatDimensionDto> filters, DimensionDto legendDimension = null)
{
if (legendDimension == null)
{
var conditionDto = new FlatDimensionDto
{
Id = xDimension.Id,
DatasetName = xDimension.DatasetName,
Name = xDimension.Name,
DimensionValues = new List <DimensionValueDto> {
new DimensionValueDto {
Id = xValue.Id
}
}
};
return(new DrilldownGraphXAxisLeafDto
{
Id = xValue.Id,
Name = xValue.Value,
Value = _querier.GetFactTableSum(allDimensionsTree,
filters, new[] { conditionDto }.ToList(), measure)
});
}
var leaf = new GroupedGraphXAxisLeafDto
{
Id = xValue.Id,
Name = xValue.Value,
LegendValues = new List <GraphLegendValueDto>()
};
var legendFilteredValues = GetFilteredValues(allDimensionsTree, legendDimension, filters, legendDimension.DimensionValues);
foreach (var legendValue in legendFilteredValues)
{
var xDimensionDto = new FlatDimensionDto
{
Id = xDimension.Id,
DatasetName = xDimension.DatasetName,
Name = xDimension.Name,
DimensionValues = new[] { new DimensionValueDto {
Id = xValue.Id
} }.ToList()
};
var legendDimensionDto = new FlatDimensionDto
{
Id = legendDimension.Id,
DatasetName = legendDimension.DatasetName,
Name = legendDimension.Name,
DimensionValues = new[] { new DimensionValueDto {
Id = legendValue.Id
} }.ToList()
};
leaf.LegendValues.Add(new GraphLegendValueDto
{
Legend = new GraphLegendDto
{
Id = legendValue.Id,
Name = legendValue.Value
},
Value = _querier.GetFactTableSum(allDimensionsTree, filters, new[] { xDimensionDto, legendDimensionDto }.ToList(), measure)
});
}
return(leaf);
}
private GraphXAxisRootDto GetParentRoot(DimensionTree allDimensionsTree, TreeDimensionDto childDimension,
Measure measure, DimensionValueDto xValue, List <FlatDimensionDto> filters, DimensionDto legendDimension = null)
{
GraphXAxisRootDto xAxisRoot;
if (legendDimension == null)
{
xAxisRoot = new DrilldownGraphXAxisRootDto
{
Id = xValue.Id,
Name = xValue.Value,
XAxisLeaves = new List <GraphXAxisLeafDto>()
};
}
else
{
xAxisRoot = new GroupedGraphXAxisRootDto
{
Id = xValue.Id,
Name = xValue.Value,
XAxisLeaves = new List <GraphXAxisLeafDto>()
};
}
var parentDimension = allDimensionsTree.GetDimensionDto((int)childDimension.ParentId);
var xDimValues = _querier.GetValuesOfDimension(
parentDimension, new Column {
Name = childDimension.IdName, Value = xValue.Id.ToString()
});
var filteredValues = GetFilteredValues(allDimensionsTree, parentDimension, filters, xDimValues);
foreach (var dimValue in filteredValues)
{
var leaf = GetLeaf(allDimensionsTree, allDimensionsTree.GetDimensionDto((int)childDimension.ParentId), dimValue, measure, filters, legendDimension);
xAxisRoot.XAxisLeaves.Add(leaf);
}
return(xAxisRoot);
}
