/// <summary>
/// Creates a <see cref="CompilationUnitSyntax"/> instance wrapping the given method.
/// </summary>
/// <param name="hierarchyInfo">The <see cref="HierarchyInfo"/> instance for the current type.</param>
/// <param name="methodDeclaration">The <see cref="MethodDeclarationSyntax"/> item to insert.</param>
/// <param name="canUseSkipLocalsInit">Whether <c>[SkipLocalsInit]</c> can be used.</param>
/// <returns>A <see cref="CompilationUnitSyntax"/> object wrapping <paramref name="methodDeclaration"/>.</returns>
private static CompilationUnitSyntax GetCompilationUnitFromMethod(
HierarchyInfo hierarchyInfo,
MethodDeclarationSyntax methodDeclaration,
bool canUseSkipLocalsInit)
{
// Method attributes
List <AttributeListSyntax> attributes = new()
{
AttributeList(SingletonSeparatedList(
Attribute(IdentifierName("global::System.CodeDom.Compiler.GeneratedCode")).AddArgumentListArguments(
AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(typeof(ID2D1ShaderGenerator).FullName))),
AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(typeof(ID2D1ShaderGenerator).Assembly.GetName().Version.ToString())))))),
AttributeList(SingletonSeparatedList(Attribute(IdentifierName("global::System.Diagnostics.DebuggerNonUserCode")))),
AttributeList(SingletonSeparatedList(Attribute(IdentifierName("global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage")))),
AttributeList(SingletonSeparatedList(
Attribute(IdentifierName("global::System.ComponentModel.EditorBrowsable")).AddArgumentListArguments(
AttributeArgument(ParseExpression("global::System.ComponentModel.EditorBrowsableState.Never"))))),
AttributeList(SingletonSeparatedList(
Attribute(IdentifierName("global::System.Obsolete")).AddArgumentListArguments(
AttributeArgument(LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal("This method is not intended to be used directly by user code"))))))
};
// Add [SkipLocalsInit] if the target project allows it
if (canUseSkipLocalsInit)
{
attributes.Add(AttributeList(SingletonSeparatedList(Attribute(IdentifierName("global::System.Runtime.CompilerServices.SkipLocalsInit")))));
}
return(hierarchyInfo.GetSyntax(methodDeclaration.AddAttributeLists(attributes.ToArray())));
}
}
public override TaskList GetTasks(HierarchyInfo item)
{
if (string.Equals(item.NodeType, HierarchyInfo.ServerConnection, StringComparison.Ordinal))
{
// Server task list
}
if (string.Equals(item.NodeType, HierarchyInfo.Site, StringComparison.Ordinal) ||
string.Equals(item.NodeType, HierarchyInfo.Application, StringComparison.Ordinal))
{
var siteName = GetSiteName(item);
var virtualPath = GetApplicationPath(Item);
var serverManager = new ServerManager();
BpmOnlineSite site;
try
{
site = new BpmOnlineSite(serverManager, siteName, virtualPath);
}
catch (Exception)
{
return(null);
}
if (site.ConnectionStringsConfig == null)
{
return(null);
}
return((TaskList) new BpmOnlineHierarchyTaskList(_owner, site));
}
/*if (string.Equals(item.NodeType, HierarchyInfo.Application, StringComparison.Ordinal))
* {
* // Application task list
* }*/
return((TaskList)null);
}
public virtual void RegisterHierarchy(IVsHierarchy hierarchy)
{
if ((null == hierarchy) || _hierarchies.ContainsKey(hierarchy))
{
return;
}
var commonProject = hierarchy.GetProject()?.GetCommonProject();
if (commonProject == null)
{
return;
}
RegisterLibrary();
HierarchyListener listener = new HierarchyListener(hierarchy, this);
var node = _hierarchies[hierarchy] = new HierarchyInfo(
listener,
new ProjectLibraryNode(commonProject)
);
_library.AddNode(node.ProjectLibraryNode);
listener.StartListening(false);
RegisterForRDTEvents();
}
private HierarchyInfo BuildHierarchyInfo(TypeInfo root, HierarchyDef hierarchyDef)
{
var key = BuildKeyInfo(root, hierarchyDef);
var schema = hierarchyDef.Schema;
// Optimization. It there is the only class in hierarchy then ConcreteTable schema is applied
if (schema != InheritanceSchema.ConcreteTable)
{
var node = context.DependencyGraph.TryGetNode(hierarchyDef.Root);
// No dependencies => no descendants
if (node == null || node.IncomingEdges.Count(e => e.Kind == EdgeKind.Inheritance) == 0)
{
schema = InheritanceSchema.ConcreteTable;
}
}
var typeDiscriminatorField = hierarchyDef.Root.Fields.FirstOrDefault(f => f.IsTypeDiscriminator);
var typeDiscriminatorMap = typeDiscriminatorField != null ? new TypeDiscriminatorMap() : null;
var hierarchy = new HierarchyInfo(root, key, schema, typeDiscriminatorMap)
{
Name = root.Name,
};
key.Hierarchy = hierarchy; // Setting backreference
context.Model.Hierarchies.Add(hierarchy);
return(hierarchy);
}
String GetHierarchy(MetadataQuery args)
{
OlapMetadataProvider provider = new OlapMetadataProvider(new ConnectionInfo(args.Connection, GetConnectionString(args.Connection)));
HierarchyInfo info = provider.GetHierarchy(args.CubeName, args.DimensionUniqueName, args.HierarchyUniqueName);
return(XmlSerializationUtility.Obj2XmlStr(info, Common.Namespace));
}
private string GetApplicationPath(HierarchyInfo item, string currentApplicationPath)
{
if (string.Equals(item.NodeType, HierarchyInfo.Site, StringComparison.Ordinal))
{
return(currentApplicationPath);
}
}
public Dictionary <String, HierarchyInfo> GetHierarchies(String cubeName, string dimensionUniqueName)
{
try
{
System.Diagnostics.Trace.TraceInformation("{0} Ranet.Olap.Core.Providers.OlapMetadataProvider Get Hierarchies Started \r\n cubeName: '{1}' \r\n dimensionUniqueName: '{2}'",
DateTime.Now.ToString(), cubeName, dimensionUniqueName);
Dictionary <String, HierarchyInfo> list = new Dictionary <String, HierarchyInfo>();
AdomdConnection conn = GetConnection();
Dimension dim = FindDimension(cubeName, dimensionUniqueName);
if (dim != null)
{
foreach (Hierarchy hierarchy in dim.Hierarchies)
{
HierarchyInfo info = InfoHelper.CreateHierarchyInfo(hierarchy);
if (info != null)
{
if (!list.ContainsKey(info.UniqueName))
{
list.Add(info.UniqueName, info);
}
}
}
}
return(list);
}
finally {
System.Diagnostics.Trace.TraceInformation("{0} Ranet.Olap.Core.Providers.OlapMetadataProvider Get Hierarchies Completed \r\n", DateTime.Now.ToString());
}
}
private string GetSiteName(HierarchyInfo item)
{
if (string.Equals(item.NodeType, HierarchyInfo.Site, StringComparison.Ordinal))
{
return(item.Text);
}
return(GetSiteName(item.Parent));
}
public static void Dump(this HierarchyInfo target, int indent)
{
WriteLine(indent, "InheritanceSchema: " + target.InheritanceSchema);
WriteLine(indent, "KeyFields:");
foreach (var pair in target.Root.Fields.Where(f => f.IsPrimaryKey))
{
WriteLine(indent + 1, pair.Name + "(" + pair.ValueType + ") ");
}
}
/// <summary>
/// Gets the name, file path, and OneNote hyperlink to the current page;
/// used to build up Favorites
/// </summary>
/// <returns></returns>
public HierarchyInfo GetPageInfo(string pageId = null)
{
if (pageId == null)
{
pageId = CurrentPageId;
}
var page = GetPage(pageId, PageDetail.Basic);
if (page == null)
{
return(null);
}
var info = new HierarchyInfo
{
PageId = pageId,
Name = page.Root.Attribute("name")?.Value,
Link = GetHyperlink(page.PageId, string.Empty)
};
// path
var builder = new StringBuilder();
builder.Append($"/{info.Name}");
var id = GetParent(pageId);
while (!string.IsNullOrEmpty(id))
{
onenote.GetHierarchy(id, HierarchyScope.hsSelf, out var xml, XMLSchema.xs2013);
var parent = XElement.Parse(xml);
var parentName = parent.Attribute("name")?.Value;
if (parentName != null)
{
builder.Insert(0, $"/{parentName}");
}
if (parent.Name.LocalName == "Section" && string.IsNullOrEmpty(info.SectionId))
{
info.SectionId = parent.Attribute("ID").Value;
}
else if (parent.Name.LocalName == "Notebook")
{
info.NotebookId = parent.Attribute("ID").Value;
}
id = GetParent(id);
}
info.Path = builder.ToString();
return(info);
}
void RegisterHierachry(SelectQuery parent, SelectQuery child, HierarchyInfo info)
{
_parents[child] = info;
if (!_tree.TryGetValue(parent, out var list))
{
list = new List <SelectQuery>();
_tree.Add(parent, list);
}
list.Add(child);
}
/// <summary>
/// Gets the name, file path, and OneNote hyperlink to the current section;
/// used to build up Favorites
/// </summary>
/// <returns></returns>
public HierarchyInfo GetSectionInfo()
{
var section = GetSection();
if (section == null)
{
return(null);
}
var info = new HierarchyInfo
{
SectionId = CurrentSectionId,
NotebookId = CurrentNotebookId,
Name = section.Attribute("name")?.Value
};
// path
var builder = new StringBuilder();
builder.Append($"/{info.Name}");
var id = GetParent(CurrentSectionId);
while (!string.IsNullOrEmpty(id))
{
onenote.GetHierarchy(id, HierarchyScope.hsSelf, out var xml, XMLSchema.xs2013);
var x = XElement.Parse(xml);
var n = x.Attribute("name")?.Value;
if (n != null)
{
builder.Insert(0, $"/{n}");
}
id = GetParent(id);
}
info.Path = builder.ToString();
var sectionId = section.Attribute("ID")?.Value;
if (sectionId != null)
{
info.Link = GetHyperlink(sectionId, string.Empty);
}
return(info);
}
protected override void RefreshTree()
{
base.RefreshTree();
if (CubeInfo != null)
{
// Если задано уникальное имя измерения, то создаем для данного измерения узел
if (!String.IsNullOrEmpty(DimensionUniqueName))
{
DimensionInfo info = CubeInfo.GetDimension(DimensionUniqueName);
if (info != null)
{
if (!String.IsNullOrEmpty(HierarchyUniqueName))
{
HierarchyInfo hierarchyInfo = info.GetHierarchy(HierarchyUniqueName);
if (hierarchyInfo != null)
{
HierarchyTreeNode hierarchyNode = AddHierarchyNode(null, hierarchyInfo);
CreateLevels(hierarchyNode, hierarchyInfo, false);
hierarchyNode.IsExpanded = true;
return;
}
else
{
LogManager.LogError(this, String.Format(Localization.MetadataResponseException_HierarchyByUniqueName_InDimension_NotFound, HierarchyUniqueName, DimensionUniqueName));
}
}
else
{
DimensionTreeNode dimNode = AddDimensionNode(null, info);
CreateHierarchies(dimNode, info, true);
dimNode.IsExpanded = true;
return;
}
}
else
{
LogManager.LogError(this, String.Format(Localization.MetadataResponseException_DimensionByUniqueName_InCube_NotFound, DimensionUniqueName, CubeName));
}
}
// Отображаем все измерения
CreateDimensions(null, CubeInfo, true);
}
}
public HierarchyTreeNode(HierarchyInfo info)
: base(info)
{
switch (info.HierarchyOrigin)
{
case HierarchyInfoOrigin.AttributeHierarchy:
Icon = UriResources.Images.AttributeHierarchy16;
break;
case HierarchyInfoOrigin.ParentChildHierarchy:
Icon = UriResources.Images.ParentChildHierarchy16;
break;
case HierarchyInfoOrigin.UserHierarchy:
Icon = UriResources.Images.UserHierarchy16;
break;
}
}
public virtual void UnregisterHierarchy(IVsHierarchy hierarchy)
{
if ((null == hierarchy) || !_hierarchies.ContainsKey(hierarchy))
{
return;
}
HierarchyInfo info = _hierarchies[hierarchy];
if (null != info)
{
info.Listener.Dispose();
}
_hierarchies.Remove(hierarchy);
_library.RemoveNode(info.ProjectLibraryNode);
if (0 == _hierarchies.Count)
{
UnregisterRDTEvents();
}
lock (_files)
{
ModuleId[] keys = new ModuleId[_files.Keys.Count];
_files.Keys.CopyTo(keys, 0);
foreach (ModuleId id in keys)
{
if (hierarchy.Equals(id.Hierarchy))
{
_library.RemoveNode(_files[id]);
_files.Remove(id);
}
}
}
// Remove the document listeners.
uint[] docKeys = new uint[_documents.Keys.Count];
_documents.Keys.CopyTo(docKeys, 0);
foreach (uint id in docKeys)
{
TextLineEventListener docListener = _documents[id];
if (hierarchy.Equals(docListener.FileID.Hierarchy))
{
_documents.Remove(id);
docListener.Dispose();
}
}
}
/// <summary>
/// 从技能ID获取父/子技能关系
/// </summary>
/// <param name="skill_id"></param>
/// <returns></returns>
public HierarchyInfo GetHierarchyInfo(uint skill_id)
{
HierarchyInfo info = null;
if (!mSkillHierarchyInfos.TryGetValue(skill_id, out info))
{
var skill_info = DBSkillSev.Instance.GetSkillInfo(skill_id);
// 有子技能
if (skill_info != null && skill_info.ParentSkillId != 0)
{
info = new HierarchyInfo();
info.ParentID = skill_info.ParentSkillId;
// 计算当前子技能的序号
var parent_skill_info = DBSkillSev.Instance.GetSkillInfo(skill_info.ParentSkillId);
if (parent_skill_info != null)
{
int index = 0;
var cur_skill_info = parent_skill_info;
while (cur_skill_info.ChildSkillId != 0 && cur_skill_info.Id != skill_info.Id)
{
cur_skill_info = DBSkillSev.Instance.GetSkillInfo(cur_skill_info.ChildSkillId);
if (cur_skill_info == null)
{
GameDebug.LogError("cur_skill_info is null, id:" + cur_skill_info.ParentSkillId);
break;
}
index++;
}
info.HierarchyIndex = index;
}
else
{
GameDebug.LogError("parent_skill_info is null, id:" + skill_info.ParentSkillId);
}
mSkillHierarchyInfos[skill_id] = info;
}
}
return(info);
}
public override TaskList GetTasks(HierarchyInfo item)
{
var connection = (Connection)_owner.ServiceProvider.GetService(typeof(Connection));
var a = ((Microsoft.Web.Management.Iis.WebObjects.WebObjectsHierarchyProvider.ServerContentInfo)(item)).NavigatorPath;
var siteName = connection.ConfigurationPath.SiteName;
var virtualPath = connection.ConfigurationPath.ApplicationPath +
connection.ConfigurationPath.FolderPath;
if (string.Equals(item.NodeType, HierarchyInfo.ServerConnection, StringComparison.Ordinal))
{
// Server task list
}
if (string.Equals(item.NodeType, HierarchyInfo.Site, StringComparison.Ordinal) ||
string.Equals(item.NodeType, HierarchyInfo.Application, StringComparison.Ordinal))
{
var serverManager = new ServerManager();
BpmOnlineSite site;
try
{
site = new BpmOnlineSite(serverManager, siteName, virtualPath);
}
catch (Exception)
{
return(null);
}
if (site.ConnectionStringsConfig == null)
{
return(null);
}
return((TaskList) new BpmOnlineHierarchyTaskList(_owner, site));
}
/*if (string.Equals(item.NodeType, HierarchyInfo.Application, StringComparison.Ordinal))
* {
* // Application task list
* }*/
return((TaskList)null);
}
void RegisterHierachry(SelectQuery parent, SelectQuery child, HierarchyInfo info)
{
_parents ![child] = info;
String BuildFilterCondition(String cubeName, String hierarchyUniqueName, FilterOperationBase filter)
{
StringBuilder builder = new StringBuilder();
if (filter != null)
{
// Опрерация
FilterOperation operation = filter as FilterOperation;
if (operation != null)
{
List <String> operands = new List <string>();
foreach (FilterOperationBase child in operation.Children)
{
String x = BuildFilterCondition(cubeName, hierarchyUniqueName, child);
if (!String.IsNullOrEmpty(x))
{
operands.Add(String.Format("({0})", x));
}
}
if (operands.Count > 1)
{
builder.Append("(");
}
for (int i = 0; i < operands.Count; i++)
{
if (i > 0)
{
builder.AppendFormat(" {0} ", operation.Operation.ToString());
}
builder.Append(operands[i]);
}
if (operands.Count > 1)
{
builder.Append(")");
}
}
FilterOperand operand = filter as FilterOperand;
if (operand != null)
{
// Если свойство не является общим для всех уровней - (общие: Caption, UniqueName, Name)
// То при формировании нужно обязательно проверять чтобы текущий уровень был именно тем, на котором это свойство есть
// Исключение составляют случаи когда измерение Parent-Child
bool isParentChild = false;
try
{
OlapMetadataProvider provider = new OlapMetadataProvider(QueryExecuter.Connection);
HierarchyInfo hierarchy = provider.GetHierarchy(cubeName, String.Empty, hierarchyUniqueName);
if (hierarchy != null && hierarchy.HierarchyOrigin == HierarchyInfoOrigin.ParentChildHierarchy)
{
isParentChild = true;
}
}
catch { }
// Свойство с одним и тем же именем может присутствовать на нескольких уровнях. В данном случае operand.PropertyLevels содержит коллекцию уникальных имен уровней. Их все нужно учесть
if (operand.PropertyLevels.Count != 0 && !isParentChild)
{
int i = 0;
builder.Append("(");
foreach (String levelUniqueName in operand.PropertyLevels)
{
if (i > 0)
{
builder.Append("or ");
}
builder.AppendFormat("({0}.Level is {1}) ", hierarchyUniqueName, levelUniqueName);
i++;
}
builder.Append(")");
builder.Append(" and ");
}
switch (operand.Condition)
{
case ConditionTypes.Equal:
builder.AppendFormat("{0}.Properties(\"{1}\")='{2}'", hierarchyUniqueName, operand.Property, operand.Value);
break;
case ConditionTypes.Contains:
builder.AppendFormat("InStr({0}.Properties(\"{1}\"),'{2}') <> 0", hierarchyUniqueName, operand.Property, operand.Value);
break;
case ConditionTypes.BeginWith:
//Позиция при использовании InStr начинается с 1
builder.AppendFormat("InStr({0}.Properties(\"{1}\"),'{2}') = 1", hierarchyUniqueName, operand.Property, operand.Value);
break;
}
}
}
return(builder.ToString());
}
public Hierarchy_AreaItemWrapper(HierarchyInfo info)
: base(info)
{
UniqueName = info.UniqueName;
}
public override HierarchyInfo[] GetChildren(HierarchyInfo item)
{
return((HierarchyInfo[])null);
}
private string GetApplicationPath(HierarchyInfo item)
{
throw new NotImplementedException();
}
/// <summary>
/// Creates a <see cref="CompilationUnitSyntax"/> instance wrapping the given method.
/// </summary>
/// <param name="hierarchyInfo">The <see cref="HierarchyInfo"/> instance for the current type.</param>
/// <param name="methodDeclaration">The <see cref="MethodDeclarationSyntax"/> item to insert.</param>
/// <param name="canUseSkipLocalsInit">Whether <c>[SkipLocalsInit]</c> can be used.</param>
/// <returns>A <see cref="CompilationUnitSyntax"/> object wrapping <paramref name="methodDeclaration"/>.</returns>
private static CompilationUnitSyntax GetCompilationUnitFromMethod(
HierarchyInfo hierarchyInfo,
MethodDeclarationSyntax methodDeclaration,
bool canUseSkipLocalsInit)
{
// Method attributes
List <AttributeListSyntax> attributes = new()
{
AttributeList(SingletonSeparatedList(
Attribute(IdentifierName("global::System.CodeDom.Compiler.GeneratedCode")).AddArgumentListArguments(
AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(typeof(IShaderGenerator).FullName))),
AttributeArgument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(typeof(IShaderGenerator).Assembly.GetName().Version.ToString())))))),
AttributeList(SingletonSeparatedList(Attribute(IdentifierName("global::System.Diagnostics.DebuggerNonUserCode")))),
AttributeList(SingletonSeparatedList(Attribute(IdentifierName("global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage")))),
AttributeList(SingletonSeparatedList(
Attribute(IdentifierName("global::System.ComponentModel.EditorBrowsable")).AddArgumentListArguments(
AttributeArgument(ParseExpression("global::System.ComponentModel.EditorBrowsableState.Never"))))),
AttributeList(SingletonSeparatedList(
Attribute(IdentifierName("global::System.Obsolete")).AddArgumentListArguments(
AttributeArgument(LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal("This method is not intended to be used directly by user code"))))))
};
// Add [SkipLocalsInit] if the target project allows it
if (canUseSkipLocalsInit)
{
attributes.Add(AttributeList(SingletonSeparatedList(Attribute(IdentifierName("global::System.Runtime.CompilerServices.SkipLocalsInit")))));
}
// Create the partial shader type declaration with the given method implementation.
// This code produces a struct declaration as follows:
//
// partial struct <SHADER_TYPE>
// {
// <METHOD>
// }
StructDeclarationSyntax structDeclarationSyntax =
StructDeclaration(hierarchyInfo.Names[0])
.AddModifiers(Token(SyntaxKind.PartialKeyword))
.AddMembers(methodDeclaration.AddAttributeLists(attributes.ToArray()));
TypeDeclarationSyntax typeDeclarationSyntax = structDeclarationSyntax;
// Add all parent types in ascending order, if any
foreach (string parentType in hierarchyInfo.Names.AsSpan().Slice(1))
{
typeDeclarationSyntax =
ClassDeclaration(parentType)
.AddModifiers(Token(SyntaxKind.PartialKeyword))
.AddMembers(typeDeclarationSyntax);
}
// Create the compilation unit with disabled warnings, target namespace and generated type.
// This will produce code as follows:
//
// #pragma warning disable
//
// namespace <NAMESPACE>;
//
// <TYPE_HIERARCHY>
return
(CompilationUnit().AddMembers(
FileScopedNamespaceDeclaration(IdentifierName(hierarchyInfo.Namespace))
.AddMembers(typeDeclarationSyntax)
.WithNamespaceKeyword(Token(TriviaList(
Trivia(PragmaWarningDirectiveTrivia(Token(SyntaxKind.DisableKeyword), true))),
SyntaxKind.NamespaceKeyword,
TriviaList())))
.NormalizeWhitespace(eol: "\n"));
}
}
private string GetSiteName(HierarchyInfo item)
{
throw new NotImplementedException();
}
public void RegisterHierarchy(IVsHierarchy hierarchy)
{
if ((null == hierarchy) || _hierarchies.ContainsKey(hierarchy)) {
return;
}
RegisterLibrary();
var commonProject = hierarchy.GetProject().GetCommonProject();
HierarchyListener listener = new HierarchyListener(hierarchy, this);
var node = _hierarchies[hierarchy] = new HierarchyInfo(
listener,
new ProjectLibraryNode(commonProject)
);
_library.AddNode(node.ProjectLibraryNode);
listener.StartListening(true);
RegisterForRDTEvents();
}
private static Func <TypeInfo, List <IndexInfo>, Dictionary <TypeInfo, IndexInfo>, IndexInfo> GetClusteredIndexChooser(HierarchyInfo hierarchy)
{
switch (hierarchy.InheritanceSchema)
{
case InheritanceSchema.ConcreteTable:
return(ChooseClusteredIndexConcreteTable);
case InheritanceSchema.ClassTable:
return(ChooseClusteredIndexClassTable);
case InheritanceSchema.SingleTable:
return(ChooseClusteredIndexSingleTable);
default:
throw new ArgumentOutOfRangeException("entityType.Hierarchy.InheritanceSchema");
}
}
/// <inheritdoc/>
/// <exception cref="NotSupportedException">Method is not supported.</exception>
protected override IPathNode VisitHierarchyInfo(HierarchyInfo hierarchy)
{
throw new NotSupportedException();
}
private string GetApplicationPath(HierarchyInfo item, string currentApplicationPath)
{
}
/// <summary>
/// Возвращает список кубов
/// </summary>
/// <returns></returns>
public CubeDefInfo GetCubeMetadata(String cubeName, MetadataQueryType type)
{
try
{
System.Diagnostics.Trace.TraceInformation("{0} Ranet.Olap.Core.Providers.OlapMetadataProvider Getting Cube '{1}' Metadata Started",
DateTime.Now.ToString(), cubeName);
CubeDef cube = FindCube(cubeName);
if (cube != null)
{
CubeDefInfo cube_info = InfoHelper.CreateCubeInfo(cube);
foreach (Dimension dim in cube.Dimensions)
{
DimensionInfo dim_info = InfoHelper.CreateDimensionInfo(dim);
cube_info.Dimensions.Add(dim_info);
foreach (Hierarchy hierarchy in dim.Hierarchies)
{
HierarchyInfo hier_info = InfoHelper.CreateHierarchyInfo(hierarchy);
dim_info.Hierarchies.Add(hier_info);
foreach (Level level in hierarchy.Levels)
{
LevelInfo level_info = InfoHelper.CreateLevelInfo(level);
hier_info.Levels.Add(level_info);
}
//AdomdConnection conn = GetConnection(ConnectionString);
//// Для каждой иерархии пытаемся определить элемент, который имеет тип MemberTypeEnum.All
//try
//{
// AdomdRestrictionCollection restrictions = new AdomdRestrictionCollection();
// restrictions.Add("CATALOG_NAME", conn.Database);
// restrictions.Add("CUBE_NAME", OlapHelper.ConvertToNormalStyle(cubeName));
// restrictions.Add("DIMENSION_UNIQUE_NAME", dim.UniqueName);
// restrictions.Add("HIERARCHY_UNIQUE_NAME", hierarchy.UniqueName);
// restrictions.Add("MEMBER_TYPE", 2/*MemberTypeEnum.All*/);
// DataSet ds = conn.GetSchemaDataSet("MDSCHEMA_MEMBERS", restrictions);
// if (ds != null && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
// {
// DataTable table = ds.Tables[0];
// if (table.Columns.Contains("MEMBER_UNIQUE_NAME"))
// {
// object obj = ds.Tables[0].Rows[0]["MEMBER_UNIQUE_NAME"];
// if (obj != null)
// hier_info.Custom_AllMemberUniqueName = obj.ToString();
// }
// }
//}catch
//{
//}
//// Для каждой иерархии пытаемся определить элемент, который имеет тип MemberTypeEnum.Unknown
//try
//{
// AdomdRestrictionCollection restrictions = new AdomdRestrictionCollection();
// restrictions.Add("CATALOG_NAME", conn.Database);
// restrictions.Add("CUBE_NAME", OlapHelper.ConvertToNormalStyle(cubeName));
// restrictions.Add("DIMENSION_UNIQUE_NAME", dim.UniqueName);
// restrictions.Add("HIERARCHY_UNIQUE_NAME", hierarchy.UniqueName);
// restrictions.Add("MEMBER_TYPE", 0 /*MemberTypeEnum.Unknown.All*/);
// DataSet ds = conn.GetSchemaDataSet("MDSCHEMA_MEMBERS", restrictions);
// if (ds != null && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
// {
// DataTable table = ds.Tables[0];
// if (table.Columns.Contains("MEMBER_UNIQUE_NAME"))
// {
// object obj = ds.Tables[0].Rows[0]["MEMBER_UNIQUE_NAME"];
// if (obj != null)
// hier_info.Custom_UnknownMemberUniqueName = obj.ToString();
// }
// }
//}
//catch
//{
//}
}
}
foreach (Kpi kpi in cube.Kpis)
{
KpiInfo kpi_info = InfoHelper.CreateKpiInfo(kpi);
cube_info.Kpis.Add(kpi_info);
}
foreach (Measure measure in cube.Measures)
{
MeasureInfo measure_info = InfoHelper.CreateMeasureInfo(measure);
cube_info.Measures.Add(measure_info);
}
foreach (NamedSet set in cube.NamedSets)
{
NamedSetInfo set_info = InfoHelper.CreateNamedSetInfo(set);
cube_info.NamedSets.Add(set_info);
}
if (type == MetadataQueryType.GetCubeMetadata_AllMembers)
{
AdomdConnection conn = GetConnection();
// Для каждой иерархии пытаемся определить элемент, который имеет тип MemberTypeEnum.All
try
{
AdomdRestrictionCollection restrictions = new AdomdRestrictionCollection();
restrictions.Add("CATALOG_NAME", conn.Database);
restrictions.Add("CUBE_NAME", OlapHelper.ConvertToNormalStyle(cubeName));
restrictions.Add("MEMBER_TYPE", 2 /*MemberTypeEnum.All*/);
DataSet ds = conn.GetSchemaDataSet("MDSCHEMA_MEMBERS", restrictions);
if (ds != null && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
{
DataTable table = ds.Tables[0];
if (table.Columns.Contains("MEMBER_UNIQUE_NAME") &&
table.Columns.Contains("HIERARCHY_UNIQUE_NAME") &&
table.Columns.Contains("DIMENSION_UNIQUE_NAME"))
{
foreach (DataRow row in ds.Tables[0].Rows)
{
String dimension_UniqueName = row["DIMENSION_UNIQUE_NAME"] != null ? row["DIMENSION_UNIQUE_NAME"].ToString() : String.Empty;
String hierarchy_UniqueName = row["HIERARCHY_UNIQUE_NAME"] != null ? row["HIERARCHY_UNIQUE_NAME"].ToString() : String.Empty;
String member_UniqueName = row["MEMBER_UNIQUE_NAME"] != null ? row["MEMBER_UNIQUE_NAME"].ToString() : String.Empty;
if (!String.IsNullOrEmpty(dimension_UniqueName) &&
!String.IsNullOrEmpty(hierarchy_UniqueName) &&
!String.IsNullOrEmpty(member_UniqueName))
{
DimensionInfo dimension = cube_info.GetDimension(dimension_UniqueName);
if (dimension != null)
{
HierarchyInfo hierarchy = dimension.GetHierarchy(hierarchy_UniqueName);
if (hierarchy != null)
{
hierarchy.Custom_AllMemberUniqueName = member_UniqueName;
}
}
}
}
}
}
}
catch (Exception ex)
{
//throw ex;
}
}
cube_info.MeasureGroups = GetMeasureGroups(cubeName);
return(cube_info);
}
return(null);
}
finally {
System.Diagnostics.Trace.TraceInformation("{0} Ranet.Olap.Core.Providers.OlapMetadataProvider Getting Cube '{1}' Metadata Completed",
DateTime.Now.ToString(), cubeName);
}
}
private string GetApplicationPath(HierarchyInfo item)
{
}
