private void SortHierarchy()
{
popupHierarchy = new Hierarchy(windowSize.x - 26.0f, 17.0f, this);
var favourites = propertyBoxes.Where(propertyBox => propertyBox.Favourite);
var suggestions = propertyBoxes.Where(propertyBox => PropertyFieldInfoUtility.IsSuggestedProperty(propertyBox.Component, propertyBox.PropertyName));
var displayableProperties = propertyBoxes.ToList();
var favouritesItem = new LabelHierarchyItem("Favourites");
popupHierarchy.AddChild(favouritesItem);
if (!favourites.Any())
{
var emptyLabelItem = new LabelHierarchyItem("Click the heart next to any property.");
favouritesItem.Children = new List <IHierarchyItem>()
{
emptyLabelItem,
};
}
else
{
favouritesItem.Children = new List <IHierarchyItem>();
foreach (var favourite in favourites)
{
favouritesItem.Children.Add(new FavouriteHierarchyItem(favourite));
}
}
if (suggestions.Any())
{
var suggestionsLabel = new LabelHierarchyItem("Suggestions");
popupHierarchy.AddChild(suggestionsLabel);
suggestionsLabel.Children = new List <IHierarchyItem>();
foreach (var suggested in suggestions)
{
if (favourites.Contains(suggested))
{
continue;
}
suggestionsLabel.Children.Add(new SuggestionHierarchyItem(suggested));
}
}
var allPropertiesItem = new LabelHierarchyItem("All Properties");
allPropertiesItem.Children = new List <IHierarchyItem>();
popupHierarchy.AddChild(allPropertiesItem);
var components = displayableProperties.Select(displayableProperty => displayableProperty.Component);
components = components.Distinct().ToList();
foreach (var component in components)
{
var properties = displayableProperties.Where(displayableProperty => displayableProperty.Component == component).ToList();
allPropertiesItem.Children.Add(new ComponentHierarchyItem(component, properties));
}
}
public void SetParent(Hierarchy newParent)
{
var rTransform = (RectTransform)transform;
if (parent != null)
{
var position = rTransform.GetParent().GetWorldPoint(rTransform.anchorMin);
var size = rTransform.GetSizeWorld();
transform.SetParent(newParent.transform, false);
parent.RemoveChild(this);
rTransform.SetPositionAnchorLocal(rTransform.GetParent().GetLocalPoint(position));
rTransform.SetSizeWorld(size);
}
else
{
transform.SetParent(newParent.transform, false);
}
parent = newParent;
parent.AddChild(this);
if (!HierarchyView.IsCreated(gameObject))
{
HierarchyView.AddChild(gameObject);
}
HierarchyView.ChangeParent(parent.gameObject, gameObject);
}
public static Hierarchy <LayoutItem> GetExpandedExtensions(Hierarchy <LayoutItem> axisnode, Table table)
{
var result = new Hierarchy <LayoutItem>(new LayoutItem());
var taxonomy = table.Taxonomy;
//get the domain ids of the extensions
var domains = new List <int>();
var layoutnodes = axisnode.All().Where(i => i.Item.IsLayout).ToList();
foreach (var lnode in layoutnodes)
{
var dimensions = lnode.Item.Dimensions.Select(i => i.DomMapID).ToList();
domains.AddRange(dimensions);
}
domains = domains.Distinct().ToList();
//get the factindexes for a given cell
var firstcellix = int.Parse(table.LayoutCellDictionary.FirstOrDefault().Key);
var indexes = new List <int>();
for (int i = 0; i < table.FactIndexToCells.Count; i++)
{
var item = table.FactIndexToCells[i];
if (item.v2 != firstcellix)
{
break;
}
indexes.Add(item.v1);
}
//extract the keyparts of the domains of the extensions
var extensionskeys = new List <int[]>();
foreach (var ix in indexes)
{
var key = table.Taxonomy.FactsManager.GetFactKey(ix);
var xkey = table.Taxonomy.GetPartsOfDomains(key, domains);
extensionskeys.Add(xkey.ToArray());
}
//set the labels
foreach (var extensionkey in extensionskeys)
{
var sbtitle = new StringBuilder();
var sbdescription = new StringBuilder();
var aggregatelabel = new Label();
foreach (var keypart in extensionkey)
{
var l = taxonomy.GetLabelForAspect(keypart);
aggregatelabel.Code = aggregatelabel.Code + "|" + l.Code;
aggregatelabel.Content = aggregatelabel.Content + "|" + l.Content;
}
result.Item.Label = aggregatelabel;
var li = new LayoutItem();
li.Category = LayoutItemCategory.Rule;
li.Label = aggregatelabel;
var h = new Hierarchy <LayoutItem>(li);
result.AddChild(h);
}
return(result);
}
public static void SetDynamicAxis2(Table table, Hierarchy <LayoutItem> source, Hierarchy <LayoutItem> target)
{
var aspects = source.Where(i => i.Item.Category == LayoutItemCategory.Aspect).ToList();
var targetAxisnode = target.FirstOrDefault(i => !String.IsNullOrEmpty(i.Item.Axis));
var sourceAxisnode = source.FirstOrDefault(i => !String.IsNullOrEmpty(i.Item.Axis));
if (targetAxisnode != null)
{
var aspect_source_dimensions = new List <Dimension>();
var ix = 0;
foreach (var aspect in aspects)
{
aspect.Item.LabelID = aspect.Parent.Item.LabelID;
aspect.Item.Label = aspect.Parent.Item.Label;
aspect.Item.LabelContent = aspect.Parent.Item.LabelContent;
aspect.Item.LabelCode = String.Format(Table.KeyLabelCodeFormat, ix);
aspect.Item.LabelID = "";
var rolenode = aspect.FirstOrDefault(i => !String.IsNullOrEmpty(i.Item.Role));
if (rolenode != null)
{
aspect.Item.Role = rolenode.Item.Role;
aspect.Item.RoleAxis = rolenode.Item.RoleAxis;
}
aspect.Item.Category = LayoutItemCategory.Key;
SetDimensions(aspect);
targetAxisnode.Children.Insert(ix, aspect);
source.Remove(aspect.Parent);
aspect.Parent.Remove(aspect);
aspect.Parent = targetAxisnode;
ix++;
aspect_source_dimensions.AddRange(aspect.Item.Dimensions);
//aspect.Item.Dimensions.Clear();
}
var visiblenodes = source.Where(i => i.Item.IsVisible);
if (aspects.Count > 0)
{
var dyn_li = new LayoutItem();
dyn_li.ID = "dynamic_" + sourceAxisnode.Item.Axis;
dyn_li.Dimensions = aspect_source_dimensions;
dyn_li.Category = LayoutItemCategory.Dynamic;
dyn_li.LabelCode = Literals.DynamicCode;
//var dyn_h = new Hierarchy<LayoutItem>(dyn_li);
//source.Item = dyn_li;
var dyn_hli = new Hierarchy <LayoutItem>(dyn_li);
source.AddChild(dyn_hli);
}
//source.Item
}
}
public void AddChildEntity(MyEntity child)
{
if (MyFakes.ENABLE_PLANET_HIERARCHY)
{
var bbox = child.PositionComp.WorldAABB;
ProfilerShort.Begin("Add sector to tree.");
int proxyId = m_sectors.AddProxy(ref bbox, child, 0);
ProfilerShort.BeginNextBlock("Add to child hierarchy.");
Hierarchy.AddChild(child, true);
ProfilerShort.End();
MyHierarchyComponentBase childHierarchy = child.Components.Get <MyHierarchyComponentBase>();
childHierarchy.ChildId = proxyId;
}
else
{
MyEntities.Add(child);
}
}
public static void ProjectNodes(Hierarchy <LayoutItem> axisnode)
{
var nodes = axisnode.Children.Where(i => Utilities.ObjectExtensions.In(i.Item.Category, LayoutItemCategory.BreakDown, LayoutItemCategory.Dynamic)).ToList();
//Project Axisnodes
if (nodes.Count > 0)
{
var basenode = nodes.FirstOrDefault();
for (int i = 1; i < nodes.Count; i++)
{
var node = nodes[i];
var baseleafs = basenode.GetLeafs();
var projectionnodes = node.GetLeafs();
foreach (var leaf in baseleafs)
{
foreach (var projectionnode in projectionnodes)
{
var copynode = projectionnode.Copy();
copynode.All().ForEach(n => n.Item = new LayoutItem(n.Item));
leaf.AddChild(copynode);
leaf.Item.IsAbstract = true;
}
}
}
if (nodes.Count > 1)
{
var li = new LayoutItem();
li.Category = LayoutItemCategory.BreakDown;
li.Axis = axisnode.Item.Axis;
li.ID = "Effective_Breakdown_" + li.Axis;
li.LabelID = li.ID;
var hli = new Hierarchy <LayoutItem>(li);
hli.AddChild(basenode);
axisnode.Clear();
axisnode.AddChild(hli);
}
}
}
protected Hierarchy <Link> GetXbrlRendering()
{
var result = new Hierarchy <Link>();
foreach (var arc in Arcs)
{
var from = Identifiables.FirstOrDefault(i => i.LabelID == arc.From);
var to = Identifiables.FirstOrDefault(i => i.LabelID == arc.To);
var harc = new Hierarchy <Link>(arc);
var hfrom = new Hierarchy <Link>(from);
var hto = new Hierarchy <Link>(to);
hfrom.AddChild(harc);
harc.AddChild(hto);
if (result.Item == null)
{
result = hfrom;
}
}
while (result.Parent != null)
{
result = result.Parent;
}
return(result);
}
public void AttachPilot(MyCharacter pilot, bool storeOriginalPilotWorld = true, bool calledFromInit = false)
{
System.Diagnostics.Debug.Assert(pilot != null);
System.Diagnostics.Debug.Assert(m_pilot == null);
m_pilot = pilot;
m_pilot.OnMarkForClose += m_pilotClosedHandler;
m_pilot.IsUsing = this;
//m_soundEmitter.OwnedBy = m_pilot;
if (MyFakes.ENABLE_NEW_SOUNDS)
{
StartLoopSound();
}
if (storeOriginalPilotWorld)
{
m_pilotRelativeWorld = (Matrix)MatrixD.Multiply(pilot.WorldMatrix, this.PositionComp.GetWorldMatrixNormalizedInv());
if (Sync.IsServer)
{
var relativeEntry = new MyPositionAndOrientation(m_pilotRelativeWorld.Value);
SyncObject.SendPilotRelativeEntryUpdate(ref relativeEntry);
}
}
if (pilot.InScene)
{
MyEntities.Remove(pilot);
}
m_pilot.Physics.Enabled = false;
m_pilot.PositionComp.SetWorldMatrix(WorldMatrix);
m_pilot.Physics.Clear();
//m_pilot.SetPosition(GetPosition() - WorldMatrix.Forward * 0.5f);
Hierarchy.AddChild(m_pilot, true, true);
var gunEntity = m_pilot.CurrentWeapon as MyEntity;
if (gunEntity != null)
{
var ob = gunEntity.GetObjectBuilder();
m_pilotGunDefinition = ob.GetId();
}
else
{
m_pilotGunDefinition = null;
}
MyAnimationDefinition animationDefinition;
MyDefinitionId id = new MyDefinitionId(typeof(MyObjectBuilder_AnimationDefinition), BlockDefinition.CharacterAnimation);
if (!MyDefinitionManager.Static.TryGetDefinition(id, out animationDefinition) && !MyFileSystem.FileExists(BlockDefinition.CharacterAnimation))
{
BlockDefinition.CharacterAnimation = null;
}
PlacePilotInSeat(pilot);
m_rechargeSocket.PlugIn(m_pilot.SuitBattery);
// Control should be handled elsewhere if we initialize the grid in the Init(...)
if (!calledFromInit)
{
GiveControlToPilot();
}
m_pilot.SwitchToWeapon(null);
}
public Message ProcessRequest(Message request)
{
var ajaxtag = "ajax";
//Logger.WriteLine("ProcessRequest " + request.Url);
Message result = new Message();
result.Id = request.Id;
result.Url = request.Url;
result.Error = "";
result.ContentType = request.ContentType;
result.Category = request.Category;
if (request.Category == "notification")
{
Utilities.Logger.WriteLine(request.Data);
if (request.Data.ToLower().Contains("ui ready"))
{
AppEngine.Features.OnUIReady();
//AppEngine.Features.LoadTaxonomyToUI();
}
}
if (request.Category == ajaxtag)
{
if (Utilities.FS.FileExists(request.Url))
{
result.Data = Utilities.FS.ReadAllText(request.Url);
}
else
{
var filextension = "";
var extix = request.Url.LastIndexOf(".");
if (extix > -1)
{
filextension = request.Url.Substring(extix + 1);
}
if (filextension.In("html"))
{
var table = Engine.CurrentTaxonomy.Tables.FirstOrDefault(i => i.HtmlPath == request.Url);
if (table != null)
{
result.Data = Utilities.FS.ReadAllText(table.FullHtmlPath);
}
}
if (filextension.In("xml", "xsd"))
{
var doc = Engine.CurrentTaxonomy.TaxonomyDocuments.FirstOrDefault(i => i.LocalRelPath == request.Url);
if (doc != null)
{
result.Data = Utilities.FS.ReadAllText(doc.LocalPath);
}
}
var urlparts = request.Url.Split(new string[] { "/" }, StringSplitOptions.RemoveEmptyEntries);
if (urlparts.Length == 2)
{
var part0 = urlparts[0].ToLower();
var part1 = urlparts[1].ToLower();
if (part0 == "settings")
{
var settings = Settings.Current;
if (part1 == "get")
{
result.Data = settings.GetJsonObj();
}
if (part1 == "save")
{
var keys = settings.Keys.ToList();
foreach (var key in keys)
{
var value = request.GetParameter(key);
settings.SetValue(key, value);
}
//settings.CheckValidationCells = request.GetParameter<bool>("CheckValidationCells");
//settings.ReDownloadFiles = request.GetParameter<bool>("ReDownloadFiles");
//settings.ReloadFullTaxonomy = request.GetParameter<bool>("ReloadFullTaxonomy");
//settings.ReloadFullTaxonomyButStructure = request.GetParameter<bool>("ReloadFullTaxonomyButStructure");
if (settings.ReloadFullTaxonomy)
{
settings.ReloadFullTaxonomyButStructure = true;
}
//settings.ReloadTaxonomyOnInstanceLoaded = request.GetParameter<bool>("ReloadTaxonomyOnInstanceLoaded");
//settings.ValidateOnInstanceLoaded = request.GetParameter<bool>("ValidateOnInstanceLoaded");
this.AppEngine.Features.SaveSettings();
}
}
if (part0 == "instance")
{
if (Engine.CurrentInstance != null && Engine.CurrentTaxonomy != null)
{
if (part1 == "get")
{
var json = Utilities.FS.ReadAllText(Engine.CurrentTaxonomy.CurrentInstancePath);
json = json.Replace("\r\n", "");
result.Data = json;
}
if (part1 == "save")
{
var factsjson = request.GetParameter("facts");
var facts = Utilities.Converters.JsonTo <List <InstanceFact> >(factsjson);
var json = Utilities.FS.ReadAllText(Engine.CurrentTaxonomy.CurrentInstancePath);
Engine.CurrentInstance.SaveFacts(facts);
this.AppEngine.Features.SaveInstance("");
//result.Data = "Ok";
}
if (part1 == "validation")
{
var json = Utilities.FS.ReadAllText(Engine.CurrentTaxonomy.CurrentInstanceValidationResultPath);
result.Data = json;
}
if (part1 == "factindexes")
{
var indexes_str = request.GetParameter("indexes").ToLower();
var indexes = indexes_str.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries).ToList();
var items = Engine.CurrentInstance.GetFactStringsByFactIdStrings(indexes);
var json = Utilities.Converters.ToJson(items);
result.Data = json;
}
if (part1 == "validationresults")
{
var page = int.Parse(request.GetParameter("page"));
var pagesize = int.Parse(request.GetParameter("pagesize"));
var ruleid = request.GetParameter("ruleid").ToLower();
var full = request.GetParameter("full").ToLower();
var taxonomy = AppEngine.Features.Engine.CurrentTaxonomy;
var instance = AppEngine.Features.Engine.CurrentInstance;
var rs = new DataResult <LogicalModel.Validation.ValidationRuleResult>();
var query = Engine.CurrentInstance.ValidationRuleResults.AsQueryable();
if (full == "1")
{
SimpleValidationRule rule = taxonomy.ValidationRules.FirstOrDefault(i => i.ID.Equals(ruleid, StringComparison.OrdinalIgnoreCase));
if (rule == null)
{
rule = taxonomy.SimpleValidationRules.FirstOrDefault(i => i.ID.Equals(ruleid, StringComparison.OrdinalIgnoreCase));
}
if (rule != null)
{
query = rule.GetAllInstanceResults(instance).AsQueryable();
}
else
{
Utilities.Logger.WriteLine(String.Format("Rule {0} was not Found (DataService)", ruleid));
}
}
query = query.Where(i => i.ID.Equals(ruleid, StringComparison.OrdinalIgnoreCase));
//TODO
var idlist = new List <int>();
rs.Items = query.Skip(pagesize * page).Take(pagesize).ToList();
foreach (var item in rs.Items)
{
foreach (var p in item.Parameters)
{
foreach (var fid in p.FactIDs)
{
var fact = instance.GetFactBaseByIndexString(fid);
if (fact != null)
{
//p.Facts.Add(fact.FactString);
}
}
}
}
rs.Total = query.Count();
var json = Utilities.Converters.ToJson(rs);
foreach (var item in rs.Items)
{
foreach (var p in item.Parameters)
{
p.InstanceFacts.Clear();
}
}
result.Data = json;
}
}
}
if (part0 == "layout")
{
var url = request.Url.Replace("/", "\\");
var content = System.IO.File.ReadAllText(url);
result.Data = content;
}
if (part0 == "ui")
{
if (part1 == "menu")
{
var commandid = request.GetParameter("command").ToLower();
var p1 = request.GetParameter("p1").ToLower();
if (!string.IsNullOrEmpty(commandid))
{
var command = this.AppEngine.Features.CommandContainer.Where(i => i.ID.ToLower() == commandid).FirstOrDefault();
if (command != null)
{
var originalca = command.ContextAccessor;
command.ContextAccessor = () => { return(new object[] { p1 }); };
command.Execute();
command.ContextAccessor = originalca;
}
}
else
{
var json = AppEngine.Features.GetJsonObj(AppEngine.Features.CommandContainer);
result.Data = json;
}
}
}
if (part0 == "browse")
{
var json = "";
if (part1 == "file")
{
json = AppEngine.Features.UI.BrowseFile("", "");
}
if (part1 == "folder")
{
json = AppEngine.Features.UI.BrowseFolder("");
}
result.Data = json;
}
if (part0 == "app")
{
var json = "";
if (part1 == "info")
{
json = AppEngine.Features.GetAppInfo();
}
result.Data = json;
}
if (part0 == "taxonomy")
{
var json = "";
if (Engine.CurrentTaxonomy != null)
{
if (part1 == "get")
{
json = Utilities.FS.ReadAllText(Engine.CurrentTaxonomy.TaxonomyModulePath);
}
if (part1 == "concepts")
{
json = Utilities.FS.ReadAllText(Engine.CurrentTaxonomy.TaxonomyConceptPath);
}
if (part1 == "cellindexes")
{
json = Utilities.FS.ReadAllText(Engine.CurrentTaxonomy.TaxonomyCellIndexPath);
}
if (part1 == "documents")
{
json = Utilities.FS.ReadAllText(Engine.CurrentTaxonomy.TaxonomyStructurePath);
if (Utilities.FS.FileExists(Engine.CurrentInstance.FullPath))
{
var td = new TaxonomyDocument();
td.LocalRelPath = Engine.CurrentInstance.FullPath;
td.FileName = Utilities.Strings.GetFileName(td.LocalRelPath);
var instjson = Utilities.Converters.ToJson(td);
json = json.Insert(json.IndexOf("[") + 1, instjson + ", ");
}
}
if (part1 == "validationrules")
{
json = Utilities.FS.ReadAllText(Engine.CurrentTaxonomy.TaxonomySimpleValidationPath);
}
if (part1 == "validationrule")
{
var id = request.Parameters["id"];
var rule = Engine.CurrentTaxonomy.ValidationRules.FirstOrDefault(i => i.ID == id);
if (rule != null)
{
var results = Engine.CurrentInstance.Facts.Count > 0 ? rule.GetAllInstanceResults(Engine.CurrentInstance) : rule.GetAllResults();
json = Utilities.Converters.ToJson(results);
}
}
if (part1 == "hierarchies")
{
json = Utilities.FS.ReadAllText(Engine.CurrentTaxonomy.TaxonomyHierarchyPath);
}
if (part1 == "labels")
{
var page = int.Parse(request.GetParameter("page"));
var pagesize = int.Parse(request.GetParameter("pagesize"));
var key = request.GetParameter("key");
var code = request.GetParameter("code");
var content = request.GetParameter("content");
var query = AppEngine.Features.Engine.CurrentTaxonomy.TaxonomyLabels.AsQueryable();
if (!String.IsNullOrEmpty(key))
{
query = query.Where(i => i.Key.IndexOf(key, StringComparison.InvariantCultureIgnoreCase) > -1);
}
if (!String.IsNullOrEmpty(code))
{
query = query.Where(i => i.Code.IndexOf(code, StringComparison.InvariantCultureIgnoreCase) > -1);
}
if (!String.IsNullOrEmpty(content))
{
query = query.Where(i => i.Content.IndexOf(content, StringComparison.InvariantCultureIgnoreCase) > -1);
}
var rs = new DataResult <Label>();
rs.Items = query.Skip(pagesize * page).Take(pagesize).ToList();
rs.Total = query.Count();
json = Utilities.Converters.ToJson(rs);
}
if (part1 == "facts")
{
var page = int.Parse(request.GetParameter("page"));
var pagesize = int.Parse(request.GetParameter("pagesize"));
var factstring = request.GetParameter("factstring");
var cellid = request.GetParameter("cellid").ToLower();
var rs = new DataResult <KeyValue>();
var taxonomy = Engine.CurrentTaxonomy;
var query = taxonomy.FactIndexEnumerable();
var qry = LogicalModel.Base.FactBaseQuery.GetQuery(factstring, Engine.CurrentTaxonomy.FactParts);
if (qry != null)
{
var all = new Interval(0, taxonomy.FactsManager.FactsOfPages.HashKeys.Count);
var allist = new IntervalList();
allist.AddInterval(all);
var idlist2 = qry.EnumerateIntervals(taxonomy.FactsOfParts, 0, allist, false).SelectMany(i => i);
var indexes = idlist2.Select(i => i).Distinct().ToDictionary(k => k, v => true);
var comparer = new Utilities.IntArrayEqualityComparer();
query = query.Where(i => indexes.ContainsKey(i));
}
if (!String.IsNullOrEmpty(cellid))
{
//var cells = taxonomy.CellIndexDictionary.Where(i => i.Value.IndexOf(cellid, StringComparison.Ordinal)>-1).Select(i=>i.Key);
//longcellid=cellid
//query = query.Where(i => i.Value.Any(j => cells.Contains(j)));
query = query.Where(i => taxonomy.FactsManager.GetFact(i).Value.Any(j => taxonomy.CellIndexDictionary[j].IndexOf(cellid, StringComparison.OrdinalIgnoreCase) > -1));
}
rs.Items = query.Skip(pagesize * page).Take(pagesize).Select(i =>
{
var keycell = taxonomy.FactsManager.GetFactKeywithCells(i);
var keystr = taxonomy.GetFactStringKey(keycell.FactKey);
return(new KeyValue(keystr, keycell.CellIndexes)); //.Select(c => taxonomy.CellIndexDictionary[c]).ToList()
}
).ToList();
rs.Total = query.Count();
json = Utilities.Converters.ToJson(rs);
}
if (part1 == "table")
{
if (request.Parameters.ContainsKey("cell"))
{
var cell = request.Parameters["cell"];
var report = "";
var extension = "";
var row = "";
var column = "";
if (cell.IndexOf(">") > -1)
{
report = cell.Remove(cell.IndexOf("<"));
var cellspecifiers = cell.TextBetween("<", ">").Split('|');
var nr_params = cellspecifiers.Length;
extension = nr_params > 0 ? cellspecifiers[0] : "";
row = nr_params > 1 ? cellspecifiers[1] : "";
column = nr_params > 2 ? cellspecifiers[2] : "";
}
else
{
report = cell;
}
json = GetTableHtmlPath(report, extension, row, column);
}
if (request.Parameters.ContainsKey("item"))
{
var item = request.Parameters["item"];
if (item == "factmap")
{
var reportid = request.Parameters["reportid"];
var table = this.Engine.CurrentTaxonomy.Tables.FirstOrDefault(i => i.ID == reportid);
if (table != null)
{
json = Utilities.FS.ReadAllText(table.FactMapPath);
}
}
}
}
if (part1 == "tables")
{
var h = new BaseModel.Hierarchy <TableInfo>();
var tablegroups = Engine.CurrentTaxonomy.Module.TableGroups.Cast <TableInfo>(i =>
{
var ti = new TableInfo();
ti.ID = i.ID;// String.IsNullOrEmpty(i.FilingIndicator) ? i.ID : i.FilingIndicator;
ti.Tables = i.TableIDs;
//var name = String.IsNullOrEmpty(i.LabelCode) ? i.LabelContent : i.LabelCode;
var name = String.IsNullOrEmpty(i.FilingIndicator) ? i.LabelContent : i.FilingIndicator;
ti.Name = Utilities.Strings.TrimTo(name, 40);
ti.Description = i.LabelContent;
ti.Type = "tablegroup";
return(ti);
});
var tgs = tablegroups.All();
var tablesingroups = tgs.SelectMany(i => i.Item.Tables).Distinct().ToList();
var alltableids = Engine.CurrentTaxonomy.Tables.Select(i => i.ID).ToList();
var ungrouped = alltableids.Except(tablesingroups).ToList();
foreach (var tgcontainer in tgs)
{
var tg = tgcontainer.Item;
var htg = tgcontainer;// new BaseModel.Hierarchy<LogicalModel.TableInfo>(tg);
//h.Children.Add(htg);
//var tables = Engine.CurrentTaxonomy.Tables.Where(i => i.FilingIndicator == tg.ID);
var tables = Engine.CurrentTaxonomy.Tables.Where(i => tg.Tables.Contains(i.ID)).ToList();
if (tables.Count > 0)
{
//htg.Children.Clear();
}
foreach (var tbl in tables)
{
var tbinfo = new TableInfo();
var ht = htg.Children.FirstOrDefault(i => i.Item.ID == tbl.ID);
if (ht == null)
{
ht = new BaseModel.Hierarchy <TableInfo>(tbinfo);
htg.Children.Add(ht);
}
ht.Item.ID = String.Format("{0}<>", tbl.ID);
ht.Item.HasData = tbl.InstanceFactsCount;
var name = tbl.Name;
ht.Item.Name = Utilities.Strings.TrimTo(name, 40);
ht.Item.Description = string.IsNullOrEmpty(tbl.LabelContent) ? name : tbl.LabelContent;
ht.Item.Type = "table";
//TODO EXT
//var tbextensions = tbl.Extensions.Children;
var tbextensions = Engine.CurrentInstance.GetTableExtensions(tbl);
ht.Children.AddRange(tbextensions.Select(i => new BaseModel.Hierarchy <TableInfo>(i)));
}
}
h = tablegroups;
if (ungrouped.Count > 0)
{
var ungroupedti = new TableInfo();
ungroupedti.Type = "tablegroup";
ungroupedti.Name = "Ungrouped";
var hungr = new Hierarchy <TableInfo>(ungroupedti);
h.AddChild(hungr);
foreach (var t in ungrouped)
{
var tbinfo = new TableInfo();
var tbl = Engine.CurrentTaxonomy.Tables.FirstOrDefault(i => i.ID == t);
var ht = new BaseModel.Hierarchy <TableInfo>(tbinfo);
ht.Item.ID = String.Format("{0}<>", tbl.ID);
ht.Item.HasData = tbl.InstanceFactsCount;
var name = tbl.Name;
ht.Item.Name = Utilities.Strings.TrimTo(name, 40);
ht.Item.Description = string.IsNullOrEmpty(tbl.LabelContent) ? name : tbl.LabelContent;
ht.Item.Type = "table";
hungr.AddChild(ht);
}
}
var itemswithdata = h.Where(i => i.Item.HasData > 0).ToList();
foreach (var itemwithdata in itemswithdata)
{
var current = itemwithdata;
while (current.Parent != null)
{
current = current.Parent;
current.Item.HasData = itemwithdata.Item.HasData;
}
}
json = Utilities.Converters.ToJson(h);
}
}
result.Data = json;
}
}
}
//Logger.WriteLine("Finished " + request.Url);
}
return(result);
}
