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 void SetupDataLayer(DimensionTree tree)
{
_treeBuilderMock.Setup(c => c.ConvertToTree(1, It.IsAny <bool>())).Returns(tree);
_dataMock.Setup(c => c.GetDimension(It.IsAny <int>()))
.Returns((int id) => new Dimension {
Name = tree.GetDimensionDto(id).Name, Id = id
});
_dataMock.Setup(c => c.GetMeasure(1)).Returns(new Measure {
Id = 1
});
_starSchemaQuerierMock.Setup(c => c.GetValuesOfDimension(It.IsAny <DimensionDto>(), It.IsAny <Column>()))
.Returns((DimensionDto dd, Column col) => tree.GetDimensionDto(dd.Id).DimensionValues);
}
private void Setup(List <Dimension> dimensions, DimensionTree tree)
{
_data.Setup(d => d.GetDimension(It.IsAny <int>())).Returns((int x) => dimensions.Single(d => d.Id == x));
_data.Setup(d => d.GetAllDimValues(It.IsAny <int>())).Returns((int x) => dimensions.Single(d => d.Id == x).DimensionValues.ToList());
_querier.Setup(q => q.GetValuesOfDimension(It.IsAny <DimensionDto>(), It.IsAny <Column>()))
.Returns(
(DimensionDto d, Column c) =>
tree.GetDimensionDto(d.Id).DimensionValues.Where(dv => c.Value == dv.Value).ToList());
}
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);
}
// Returns root dimension and list of its ids for concrete non-root dimension
private DimensionValueIds GetRootDimensionIds(DimensionTree tree, int dimensionId, int valueId)
{
var isRoot = tree.IsRoot(dimensionId);
var childDimension = tree.GetDimensionDto(dimensionId);
var oldIds = new List <int> {
valueId
};
var newIds = new List <int> {
valueId
};
while (!isRoot)
{
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;
if (childDimension.ParentId == null)
{
isRoot = true;
}
}
return(new DimensionValueIds
{
DimensionId = childDimension.Id,
ValueIds = new HashSet <int>(newIds)
});
}
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);
}
private List <List <Column> > ConvertToSelectors(DimensionTree allValues, IEnumerable <List <DimensionValueIds> > filters)
{
var selectors = new List <List <Column> >();
foreach (var filter in filters)
{
var listToAdd = new List <Column>();
foreach (var valueIds in filter)
{
listToAdd.AddRange(valueIds.ValueIds.Select(dId => new Column {
Name = allValues.GetDimensionDto(valueIds.DimensionId).IdName, Value = dId.ToString()
}));
}
selectors.Add(listToAdd);
}
return(selectors);
}
public static List <FlatDimensionDto> GetFilters(DimensionTree tree, List <Tuple <int, int[]> > dimensionsAndValues)
{
var ret = new List <FlatDimensionDto>();
foreach (var dimension in dimensionsAndValues)
{
var dimensionInTree = tree.GetDimensionDto(dimension.Item1);
ret.Add(new FlatDimensionDto
{
Id = dimensionInTree.Id,
Name = dimensionInTree.Name,
DatasetName = dimensionInTree.DatasetName,
DimensionValues = dimension.Item2.Select(dv => dimensionInTree.DimensionValues.Single(dvt => dvt.Id == dv)).ToList()
});
}
return(ret);
}
