Example #1
0
        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));
        }
Example #2
0
        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);
        }