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));
}
private DrilldownChartViewModel GetDrilldownChart(DimensionTree tree, TreeDimensionDto xDimension, Measure measure,
List <FlatDimensionDto> filters, bool requireDrilldownChart)
{
var drilldownGraphDto = _graphService.GetDrilldownGraph(tree, xDimension, measure, filters, requireDrilldownChart);
return(_browseCubeMapper.Map(drilldownGraphDto));
}
public DrilldownGraphDto GetDrilldownGraph(DimensionTree allDimensionsTree, TreeDimensionDto xDimension,
Measure measure, List <FlatDimensionDto> filters, bool requireDrilldownChart)
{
var graph = new DrilldownGraphDto
{
DimensionName = xDimension.Name,
Name = $"Drilldown graph of {measure.Name} by {xDimension.Name}",
Roots = new List <GraphXAxisRootDto>()
};
var xDimIsRoot = allDimensionsTree.IsRoot(xDimension.Id);
// if x-dimension is root dimension, there is no point for showing drilldown graph
if (xDimIsRoot && !requireDrilldownChart)
{
return(null);
}
// otherwise values of x dimension will be root and its parents values will be leaves
else if (!xDimIsRoot)
{
var filteredXValues = GetFilteredValues(allDimensionsTree, xDimension, filters);
foreach (var xValue in filteredXValues)
{
graph.Roots.Add(GetParentRoot(allDimensionsTree, xDimension, measure, xValue, filters));
}
}
else
{
var filteredXValues = GetFilteredValues(allDimensionsTree, xDimension, filters).ToList();
foreach (var xValue in filteredXValues)
{
graph.Roots.Add(GetRoot(allDimensionsTree, xDimension, measure, filteredXValues, filters, xValue));
}
}
return(graph);
}
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);
}
private void AddSelectListItem(TreeDimensionDto treeDimension, int level)
{
var prefix = string.Empty;
for (var i = 0; i < level; i++)
{
prefix += "- ";
}
Items.Add(new SelectListItem
{
Value = treeDimension.Id.ToString(),
Text = prefix + treeDimension.Name
});
foreach (var child in treeDimension.Children)
{
AddSelectListItem(child, level + 1); //<-- recursive
}
}
public DimensionTree ConvertToTree(IEnumerable <Dimension> dimensions, string prefix, bool populate = false)
{
var dimensionList = dimensions.ToList();
var dimensionTree = new DimensionTree(dimensionList.First().DataSet.Name, prefix);
while (dimensionTree.Count != dimensionList.Count)
{
foreach (var dimension in dimensionList)
{
var dimToAdd = new TreeDimensionDto
{
Children = new List <TreeDimensionDto>(),
Id = dimension.Id,
Name = dimension.Name,
ParentId = dimension.ParentDimension?.Id,
DatasetName = dimension.DataSet.Name,
Type = dimension.Type.ToType(),
Prefix = prefix
};
if (!dimensionTree.Contains(dimToAdd))
{
if (dimension.ParentDimension == null)
{
dimensionTree.Add(dimToAdd);
}
else
{
if (dimensionTree.Contains((int)dimension.ParentDimension.Id))
{
dimensionTree.Add(dimToAdd);
}
}
}
}
}
if (populate)
{
Populate(dimensionTree);
}
return(dimensionTree);
}
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);
}
