internal void ModifySelection(CubeMetadata selectionModifier, bool add)
{
foreach (TreeNode pNode in this.Nodes)
{
if (selectionModifier.Perspectives.ContainsKey((string)pNode.Tag))
{
var perspective = selectionModifier.Perspectives[(string)pNode.Tag];
foreach (TreeNode mgNode in pNode.Nodes)
{
mgNode.Checked = perspective.MeasureGroups.ContainsKey((string)mgNode.Tag);
if (perspective.MeasureGroups.ContainsKey((string)mgNode.Tag))
{
var measureGroup = perspective.MeasureGroups[(string)mgNode.Tag];
foreach (TreeNode measureNode in mgNode.LastNode.Nodes)
{
if (measureGroup.Measures.ContainsKey((string)measureNode.Tag))
{
measureNode.Checked = add;
CheckParentNode(measureNode, measureNode.Checked);
}
}
}
}
}
}
}
public void Write_TwoDimensionsSameMeasureGroup_FileIsCorrectlyBuilt()
{
var header = GetHeader();
var expectedContent = header
+ "\"p\";\"mg\";\"m1\";\"[m1]\";\"d1\";\"[d1]\";\"h1\";\"[h1]\";\"l1\";\"[l1]\";\"0\";\"p1\";\"[p1]\"\r\n"
+ "\"p\";\"mg\";\"m1\";\"[m1]\";\"d2\";\"[d2]\";\"h2\";\"[h2]\";\"l2\";\"[l2]\";\"1\";\"p2\";\"[p2]\"\r\n"
;
var expectedFilename = Path.Combine(DiskOnFile.GetDirectoryPath(), "ExpectedCSV-" + MethodBase.GetCurrentMethod() + ".csv");
if (File.Exists(expectedFilename))
{
File.Delete(expectedFilename);
}
File.AppendAllText(expectedFilename, expectedContent, Encoding.UTF8);
var filename = Path.Combine(DiskOnFile.GetDirectoryPath(), @"ActualCSV-" + MethodBase.GetCurrentMethod() + ".csv");
var metadata = new CubeMetadata();
var p = new Perspective("p");
metadata.Perspectives.Add(p);
var mg = new MeasureGroup("mg");
p.MeasureGroups.Add(mg);
var m1 = new Measure("[m1]", "m1", "df");
mg.Measures.Add(m1);
var d1 = new Dimension("[d1]", "d1");
mg.LinkedDimensions.Add(d1);
var h1 = new Hierarchy("[h1]", "h1", "df");
d1.Hierarchies.Add(h1);
var l1 = new Level("[l1]", "l1", 0);
h1.Levels.Add(l1);
var p1 = new Property("[p1]", "p1");
l1.Properties.Add(p1);
var d2 = new Dimension("[d2]", "d2");
mg.LinkedDimensions.Add(d2);
var h2 = new Hierarchy("[h2]", "h2", "df");
d2.Hierarchies.Add(h2);
var l2 = new Level("[l2]", "l2", 1);
h2.Levels.Add(l2);
var p2 = new Property("[p2]", "p2");
l2.Properties.Add(p2);
//set the object to test
var mcw = new MetadataCsvWriter(filename);
mcw.Write(metadata);
//Assertion
FileAssert.AreEqual(expectedFilename, filename);
}
private CubeMetadata BuildFakeMetadata()
{
var metadata = new CubeMetadata();
var p = new Perspective("p");
var mg = new MeasureGroup("mg");
var h1 = new Hierarchy("[h1]", "h1", "df");
var h2 = new Hierarchy("[h2]", "h2", "df");
var hs = new HierarchyCollection();
hs.Add(h1);
hs.Add(h2);
var d = new Dimension("[d]", "d", hs);
mg.LinkedDimensions.Add(d);
var m1 = new Measure("[m1]", "m1", "df");
var m2 = new Measure("[m2]", "m2", "df");
mg.Measures.Add(m1);
mg.Measures.Add(m2);
p.MeasureGroups.Add(mg);
metadata.Perspectives.Add(p);
return(metadata);
}
private void CheckForComplete(SlicingOptions options, CubeManager manager)
{
int expectedResults = options.TextureSliceX * options.TextureSliceY;
if (StorageUtilities.GetWorkCompletedCount(TableClient, options.CloudResultPath, options.CloudResultContainer) != expectedResults)
{
return;
}
var workResults = StorageUtilities.GetWorkCompletedMetadata(TableClient, options.CloudResultPath, options.CloudResultContainer);
// Write metadata
CubeMetadata metadata = new CubeMetadata(options.CubeGrid)
{
WorldBounds = manager.ObjInstance.Size,
VirtualWorldBounds = options.ForceCubicalCubes ? manager.ObjInstance.CubicalSize : manager.ObjInstance.Size,
VertexCount = manager.ObjInstance.VertexList.Count
};
// Configure texture slicing metadata
if (!string.IsNullOrEmpty(options.Texture) && (options.TextureSliceX + options.TextureSliceY) > 2)
{
metadata.TextureSetSize = new Vector2(options.TextureSliceX, options.TextureSliceY);
}
else
{
metadata.TextureSetSize = new Vector2(1, 1);
}
var resultsList = workResults.Select(w =>
SerializationUtilities.DecodeMetadataFromBase64(
Texture.GetCubeListFromTextureTile(options.TextureSliceY, options.TextureSliceX, w.TextureTileX, w.TextureTileY, manager.ObjInstance),
w.MetadataBase64));
foreach (var result in resultsList)
{
foreach (var cube in result.Keys)
{
metadata.CubeExists[cube.X, cube.Y, cube.Z] = result[cube];
}
}
// Write out some json metadata
string metadataPath = Path.Combine(outputPath, "metadata.json");
if (File.Exists(metadataPath))
{
File.Delete(metadataPath);
}
string metadataString = JsonConvert.SerializeObject(metadata);
File.WriteAllText(metadataPath, metadataString);
StorageUtilities.UpdateSetCompleted(TableClient, options.SetKey);
}
public ViewModel()
{
var years = Enumerable.Range(2019, 70).Select(v => v.ToString()).ToArray();
var units = new[] { "dollar", "kroner", "euro", "yen" };
var reportLevel1 = new[] { "Norway", "Sweden", "Denmark", "Germany", "Finland", "India" };
var reportLevel2 = new[] { "City 1", "City 2", "City 3", "City 4", "City 5" };
var metadataFactory = new DimensionMetadataFactory();
var values = Enumerable.Range(1, 100).Select(v => RandomString(4)).ToArray();
var numProperties = 100;
var numValues = 750000;
List <object> data = new List <object>();
List <string> fields = Enumerable.Range(1, numProperties).Select(v => $"Item{v}").Concat(new [] { "Value", "ReportLevel1", "ReportLevel2", "Unit", "Year" }).ToList();
var myType = _typeBuilder.GenerateType(fields.Select(f => new DynamicTypePropertyInfo {
PropertyName = f, PropertyType = f.Equals("Value") ? typeof(double) : typeof(object)
}).ToList());
for (int i = 0; i < numValues; i++)
{
var obj = Activator.CreateInstance(myType);
myType.GetProperty("Unit").SetValue(obj, GetRandomFrom(units));
myType.GetProperty("Year").SetValue(obj, GetRandomFrom(years));
myType.GetProperty("ReportLevel1").SetValue(obj, GetRandomFrom(reportLevel1));
myType.GetProperty("ReportLevel2").SetValue(obj, GetRandomFrom(reportLevel2));
myType.GetProperty("Value").SetValue(obj, 1.0);
data.Add(obj);
}
foreach (var prop in myType.GetProperties().Take(numProperties))
{
for (int i = 0; i < numValues; i++)
{
prop.SetValue(data[i], GetRandomFrom(values), null);
}
}
var cubeMetadata = new CubeMetadata {
DataTypeFullName = _typeBuilder.DynamicTypeName, DisplayName = "Pivot"
};
fields.ForEach(field => cubeMetadata.DimensionSettings.Add(metadataFactory.Create(field, field, field, field.Equals("Value"))));
FlatDataSource = new FlatDataSource
{
ItemsSource = data,
CubesSettings = { cubeMetadata },
DimensionsGenerationMode = DimensionsGenerationMode.Metadata,
PreserveMembersOrder = false
};
}
internal void SetSelection(CubeMetadata selection)
{
foreach (TreeNode pNode in this.Nodes)
{
pNode.Checked = selection.Perspectives.ContainsKey((string)pNode.Tag);
if (pNode.Checked)
{
var perspective = selection.Perspectives[(string)pNode.Tag];
foreach (TreeNode mgNode in pNode.Nodes)
{
mgNode.Checked = perspective.MeasureGroups.ContainsKey((string)mgNode.Tag);
if (mgNode.Checked)
{
foreach (TreeNode dimNode in mgNode.FirstNode.Nodes)
{
dimNode.Checked = perspective.MeasureGroups[(string)mgNode.Tag].LinkedDimensions.ContainsKey((string)dimNode.Tag);
mgNode.FirstNode.Checked = dimNode.Checked || mgNode.FirstNode.Checked;
if (dimNode.Checked)
{
foreach (TreeNode hierarchyNode in dimNode.Nodes)
{
hierarchyNode.Checked = perspective.MeasureGroups[(string)mgNode.Tag].
LinkedDimensions[(string)dimNode.Tag].
Hierarchies.ContainsKey((string)hierarchyNode.Tag);
if (hierarchyNode.Checked)
{
foreach (TreeNode levelNode in hierarchyNode.Nodes)
{
levelNode.Checked = perspective.MeasureGroups[(string)mgNode.Tag].
LinkedDimensions[(string)dimNode.Tag].
Hierarchies[(string)hierarchyNode.Tag].
Levels.ContainsKey((string)levelNode.Tag);
}
}
}
}
}
foreach (TreeNode measureNode in mgNode.LastNode.Nodes)
{
measureNode.Checked = perspective.MeasureGroups[(string)mgNode.Tag].Measures.ContainsKey((string)measureNode.Tag);
mgNode.LastNode.Checked = measureNode.Checked || mgNode.LastNode.Checked;
}
}
}
}
}
}
/// <summary>
/// Import a single cube part into the cube designer from the Content\Cubes folder.
/// </summary>
public void Import(string path)
{
try
{
var contentPath = path.MakeContentRelative();
if (contentPath == string.Empty)
{
return;
}
// Find or create cube metadata.
var metadataPath = Path.ChangeExtension(path, ".metadata");
CubeMetadata cmd;
if (File.Exists(metadataPath))
{
cmd = Serializer.ReadXML <CubeMetadata>(CubeMetadata.CubeMetadataSerializer, metadataPath);
cmd.LoadContent(MainGame);
}
else
{
cmd = new CubeMetadata()
{
ContentPath = contentPath
};
cmd.LoadContent(MainGame);
cmd.Serialize(metadataPath);
$"Creating {Path.GetFileName(metadataPath)}...".Log();
}
// Deduce part type from path.
var _part = contentPath.Split('\\')[1];
CubePart part = (CubePart)Enum.Parse(typeof(CubePart), _part, true);
// Add to part specific collection.
if (part == CubePart.Top)
{
CubeTopCollection.Add(new CubeDesignerItem(this, path, cmd));
}
else if (part == CubePart.Base)
{
CubeBaseCollection.Add(new CubeDesignerItem(this, path, cmd));
}
}
catch (Exception e)
{
e.Message.Log();
}
}
private void openMetadataToolStripMenuItem_Click(object sender, System.EventArgs e)
{
var cfg = Configuration.Project.Directories[Configuration.DirectoryCollection.DirectoryType.Metadata];
using (var ofd = new OpenFileDialog())
{
ofd.InitialDirectory = cfg.FullPath;
ofd.FileName = cfg.File;
ofd.Filter = "CSV|*.csv|Excel 97-2003|*.xls";
if (!string.IsNullOrEmpty(cfg.File))
{
ofd.FilterIndex = cfg.File.EndsWith("csv") ? 1 : 2;
}
if (ofd.ShowDialog() == DialogResult.OK)
{
var mr = MetadataFactory.GetReader(ofd.FileName);
var openMetadataDetailsForm = new MetadataOpen();
if (mr.SupportSheets)
{
openMetadataDetailsForm.MetadataReader = mr;
openMetadataDetailsForm.ShowDialog();
}
StartClick(null);
metadataTreeview.Nodes.Clear();
mr.ProgressStatusChanged += new ProgressStatusHandler(ProgressStatus);
Metadata = mr.Read();
mr.ProgressStatusChanged -= new ProgressStatusHandler(ProgressStatus);
metadataTreeview.Content = Metadata;
if (mr.SupportSheets && openMetadataDetailsForm.Track != "None")
{
var perspTrack = mr.Read(openMetadataDetailsForm.Track);
metadataTreeview.Selection = perspTrack;
}
cfg.FullFileName = ofd.FileName;
EndClick(null);
}
}
}
public void FindMeasures_OneLetterExistingInNoCaptions_ZeroMatches()
{
//Buiding object used during test
var cm = new CubeMetadata();
cm.Perspectives.Add(new Perspective("p"));
cm.Perspectives["p"].MeasureGroups.Add(new MeasureGroup("mg"));
cm.Perspectives["p"].MeasureGroups["mg"].Measures.Add(new Measure("[m1]", "m1", "df"));
cm.Perspectives["p"].MeasureGroups["mg"].Measures.Add(new Measure("[m2]", "m2", "df"));
cm.Perspectives["p"].MeasureGroups["mg"].Measures.Add(new Measure("[m3]", "xm3x", "df"));
cm.Perspectives["p"].MeasureGroups["mg"].Measures.Add(new Measure("[m4]", "4", "df"));
//Call the method to test
var res = cm.FindMeasures("z");
//Assertion
Assert.That(res.Perspectives.Count, Is.EqualTo(0));
}
public string[] Build(CubeMetadata metadata, string hierarchyFunction, string slicer, bool notEmpty)
{
var i = 0;
var total = metadata.GetItemsCount();
if (ProgressStatusChanged != null)
{
ProgressStatusChanged(this, new ProgressStatusEventArgs(string.Format("Creating query set")));
}
var res = new List <string>();
foreach (var p in metadata.Perspectives)
{
foreach (var mg in p.Value.MeasureGroups)
{
foreach (var dim in mg.Value.LinkedDimensions)
{
foreach (var hierarchy in dim.Value.Hierarchies)
{
foreach (var m in mg.Value.Measures)
{
var mdx = BuildMdx(p.Value.Name, m.Value.UniqueName, hierarchy.Value.UniqueName, hierarchyFunction, slicer, notEmpty);
if (!string.IsNullOrEmpty(PersistancePath))
{
i++;
var filename = BuildFilename(p.Value.Name, mg.Value.Name, m.Value.Caption, dim.Value.Caption, hierarchy.Value.Caption);
Persist(mdx, filename);
if (ProgressStatusChanged != null)
{
ProgressStatusChanged(this, new ProgressStatusEventArgs(String.Format("Persisting query set {0} of {1}", i, total), i, total));
}
}
res.Add(mdx);
}
}
}
}
}
if (ProgressStatusChanged != null)
{
ProgressStatusChanged(this, new ProgressStatusEventArgs(string.Format("Query set created")));
}
return(res.ToArray());
}
public void FindMeasures_ComplexRegexMatchingTwoCaptions_TwoMatches()
{
//Buiding object used during test
var cm = new CubeMetadata();
cm.Perspectives.Add(new Perspective("p"));
cm.Perspectives["p"].MeasureGroups.Add(new MeasureGroup("mg"));
cm.Perspectives["p"].MeasureGroups["mg"].Measures.Add(new Measure("[m1]", "m1", "df"));
cm.Perspectives["p"].MeasureGroups["mg"].Measures.Add(new Measure("[m2]", "m2", "df"));
cm.Perspectives["p"].MeasureGroups["mg"].Measures.Add(new Measure("[m3]", "xm3x", "df"));
cm.Perspectives["p"].MeasureGroups["mg"].Measures.Add(new Measure("[m4]", "4", "df"));
//Call the method to test
var res = cm.FindMeasures("m[0-9]$");
//Assertion
Assert.That(res.Perspectives.Count, Is.EqualTo(1));
Assert.That(res.Perspectives["p"].MeasureGroups.Count, Is.EqualTo(1));
Assert.That(res.Perspectives["p"].MeasureGroups["mg"].Measures.Count, Is.EqualTo(2));
}
private void extractMetadataToolStripMenuItem_Click(object sender, EventArgs e)
{
var extractForm = new MetadataExtract();
var cfg = Configuration.Project.ConnectionStrings[
Configuration.ConnectionStringCollection.ConnectionClass.Adomd,
Configuration.ConnectionStringCollection.ConnectionType.Expect
];
extractForm.ConnectionString = cfg.Value;
if (extractForm.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
StartClick(null);
var metadataExtractor = extractForm.MetadataExtractor;
metadataExtractor.ProgressStatusChanged += new ProgressStatusHandler(ProgressStatus);
try
{
Metadata = metadataExtractor.GetFullMetadata();
}
catch (ConnectionException ex)
{
MessageBox.Show(ex.Message, "Cannot connect with connectionString", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
finally
{
metadataExtractor.ProgressStatusChanged -= new ProgressStatusHandler(ProgressStatus);
if (Metadata != null)
{
metadataTreeview.Content = Metadata;
}
cfg.Value = extractForm.ConnectionString;
EndClick(null);
}
}
}
public CubeDesignerItem(CubeDesignerViewModel viewModel, string imagePath, CubeMetadata cmd) : base(imagePath, cmd)
{
SourceRect = new Int32Rect(0, 0, 72, 75);
ViewModel = viewModel;
CubeMetadata = cmd;
}
public FindMeasures(CubeMetadata metadata)
{
InitializeComponent();
_metadata = metadata;
Settings = new SettingsFindMeasures();
}
public string[] Build(CubeMetadata metadata)
{
return(this.Build(metadata, "Children", "", false));
}
internal TreeNode[] MapContent(CubeMetadata metadata)
{
var tnc = new List <TreeNode>();
if (metadata == null)
{
return(tnc.ToArray());
}
foreach (var perspective in metadata.Perspectives)
{
var pNode = new TreeNode(perspective.Value.Name);
pNode.Tag = perspective.Key;
tnc.Add(pNode);
foreach (var mg in perspective.Value.MeasureGroups)
{
var mgNode = new TreeNode(mg.Value.Name);
mgNode.Tag = mg.Key;
pNode.Nodes.Add(mgNode);
var dimsNode = new TreeNode("Linked dimensions");
mgNode.Nodes.Add(dimsNode);
foreach (var dim in mg.Value.LinkedDimensions)
{
var dimNode = new TreeNode(dim.Value.Caption);
dimNode.Tag = dim.Key;
dimsNode.Nodes.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);
}
}
}
}
var measuresNode = new TreeNode("Measures");
mgNode.Nodes.Add(measuresNode);
foreach (var measure in mg.Value.Measures)
{
var measureNode = new TreeNode(measure.Value.Caption);
measureNode.Tag = measure.Key;
measuresNode.Nodes.Add(measureNode);
}
}
}
return(tnc.ToArray());
}
public string[] Build(CubeMetadata metadata, string hierarchyFunction, string slicer)
{
return(this.Build(metadata, hierarchyFunction, slicer, false));
}
public string[] Build(CubeMetadata metadata, bool notEmpty)
{
return(this.Build(metadata, "Children", "", notEmpty));
}
internal CubeMetadata GetSelection()
{
CubeMetadata sel = new CubeMetadata();
foreach (TreeNode perspNode in this.Nodes)
{
var selPersp = Content.Perspectives[(string)perspNode.Tag].Clone();
sel.Perspectives.Add(selPersp);
foreach (TreeNode mgNode in perspNode.Nodes)
{
if (mgNode.Checked)
{
var selMg = selPersp.MeasureGroups[(string)mgNode.Tag];
foreach (TreeNode dimNode in mgNode.FirstNode.Nodes)
{
if (dimNode.Checked)
{
var cleanDim = Content.Perspectives[(string)perspNode.Tag].Dimensions[(string)dimNode.Tag].Clone(); //NOT A TRUE CLONE !!!!
cleanDim.Hierarchies.Clear();
selMg.LinkedDimensions.Add(cleanDim);
foreach (TreeNode hierarchyNode in dimNode.Nodes)
{
if (hierarchyNode.Checked)
{
var cleanHierarchy = Content.Perspectives[(string)perspNode.Tag]
.Dimensions[(string)dimNode.Tag]
.Hierarchies[(string)hierarchyNode.Tag].Clone();
cleanHierarchy.Levels.Clear();
selMg.LinkedDimensions[(string)dimNode.Tag].Hierarchies.Add(cleanHierarchy);
foreach (TreeNode levelNode in hierarchyNode.Nodes)
{
if (levelNode.Checked)
{
selMg.LinkedDimensions[(string)dimNode.Tag]
.Hierarchies[(string)hierarchyNode.Tag].Levels.Add((string)levelNode.Tag,
Content.Perspectives[(string)perspNode.Tag]
.Dimensions[(string)dimNode.Tag]
.Hierarchies[(string)hierarchyNode.Tag]
.Levels[(string)levelNode.Tag]
.Clone());
}
}
}
}
}
}
foreach (TreeNode measureNode in mgNode.LastNode.Nodes)
{
if (measureNode.Checked)
{
selMg.Measures.Add(Content.Perspectives[(string)perspNode.Tag].MeasureGroups[(string)mgNode.Tag].Measures[(string)measureNode.Tag].Clone());
}
}
}
}
}
return(sel);
}
public static CubeMetadata GetCubeMetadata(AdomdConnection conn, string cubeName)
{
if (conn == null)
{
throw new ArgumentNullException("conn");
}
if (string.IsNullOrEmpty(cubeName))
{
throw new ArgumentNullException("cubeName");
}
var cubeMetadata = new CubeMetadata();
cubeMetadata.CubeName = SSASHelper.RemoveBrackets(cubeName);
// Measures
var dtMeasures = GetSchemaRowset(conn, SSAS_RowSets.MDSCHEMA_MEASURES,
"[MEASURE_IS_VISIBLE]", null, null, cubeName);
foreach (var dr in dtMeasures.AsEnumerable())
{
var newRow = cubeMetadata.Measures.NewRow();
newRow["Name"] = dr.Field <string>("MEASURE_CAPTION");
newRow["UniqueName"] = dr.Field <string>("MEASURE_UNIQUE_NAME");
newRow["MeasureGroupName"] = dr.Field <string>("MEASUREGROUP_NAME");
newRow["MeasureDisplayFolder"] = dr.Field <string>("MEASURE_DISPLAY_FOLDER");
cubeMetadata.Measures.Rows.Add(newRow);
}
// Dimensions
var dtDimensions = GetSchemaRowset(conn, SSAS_RowSets.MDSCHEMA_DIMENSIONS
, null, null, null, cubeName).AsEnumerable().ToList();
// Dimensions vs MG relations
var listDimensionsAndMG = GetSchemaRowset(conn, SSAS_RowSets.MDSCHEMA_MEASUREGROUP_DIMENSIONS
, string.Empty, null, null, cubeName)
.AsEnumerable().ToList();
foreach (var dr in dtDimensions)
{
var newRow = cubeMetadata.Dimensions.NewRow();
newRow["Name"] = dr.Field <string>("DIMENSION_CAPTION");
var dimensionUniqueName = dr.Field <string>("DIMENSION_UNIQUE_NAME");
newRow["UniqueName"] = dimensionUniqueName;
var type = dr.Field <short>("DIMENSION_TYPE");
// 2: Measure dimension
if (type == 2)
{
continue;
}
newRow["Type"] = type.ToString();
var measureGroups = listDimensionsAndMG.Where(m => m.Field <string>("DIMENSION_UNIQUE_NAME").EqualsCI(dimensionUniqueName))
.Select(s => s.Field <string>("MEASUREGROUP_NAME"))
.Distinct();
newRow["MeasureGroupName"] = string.Join(",", measureGroups);
cubeMetadata.Dimensions.Rows.Add(newRow);
}
// Hierarchies
var dtHierarchies = GetSchemaRowset(conn, SSAS_RowSets.MDSCHEMA_HIERARCHIES
, "[HIERARCHY_IS_VISIBLE] and [HIERARCHY_UNIQUE_NAME] <> '[Measures]'", null, null, cubeName).AsEnumerable().ToList();
foreach (var hRow in dtHierarchies.AsEnumerable())
{
var newRow = cubeMetadata.Hierarchies.NewRow();
newRow["Name"] = hRow.Field <string>("HIERARCHY_CAPTION");
newRow["UniqueName"] = hRow.Field <string>("HIERARCHY_UNIQUE_NAME");
newRow["Type"] = Convert.ToInt32(hRow["HIERARCHY_ORIGIN"].IgnoreDBNull()) == 1
? "User"
: "Attribute";
newRow["DimensionUniqueName"] = hRow.Field <string>("DIMENSION_UNIQUE_NAME");
cubeMetadata.Hierarchies.Rows.Add(newRow);
}
// Levels
var dtLevels = GetSchemaRowset(conn, SSAS_RowSets.MDSCHEMA_LEVELS
, "[LEVEL_IS_VISIBLE] and [HIERARCHY_UNIQUE_NAME] <> '[Measures]'", null, null, cubeName).AsEnumerable().ToList();
foreach (var dr in dtLevels)
{
var newRowLevel = cubeMetadata.Levels.NewRow();
newRowLevel["Name"] = dr.Field <string>("LEVEL_CAPTION");
newRowLevel["UniqueName"] = dr.Field <string>("LEVEL_UNIQUE_NAME");
newRowLevel["Type"] = dr.Field <int>("LEVEL_TYPE").ToString();
newRowLevel["HierarchyUniqueName"] = dr.Field <string>("HIERARCHY_UNIQUE_NAME");
newRowLevel["Number"] = dr.Field <uint>("LEVEL_NUMBER");
newRowLevel["Cardinality"] = dr.Field <uint>("LEVEL_CARDINALITY");
cubeMetadata.Levels.Rows.Add(newRowLevel);
}
return(cubeMetadata);
}
