public Tree(int sortOrder, string applicationAlias, string group, string alias, string title, TreeUse use, Type treeControllerType, bool isSingleNodeTree)
{
SortOrder = sortOrder;
SectionAlias = applicationAlias ?? throw new ArgumentNullException(nameof(applicationAlias));
TreeGroup = group;
TreeAlias = alias ?? throw new ArgumentNullException(nameof(alias));
TreeTitle = title;
TreeUse = use;
TreeControllerType = treeControllerType ?? throw new ArgumentNullException(nameof(treeControllerType));
IsSingleNodeTree = isSingleNodeTree;
}
public override Tree Build()
{
var sortOrder = _sortOrder ?? 1;
var alias = _alias ?? "testTree";
var sectionAlias = _sectionAlias ?? Constants.Applications.Content;
var group = _group ?? string.Empty;
var title = _title ?? string.Empty;
TreeUse treeUse = _treeUse ?? TreeUse.Main;
var isSingleNode = _isSingleNode ?? false;
return(new Tree(sortOrder, sectionAlias, group, alias, title, treeUse, typeof(SampleTreeController), isSingleNode));
}
public void HasFlagAnyTest(TreeUse value, TreeUse test, bool expected)
{
// The HasFlagAny() extension method determines whether
// at least one bit from <test> is set.
if (expected)
{
Assert.IsTrue(value.HasFlagAny(test));
}
else
{
Assert.IsFalse(value.HasFlagAny(test));
}
}
public void HasFlagAllTest(TreeUse value, TreeUse test, bool expected)
{
// The HasFlagAll() extension method determines whether
// all bits from <test> are set (other bits can be set too).
if (expected)
{
Assert.IsTrue(value.HasFlagAll(test));
}
else
{
Assert.IsFalse(value.HasFlagAll(test));
}
}
public void HasFlagTest(TreeUse value, TreeUse test, bool expected)
{
// The built-in Enum.HasFlag() method determines whether
// all bits from <test> are set (other bits can be set too).
if (expected)
{
Assert.IsTrue(value.HasFlag(test));
}
else
{
Assert.IsFalse(value.HasFlag(test));
}
}
/// <summary>
/// Returns the tree nodes for an application
/// </summary>
/// <param name="application">The application to load tree for</param>
/// <param name="tree">An optional single tree alias, if specified will only load the single tree for the request app</param>
/// <param name="queryStrings">The query strings</param>
/// <param name="use">Tree use.</param>
public async Task <ActionResult <TreeRootNode> > GetApplicationTrees(string application, string tree, [ModelBinder(typeof(HttpQueryStringModelBinder))] FormCollection queryStrings, TreeUse use = TreeUse.Main)
{
application = application.CleanForXss();
if (string.IsNullOrEmpty(application))
{
return(NotFound());
}
var section = _sectionService.GetByAlias(application);
if (section == null)
{
return(NotFound());
}
// find all tree definitions that have the current application alias
var groupedTrees = _treeService.GetBySectionGrouped(application, use);
var allTrees = groupedTrees.Values.SelectMany(x => x).ToList();
if (allTrees.Count == 0)
{
// if there are no trees defined for this section but the section is defined then we can have a simple
// full screen section without trees
var name = _localizedTextService.Localize("sections", application);
return(TreeRootNode.CreateSingleTreeRoot(Constants.System.RootString, null, null, name, TreeNodeCollection.Empty, true));
}
// handle request for a specific tree / or when there is only one tree
if (!tree.IsNullOrWhiteSpace() || allTrees.Count == 1)
{
var t = tree.IsNullOrWhiteSpace()
? allTrees[0]
: allTrees.FirstOrDefault(x => x.TreeAlias == tree);
if (t == null)
{
return(NotFound());
}
var treeRootNode = await GetTreeRootNode(t, Constants.System.Root, queryStrings);
if (treeRootNode != null)
{
return(treeRootNode);
}
return(NotFound());
}
// handle requests for all trees
// for only 1 group
if (groupedTrees.Count == 1)
{
var nodes = new TreeNodeCollection();
foreach (var t in allTrees)
{
var nodeResult = await TryGetRootNode(t, queryStrings);
if (!(nodeResult.Result is null))
{
return(nodeResult.Result);
}
var node = nodeResult.Value;
if (node != null)
{
nodes.Add(node);
}
}
var name = _localizedTextService.Localize("sections", application);
if (nodes.Count > 0)
{
var treeRootNode = TreeRootNode.CreateMultiTreeRoot(nodes);
treeRootNode.Name = name;
return(treeRootNode);
}
// otherwise it's a section with all empty trees, aka a fullscreen section
// todo is this true? what if we just failed to TryGetRootNode on all of them? SD: Yes it's true but we should check the result of TryGetRootNode and throw?
return(TreeRootNode.CreateSingleTreeRoot(Constants.System.RootString, null, null, name, TreeNodeCollection.Empty, true));
}
// for many groups
var treeRootNodes = new List <TreeRootNode>();
foreach (var(groupName, trees) in groupedTrees)
{
var nodes = new TreeNodeCollection();
foreach (var t in trees)
{
var nodeResult = await TryGetRootNode(t, queryStrings);
if (nodeResult != null && nodeResult.Result is not null)
{
return(nodeResult.Result);
}
var node = nodeResult?.Value;
if (node != null)
{
nodes.Add(node);
}
}
if (nodes.Count == 0)
{
continue;
}
// no name => third party
// use localization key treeHeaders/thirdPartyGroup
// todo this is an odd convention
var name = groupName.IsNullOrWhiteSpace() ? "thirdPartyGroup" : groupName;
var groupRootNode = TreeRootNode.CreateGroupNode(nodes, application);
groupRootNode.Name = _localizedTextService.Localize("treeHeaders", name);
treeRootNodes.Add(groupRootNode);
}
return(TreeRootNode.CreateGroupedMultiTreeRoot(new TreeNodeCollection(treeRootNodes.OrderBy(x => x.Name))));
}
public void SetFlagTests(TreeUse value, TreeUse flag, TreeUse expected)
{
Assert.AreEqual(expected, value.SetFlag(flag));
}
public TreeBuilder WithTreeUse(TreeUse treeUse)
{
_treeUse = treeUse;
return(this);
}
/// <inheritdoc />
public IDictionary <string, IEnumerable <Tree> > GetBySectionGrouped(string sectionAlias, TreeUse use = TreeUse.Main)
{
return(GetBySection(sectionAlias, use).GroupBy(x => x.TreeGroup).ToDictionary(
x => x.Key ?? "",
x => (IEnumerable <Tree>)x.ToArray()));
}
/// <inheritdoc /> public IEnumerable <Tree> GetBySection(string sectionAlias, TreeUse use = TreeUse.Main) // use HasFlagAny: if use is Main|Dialog, we want to return Main *and* Dialog trees => _treeCollection.Where(x => x.SectionAlias.InvariantEquals(sectionAlias) && x.TreeUse.HasFlagAny(use)).OrderBy(x => x.SortOrder).ToList();
/// <inheritdoc /> public IEnumerable <Tree> GetAll(TreeUse use = TreeUse.Main) // use HasFlagAny: if use is Main|Dialog, we want to return Main *and* Dialog trees => _treeCollection.Where(x => x.TreeUse.HasFlagAny(use));
