internal TreeNode[] MapContent(DimensionCollection metadata)
{
var tnc = new List <TreeNode>();
if (metadata == null)
{
return(tnc.ToArray());
}
foreach (var dim in metadata)
{
var dimNode = new TreeNode(dim.Value.Caption);
dimNode.Tag = dim.Key;
tnc.Add(dimNode);
foreach (var h in dim.Value.Hierarchies)
{
var hNode = new TreeNode(h.Value.Caption);
hNode.Tag = h.Key;
dimNode.Nodes.Add(hNode);
foreach (var l in h.Value.Levels)
{
var lNode = new TreeNode(l.Value.Caption);
lNode.Tag = l.Key;
hNode.Nodes.Add(lNode);
foreach (var p in l.Value.Properties)
{
var propNode = new TreeNode(p.Value.Caption);
propNode.Tag = p.Key;
lNode.Nodes.Add(propNode);
}
}
}
}
return(tnc.ToArray());
}
public void FindMemberProperty()
{
var connection = TestHelper.CreateConnectionToSsas();
connection.Open();
CubeDef cube = TestHelper.GetCube(connection);
KpiCollection kpis = cube.Kpis;
MeasureCollection meas = cube.Measures;
DimensionCollection dims = cube.Dimensions;
HierarchyCollection hiers = dims[0].Hierarchies;
LevelCollection levels = hiers[0].Levels;
MemberCollection members = levels[1].GetMembers();
MemberProperty prop = members[0].MemberProperties.Find("PARENT_UNIQUE_NAME");
Assert.IsTrue(!string.IsNullOrEmpty(prop.Value.ToString()));
connection.Close();
}
/// <summary>
/// Clears Prarameters' values for all dimensions form a specific collection
/// </summary>
void ClearParameters(DimensionCollection dimensions)
{
foreach (var dimension in dimensions)
{
dashboardDesigner1.Parameters[GetParameterDataMember(dimension.DataMember)].SelectedValue = null;
}
}
public new DimensionCollection List(IEnumerable<IFilter> filters)
{
var dimensions = new DimensionCollection();
var rows = Discover(filters);
foreach (var row in rows)
dimensions.AddOrIgnore(row.UniqueName, row.Caption);
return dimensions;
}
public async Task GetDimensionsAsync()
{
var connection = TestHelper.CreateConnectionToSsas();
await connection.OpenAsync();
CubeDef cube = await TestHelper.GetCubeAsync(connection);
DimensionCollection dims = await cube.GetDimensionsAsync();
await connection.CloseAsync();
Assert.IsTrue(dims.Count == 13);
}
public new DimensionCollection List(IEnumerable <IFilter> filters)
{
var dimensions = new DimensionCollection();
var rows = Discover(filters);
foreach (var row in rows)
{
dimensions.AddOrIgnore(row.UniqueName, row.Caption);
}
return(dimensions);
}
public async Task GetMembersAsync()
{
var connection = TestHelper.CreateConnectionToSsas();
await connection.OpenAsync();
CubeDef cube = await TestHelper.GetCubeAsync(connection);
DimensionCollection dims = await cube.GetDimensionsAsync();
var hiersTasks = new List <Task <HierarchyCollection> >();
foreach (Dimension dim in dims)
{
hiersTasks.Add(dim.GetHierarchiesAsync());
}
var hiersCols = await Task.WhenAll(hiersTasks);
var hiers = hiersCols.SelectMany(x => x);
Debug.WriteLine(hiers.Count());
var levelsTasks = new List <Task <LevelCollection> >();
foreach (var hier in hiers)
{
levelsTasks.Add(hier.GetLevelsAsync());
}
var levelsCols = await Task.WhenAll(levelsTasks);
var levels = levelsCols.SelectMany(x => x);
var membersTasks = new List <Task <MemberCollection> >();
foreach (var level in levels)
{
membersTasks.Add(level.GetMembersAsync());
}
var membersCols = await Task.WhenAll(membersTasks);
var members = membersCols.SelectMany(x => x);
Debug.WriteLine(members.Count());
await connection.CloseAsync();
}
internal DimensionCollection GetSelection()
{
var sel = new DimensionCollection();
if (this.Nodes == null || Content == null)
{
return(null);
}
foreach (TreeNode dimNode in this.Nodes)
{
if (dimNode.Checked)
{
var cleanDim = Content[(string)dimNode.Tag].Clone();
cleanDim.Hierarchies.Clear();
sel.Add(cleanDim);
foreach (TreeNode hierarchyNode in dimNode.Nodes)
{
if (hierarchyNode.Checked)
{
var cleanHierarchy = Content[(string)dimNode.Tag]
.Hierarchies[(string)hierarchyNode.Tag].Clone();
cleanHierarchy.Levels.Clear();
sel[(string)dimNode.Tag].Hierarchies.Add(cleanHierarchy);
foreach (TreeNode levelNode in hierarchyNode.Nodes)
{
if (levelNode.Checked)
{
sel[(string)dimNode.Tag]
.Hierarchies[(string)hierarchyNode.Tag].Levels.Add((string)levelNode.Tag,
sel[(string)dimNode.Tag]
.Hierarchies[(string)hierarchyNode.Tag]
.Levels[(string)levelNode.Tag]
.Clone());
}
}
}
}
}
}
return(sel);
}
public IArrayType UpdateDynamicType()
{
int elementCount = this.readArraySize();
ArrayType dataType = (ArrayType)base.DataType;
ReadOnlyDimensionCollection dimensions = dataType.Dimensions;
DimensionCollection dims = new DimensionCollection();
for (int i = 0; i < dimensions.Count; i++)
{
Dimension item = null;
item = (i != 0) ? new Dimension(dimensions[i].LowerBound, dimensions[i].ElementCount) : new Dimension(dimensions[i].LowerBound, elementCount);
dims.Add(item);
}
ArrayType type2 = new ArrayType(dataType.Name, (DataType)dataType.ElementType, dims, AdsDataTypeFlags.AnySizeArray | AdsDataTypeFlags.DataType);
base.resolvedDataType = type2;
return(type2);
}
private void LoadFields()
{
String connectionString = System.Configuration.ConfigurationManager.ConnectionStrings["OLAPConnection"].ConnectionString;
using (AdomdConnection conn = new AdomdConnection(connectionString))
{
conn.Open();
CubeDef cubeDef = null;
foreach (CubeDef cube in conn.Cubes)
{
if (cube.Type == CubeType.Cube)
{
cubeDef = cube;
break;
}
}
if (cubeDef == null)
{
m_DimFieldCollection.Clear();
m_MeasureFieldCollection.Clear();
return;
}
DimensionCollection dimCollection = cubeDef.Dimensions;
foreach (Dimension dim in dimCollection)
{
if (dim.DimensionType == DimensionTypeEnum.Measure)
{
continue;
}
HierarchyCollection hierarchyColl = dim.Hierarchies;
foreach (Hierarchy hier in hierarchyColl)
{
m_DimFieldCollection.Add(new Olap.DimensionFieldInfo(hier));
}
}
MeasureCollection measureCollection = cubeDef.Measures;
foreach (Measure m in measureCollection)
{
m_MeasureFieldCollection.Add(new Olap.MeasureFieldInfo(m));
}
}
}
public ArrayType(AdsDataTypeEntry entry) : base(DataTypeCategory.Array, entry)
{
string str2;
AdsDatatypeArrayInfo[] arrayInfos = entry.arrayInfos;
AdsDatatypeArrayInfo[] dims = null;
AdsDatatypeArrayInfo[] infoArray3 = null;
string baseType = null;
if (DataTypeStringParser.TryParseArray(base.name, out dims, out baseType) && DataTypeStringParser.TryParseArray(baseType, out infoArray3, out str2))
{
this._dimensions = new DimensionCollection(dims);
this.elementTypeName = baseType;
this.elementTypeId = entry.baseTypeId;
}
else
{
this._dimensions = new DimensionCollection(arrayInfos);
this.elementTypeName = entry.typeName;
this.elementTypeId = entry.baseTypeId;
}
this._oversampled = (entry.flags & (AdsDataTypeFlags.None | AdsDataTypeFlags.Oversample)) == (AdsDataTypeFlags.None | AdsDataTypeFlags.Oversample);
}
internal void SetSelection(DimensionCollection selection)
{
foreach (TreeNode dimNode in this.Nodes)
{
dimNode.Checked = selection.ContainsKey((string)dimNode.Tag);
if (dimNode.Checked)
{
foreach (TreeNode hierarchyNode in dimNode.Nodes)
{
hierarchyNode.Checked = selection[(string)dimNode.Tag].
Hierarchies.ContainsKey((string)hierarchyNode.Tag);
if (hierarchyNode.Checked)
{
foreach (TreeNode levelNode in hierarchyNode.Nodes)
{
levelNode.Checked = selection[(string)dimNode.Tag].
Hierarchies[(string)hierarchyNode.Tag].
Levels.ContainsKey((string)levelNode.Tag);
}
}
}
}
}
}
private List <FieldInfo> LoadFields()
{
//String connectionString = System.Configuration.ConfigurationManager.ConnectionStrings[OLAPConnector.OLAPConnectionString].ConnectionString;
String connectionString = "Data source=(local);Initial Catalog=SWordBI_SSAS";
//Dictionary<String, String> fields = new Dictionary<String, String>();
List <FieldInfo> fields = new List <FieldInfo>();
using (AdomdConnection conn = new AdomdConnection(connectionString))
{
conn.Open();
CubeDef cubeDef = null;
foreach (CubeDef cube in conn.Cubes)
{
if (cube.Type == CubeType.Cube)
{
cubeDef = cube;
break;
}
}
if (cubeDef == null)
{
return(fields);
}
DimensionCollection dimCollection = cubeDef.Dimensions;
foreach (Dimension dim in dimCollection)
{
HierarchyCollection hierarchyColl = dim.AttributeHierarchies;
foreach (Hierarchy h in hierarchyColl)
{
//fields.Add(h.UniqueName, h.Caption);
fields.Add(new FieldInfo(h.UniqueName, h.Caption));
}
}
}
return(fields);
}
public MeasureGroup(string name)
{
Name = name;
Measures = new MeasureCollection();
LinkedDimensions = new DimensionCollection();
}
public override void Load_InitData()
{
if (Mode != ControlMode.New)
{
return;
}
ASPxComboBox cbbKeyField;
try
{
cbbKeyField = (ASPxComboBox)this.FindControl("cbbKeyField");
if (cbbKeyField == null)
{
return;
}
}
#if DEBUG
catch (Exception ex)
{
throw ex;
}
#else
catch ()
{
return;
}
#endif
// Load fields
String connectionString = System.Configuration.ConfigurationManager.ConnectionStrings["OLAPConnection"].ConnectionString;
using (AdomdConnection conn = new AdomdConnection(connectionString))
{
conn.Open();
// Find a cube
CubeDef cubeDef = null;
CubeCollection cubeCollection = conn.Cubes;
int numOfCube = cubeCollection.Count - 1;
for (; numOfCube > 0; numOfCube--)
{
cubeDef = cubeCollection[numOfCube];
if (cubeDef.Type == CubeType.Cube)
{
break;
}
}
if (this is wcNormalFilter ||
this is wcTimeFilter)
{
Olap.DimensionFieldInfoCollection fields = new Olap.DimensionFieldInfoCollection();
// Load dimension field
DimensionCollection dimCollection = cubeDef.Dimensions;
int numOfDim = dimCollection.Count;
for (int dimIndex = 0; dimIndex < numOfDim; dimIndex++)
{
Dimension dim = dimCollection[dimIndex];
if (this is wcNormalFilter)
{
if (dim.UniqueName == "[ARDimTime]" ||
dim.DimensionType == DimensionTypeEnum.Measure)
{
continue;
}
}
else if (this is wcNumFilter)
{
if (dim.DimensionType != DimensionTypeEnum.Measure)
{
continue;
}
}
else // Date
{
if (dim.UniqueName != "[ARDimTime]")
{
continue;
}
}
foreach (Hierarchy hier in dim.Hierarchies)
{
fields.Add(new Olap.DimensionFieldInfo(hier));
}
}
Helpers.SetDataSource(cbbKeyField, fields, "UniqueName", "Caption");
}
else // wcNumFilter
{
Olap.MeasureFieldInfoCollection fields = new Olap.MeasureFieldInfoCollection();
MeasureCollection measureCollection = cubeDef.Measures;
int numOfMeasure = measureCollection.Count;
for (int mIndex = 0; mIndex < numOfMeasure; mIndex++)
{
Measure m = measureCollection[mIndex];
fields.Add(new Olap.MeasureFieldInfo(m));
}
Helpers.SetDataSource(cbbKeyField, fields, "UniqueName", "Caption");
}
}
}
internal DimensionCollection GetSelection()
{
var sel = new DimensionCollection();
if (this.Nodes == null || Content==null)
return null;
foreach (TreeNode dimNode in this.Nodes)
{
if (dimNode.Checked)
{
var cleanDim = Content[(string)dimNode.Tag].Clone();
cleanDim.Hierarchies.Clear();
sel.Add(cleanDim);
foreach (TreeNode hierarchyNode in dimNode.Nodes)
{
if (hierarchyNode.Checked)
{
var cleanHierarchy = Content[(string)dimNode.Tag]
.Hierarchies[(string)hierarchyNode.Tag].Clone();
cleanHierarchy.Levels.Clear();
sel[(string)dimNode.Tag].Hierarchies.Add(cleanHierarchy);
foreach (TreeNode levelNode in hierarchyNode.Nodes)
{
if (levelNode.Checked)
sel[(string)dimNode.Tag]
.Hierarchies[(string)hierarchyNode.Tag].Levels.Add((string)levelNode.Tag,
sel[(string)dimNode.Tag]
.Hierarchies[(string)hierarchyNode.Tag]
.Levels[(string)levelNode.Tag]
.Clone());
}
}
}
}
}
return sel;
}
public DimensionCollection GetDimensions()
{
return(DimensionCollection.GetDimensions());
}
public Product()
{
Dimensions = new DimensionCollection();
}
public ArrayType(string typeName, DataType elementType, DimensionCollection dims, AdsDataTypeFlags flags) : base(typeName, AdsDatatypeId.ADST_BIGTYPE, DataTypeCategory.Array, dims.ElementCount * elementType.ByteSize, null, flags)
{
this.elementType = elementType;
this.elementTypeName = elementType.Name;
this._dimensions = dims;
}
internal void SetSelection(DimensionCollection selection)
{
foreach (TreeNode dimNode in this.Nodes)
{
dimNode.Checked = selection.ContainsKey((string)dimNode.Tag);
if (dimNode.Checked)
{
foreach (TreeNode hierarchyNode in dimNode.Nodes)
{
hierarchyNode.Checked = selection[(string)dimNode.Tag].
Hierarchies.ContainsKey((string)hierarchyNode.Tag);
if (hierarchyNode.Checked)
{
foreach (TreeNode levelNode in hierarchyNode.Nodes)
{
levelNode.Checked = selection[(string)dimNode.Tag].
Hierarchies[(string)hierarchyNode.Tag].
Levels.ContainsKey((string)levelNode.Tag);
}
}
}
}
}
}
public Perspective(string name)
{
Name = name;
MeasureGroups = new MeasureGroupCollection();
Dimensions = new DimensionCollection();
}
public MeasureGroup(string name)
{
Name = name;
Measures = new MeasureCollection();
LinkedDimensions = new DimensionCollection();
}
internal TreeNode[] MapContent(DimensionCollection metadata)
{
var tnc = new List<TreeNode>();
if (metadata == null)
return tnc.ToArray();
foreach (var dim in metadata)
{
var dimNode = new TreeNode(dim.Value.Caption);
dimNode.Tag = dim.Key;
tnc.Add(dimNode);
foreach (var h in dim.Value.Hierarchies)
{
var hNode = new TreeNode(h.Value.Caption);
hNode.Tag = h.Key;
dimNode.Nodes.Add(hNode);
foreach (var l in h.Value.Levels)
{
var lNode = new TreeNode(l.Value.Caption);
lNode.Tag = l.Key;
hNode.Nodes.Add(lNode);
foreach (var p in l.Value.Properties)
{
var propNode = new TreeNode(p.Value.Caption);
propNode.Tag = p.Key;
lNode.Nodes.Add(propNode);
}
}
}
}
return tnc.ToArray();
}
internal static bool TryParseType(string typeName, IBinder resolver, out IDataType type)
{
if (typeName == null)
{
throw new ArgumentNullException("typeName");
}
if (resolver == null)
{
throw new ArgumentNullException("resolver");
}
if (typeName == string.Empty)
{
throw new ArgumentException();
}
DataType type2 = null;
int length = -1;
bool isUnicode = false;
if (DataTypeStringParser.TryParseString(typeName, out length, out isUnicode))
{
type2 = !isUnicode ? ((DataType) new StringType(length)) : ((DataType) new WStringType(length));
resolver.RegisterType(type2);
resolver.OnTypeGenerated(type2);
type = type2;
return(true);
}
DimensionCollection dims = null;
string baseType = null;
if (DataTypeStringParser.TryParseArray(typeName, out dims, out baseType))
{
IDataType type3 = null;
if (resolver.TryResolveType(baseType, out type3))
{
type2 = new ArrayType(typeName, (DataType)type3, dims, AdsDataTypeFlags.DataType);
resolver.RegisterType(type2);
resolver.OnTypeGenerated(type2);
type = type2;
return(true);
}
resolver.OnTypeResolveError(typeName);
object[] args = new object[] { typeName };
Module.Trace.TraceWarning("Array Type '{0}' could not be resolved. Not in DataType tables. Ignoring Type!", args);
type = null;
return(false);
}
string referencedType = null;
if (DataTypeStringParser.TryParsePointer(typeName, out referencedType))
{
type2 = new PointerType(typeName, referencedType);
resolver.RegisterType(type2);
resolver.OnTypeGenerated(type2);
type = type2;
return(true);
}
if (DataTypeStringParser.TryParseReference(typeName, out referencedType))
{
type2 = new ReferenceType(typeName, referencedType, resolver.PlatformPointerSize);
resolver.RegisterType(type2);
resolver.OnTypeGenerated(type2);
type = type2;
return(true);
}
type2 = (DataType)SubRangeTypeFactory.Create(typeName, resolver);
if (type2 == null)
{
type = null;
resolver.OnTypeResolveError(typeName);
return(false);
}
resolver.RegisterType(type2);
resolver.OnTypeGenerated(type2);
type = type2;
return(true);
}
