public override bool PublishCommentPost(UserInfo u, string msg, PostInfo p)
{
NTree <PostInfo> node = null;
List <PostInfo> result = new List <PostInfo>();
if (msg == "")
{
return(false);
}
tree.traverse(delegate(NTree <PostInfo> curnode)
{
if (curnode.getData() != null && curnode.getData().id == p.id)
{
node = curnode;
}
});
if (node == null)
{
return(false);
}
;
node.addChild(new PostInfo {
id = Int2Guid(postnum++), msg = msg, owner = memb
});
return(true);
}
internal static NTree <int> Execute <TEdge>(Graph <TEdge> graph, int startingNode)
where TEdge : IEdge
{
var root = new NTree <int>(startingNode);
var marked = new bool[graph.CountOfNodes];
marked[startingNode] = true;
var queue = new Queue <NTree <int> >(graph.CountOfNodes);
queue.Enqueue(root);
while (queue.Count > 0)
{
var currentTree = queue.Dequeue();
var notVisitedQuery = graph.GetAdjacentNodes(currentTree.Value)
.Where(w => !marked[w]);
foreach (var childIndex in notVisitedQuery)
{
marked[childIndex] = true;
var child = new NTree <int>(childIndex);
currentTree.ChildsList.Add(child);
queue.Enqueue(child);
}
}
return(root);
}
public void NTreeDeletesByIndexIndividualUnique()
{
var objs = TestResourceFactory.GetMockClassAObjects(50).ToList();
var seedIndex = new Seed32();
var seedSegment = new Seed64();
objs.ForEach(o => o.Id = seedIndex.Increment());
using (var tree = new NTree<int, MockClassA, long>("Id", true))
{
foreach (var o in objs)
tree.AddOrUpdate(new Tuple<MockClassA, long>(o, seedSegment.Increment()));
Assert.AreEqual(50, tree.Length);
Assert.AreEqual(5, tree.GetFirstByIndex(5));
Assert.AreEqual(5, tree.GetFirstBySegment(5));
Assert.AreEqual(1, tree.GetByIndex(5).Count());
Assert.AreEqual(1, tree.Delete(5).Length);
Assert.AreEqual(50, tree.Length);
Assert.AreEqual(0, tree.GetFirstByIndex(5));
}
}
public void Equals_NTreeDifferentStructure_Returns_False()
{
// Arrange
var values = new[] { 0, 1, 2, 3, 4 };
var otherTree = new NTree <int>(values[0], new List <NTree <int> >
{
new NTree <int>(values[1]),
new NTree <int>(values[2]),
new NTree <int>(values[3]),
new NTree <int>(values[4]),
});
var sut = new NTree <int>(values[0], new List <NTree <int> >
{
new NTree <int>(values[1], new List <NTree <int> >
{
new NTree <int>(values[2]),
}),
new NTree <int>(values[3], new List <NTree <int> >
{
new NTree <int>(values[4]),
}),
});
// Act
var result = sut.Equals(otherTree);
// Assert
Assert.False(result);
}
public void NTreeFetchesByIndexRange()
{
var objs = TestResourceFactory.GetMockClassAObjects(5000).ToList();
var seedIndex = new Seed32();
var seedSegment = new Seed64();
objs.ForEach(o => o.Id = seedIndex.Increment());
var toAdd = objs.Select(o => new Tuple<MockClassA, long>(o, seedSegment.Increment())).ToList();
using (var tree = new NTree<int, MockClassA, long>("Id"))
{
var ids = tree.AddOrUpdateRange(toAdd);
Assert.AreEqual(5000, tree.Length);
Assert.AreEqual(5, tree.GetFirstByIndex(5));
Assert.AreEqual(5, tree.GetFirstBySegment(5));
Assert.AreEqual(1, tree.GetByIndex(5).Count());
tree.AddOrUpdate(new Tuple<MockClassA, long>(TestResourceFactory.CreateRandom().WithId(seedIndex.Increment()), seedSegment.Increment()));
Assert.AreEqual(5001, tree.Length);
long[] loc;
var range = tree.GetByIndexRangeInclusive(51, 250, out loc);
Assert.AreEqual(200, range.Length);
}
}
public void NTreeChecksAllWithLargeCount()
{
using (var tree = new NTree<int, MockClassA, long>("Id", true))
{
var objs = new List<MockClassA>();
var seedIndex = new Seed32();
var seedSegment = new Seed64();
for (var i = 0; i < 5; i++)
{
var additions = TestResourceFactory.GetMockClassAObjects(100000).ToList();
additions.ForEach(o => o.Id = seedIndex.Increment());
tree.AddOrUpdateRange(additions.Select(o => new Tuple<MockClassA, long>(o, seedSegment.Increment())).ToList());
}
Assert.AreEqual(500000, tree.Length);
Assert.AreEqual(5, tree.GetFirstByIndex(5));
Assert.AreEqual(5, tree.GetFirstBySegment(5));
Assert.AreEqual(1, tree.GetByIndex(5).Count());
tree.AddOrUpdate(new Tuple<MockClassA, long>(TestResourceFactory.CreateRandom().WithId(seedIndex.Increment()), seedSegment.Increment()));
Assert.AreEqual(500001, tree.Length);
tree.AddOrUpdateRange(
tree.AsEnumerable().First().Take(100)
.Select(s => new NTreeItem<int, long>(s.Item2.Index, s.Item2.Segment))
.ToList());
Assert.AreEqual(500001, tree.Length);
}
}
public void ByLevel_ThreeLevels_ThreeChildsPerLevels()
{
// Arrange
var values = Enumerable.Range(0, 13).ToArray();
var sut = new NTree <int>(values[0], new List <NTree <int> >
{
new NTree <int>(values[1], new List <NTree <int> >
{
new NTree <int>(values[4]),
new NTree <int>(values[5]),
new NTree <int>(values[6]),
}),
new NTree <int>(values[2], new List <NTree <int> >
{
new NTree <int>(values[7]),
new NTree <int>(values[8]),
new NTree <int>(values[9]),
}),
new NTree <int>(values[3], new List <NTree <int> >
{
new NTree <int>(values[10]),
new NTree <int>(values[11]),
new NTree <int>(values[12]),
}),
});
// Act
var result = sut.ByLevel;
// Assert
Assert.True(result.SequenceEqual(values));
}
public void ByLevel_UnEvenTree()
{
// Arrange
var values = Enumerable.Range(0, 7).ToArray();
var sut = new NTree <int>(values[0], new List <NTree <int> >
{
new NTree <int>(values[1], new List <NTree <int> >
{
new NTree <int>(values[4]),
}),
new NTree <int>(values[2]),
new NTree <int>(values[3], new List <NTree <int> >
{
new NTree <int>(values[5]),
new NTree <int>(values[6]),
}),
});
// Act
var result = sut.ByLevel;
// Assert
Assert.True(result.SequenceEqual(values));
}
private void GetTitle(NTree tree, out string title, out string subText, out string activateText)
{
var type = tree.Type;
switch (type)
{
case TreeType.Skill:
title = "SKILLS";
subText = "SP: " + RPG.PlayerData.SkillExp.ToString("N0");
activateText = "unlock skill / customise skill";
break;
case TreeType.Weapon:
title = "WEAPONS";
subText = "SP: " + RPG.PlayerData.SkillExp.ToString("N0");
activateText = "unlock weapon / customise weapon";
break;
case TreeType.SkillMod:
var s = RPG.PlayerData.GetSkill(tree.TreeRef);
title = s.Name;
subText = "SP: " + RPG.PlayerData.SkillExp.ToString("N0");
activateText = "unlock skill mod";
break;
default:
throw new ArgumentOutOfRangeException(type.ToString());
}
}
private NTree <ItemDto> SearchFoldersInternal(int portalId, string searchText, int sortOrder, string permission)
{
var tree = new NTree <ItemDto> {
Data = new ItemDto {
Key = RootKey
}
};
if (portalId > -1)
{
if (!IsPortalIdValid(portalId))
{
return(tree);
}
}
else
{
portalId = GetActivePortalId();
}
var allFolders = GetPortalFolders(portalId, searchText, permission);
var folders = allFolders.Select(f => new ItemDto
{
Key = f.FolderID.ToString(CultureInfo.InvariantCulture),
Value = f.FolderName,
HasChildren = false,
Selectable = true
});
tree.Children = ApplySort(folders, sortOrder).Select(dto => new NTree <ItemDto> {
Data = dto
}).ToList();
return(tree);
}
private NTree <ItemDto> GetTreePathForPageInternal(string itemId, int sortOrder, bool includePortalTree = false, bool includeDisabled = false, bool includeAllTypes = false)
{
var tree = new NTree <ItemDto> {
Data = new ItemDto {
Key = RootKey
}
};
int itemIdAsInt;
if (string.IsNullOrEmpty(itemId) || !int.TryParse(itemId, out itemIdAsInt))
{
return(tree);
}
var portals = PortalController.GetPortalDictionary();
int portalId;
if (portals.ContainsKey(itemIdAsInt))
{
portalId = portals[itemIdAsInt];
}
else
{
return(tree);
}
return(GetTreePathForPageInternal(portalId, itemIdAsInt, sortOrder, includePortalTree, includeDisabled, includeAllTypes));
}
public void Traverse(NTree <T> node, TreeVisitor <T> visitor, string t, ref NTree <T> r)
{
visitor(node.data, node, t, ref r);
foreach (NTree <T> kid in node.children)
{
Traverse(kid, visitor, t, ref r);
}
}
public NTree <T> AddChild(T data)
{
var newNode = new NTree <T>(data);
_children.AddFirst(newNode);
return(newNode);
}
public void Traverse(NTree <T> node, TreeVisitor <T> visitor)
{
visitor(node.data);
foreach (NTree <T> kid in node.children)
{
Traverse(kid, visitor);
}
}
public void Traverse(NTree <T> node, TreeVisitor <T> visitor)
{
visitor(node.Data);
foreach (NTree <T> child in node._children)
{
Traverse(child, visitor);
}
}
private bool AddToFrontier(NTree<PuzzleNode> nodeState)
{
if (!ClosedList.Contains(nodeState) || !Frontier.Contains(nodeState))
{
Frontier.Enqueue(nodeState);
return true;
}
return false;
}
public void AddChild(T data)
{
var node = new NTree <T>(data)
{
Parent = this
};
children.AddFirst(node);
}
private NTree <string> MoveToChild(NTree <string> currentNode, string child)
{
if (currentNode.HasChild(child))
{
return(currentNode.GetChild(child));
}
return(currentNode.AddChild(child));
}
public void PlayWithTree()
{
NTree <int> tree = new NTree <int>();
// Initialize tree
// If the tree has 47 nodes, WreakHavoc will be called 47 times,
// once for each node in the tree.
tree.traverse(WreakHavoc);
}
public void NTree_Object_Default()
{
// Act
var sut = new NTree <object>();
// Assert
Assert.Equal(sut.Value, null);
Assert.Equal(sut.ChildsList.Count, 0);
Assert.False(sut.ChildsEnumerable.Any());
}
public void NTree_Object(object value)
{
// Act
var sut = new NTree <object>(value);
// Assert
Assert.Equal(sut.Value, value);
Assert.Equal(sut.ChildsList.Count, 0);
Assert.False(sut.ChildsEnumerable.Any());
}
public static XElement TreeAsXml <T>(this NTree <T> node)
{
XElement element = new XElement("Node",
new XAttribute("value", node.data));
foreach (var child in node.children)
{
element.Add(TreeAsXml(child));
}
return(element);
}
private NTree <ItemDto> SortFoldersInternal(int portalId, NTree <ItemIdDto> openedNodesTree, int sortOrder, string permissions)
{
var sortedTree = new NTree <ItemDto> {
Data = new ItemDto {
Key = RootKey
}
};
SortFoldersRecursevely(portalId, sortedTree, openedNodesTree, sortOrder, permissions);
return(sortedTree);
}
public void Equals_ObjectNull_Returns_False()
{
// Arrange
object otherTree = null;
var sut = new NTree <int>();
// Act
var result = sut.Equals(otherTree);
// Assert
Assert.False(result);
}
NTree <int> BuildTree()
{
var tree = new NTree <int>(0);
tree.Add(1).Add(2).Add(3);
tree.Children[0].Add(4).Add(5);
tree.Children[0].Children[0].Add(6);
tree.Children[1].Add(7);
tree.Children[2].Add(8);
tree.Children[2].Children[0].Add(9);
return(tree);
}
public override List <Puzzle> search(Puzzle puzzle)
{
NTree <Puzzle> tree = new NTree <Puzzle>(puzzle, repoPuzzle.construireTree(puzzle));
var allVisited = new List <Puzzle>();
Queue <Node <Puzzle> > q = new Queue <Node <Puzzle> >();
q.Enqueue(tree.root);
while (q.Count() != 0)
{
Node <Puzzle> temp = q.Peek();
Node <Puzzle> node = null;
int dife = 0;
q.Dequeue();
//
allVisited.Add(temp.Value);
if (repoPuzzle.isGoal(temp.Value))
{
return(allVisited);
}
NTree <Puzzle>[] noduri = repoPuzzle.construireTree(temp.Value);
if (temp.ChildrensCount == 0 && noduri.Count() != 0)
{
if (noduri.Count() != 0)
{
NTree <Puzzle> temporar = new NTree <Puzzle>(temp.Value, noduri);
temp.Childrens = temporar.root.Childrens;
foreach (var el in temporar.root.Childrens)
{
int auxD = repoPuzzle.checkDiferences(el.Value);
auxD = auxD + el.ChildrensCount;
if (auxD > dife)
{
node = el;
dife = auxD;
}
}
if (node != null)
{
q.Enqueue(node);
}
}
}
//
else
{
foreach (var va1 in temp.Childrens)
{
q.Enqueue(va1);
}
}
}
return(null);
}
public void ByLevel_OneLevel()
{
// Arrange
var value = 0;
var sut = new NTree <int>(value);
// Act
var result = sut.ByLevel;
// Assert
Assert.True(result.SequenceEqual(new[] { value }));
}
public void Dfs_GraphWith1Node_ReturnsNTreeWith1Node()
{
// Arrange
var expectedResult = new NTree <int>(0);
var countOfNodes = 1;
var sut = GetGraph(countOfNodes);
// Act
var result = sut.Dfs(0);
// Assert
Assert.True(expectedResult.Equals(result));
}
public static bool CalculateNextNode (int NumSingleSheets, ref NTree<List<int>> Tree, double probability)
{
var savedNode = memory.Find(Tree.GetNode());
var found = savedNode != null;
if (!found)
{
if (!Tree.IsLeaf)
{
var nodeProbability = (1.0 / double.Parse(Tree.GetNode().Count.ToString()));
probability = probability * nodeProbability;
for (var i = Tree.GetNode().Count - 1; i >= 0; i--)
{
var newTree = new NTree<List<int>>(Tree.GenerateNewNode(i));
CalculateNextNode(NumSingleSheets, ref newTree, probability);
var k = 0;
if (Tree.IsSolitary)
{
k = 1;
}
for (var j = 0; j <= 2; j++)
{
foreach (var element in newTree.probabilityNodeToleafPerSinglesSheets[j])
{
Tree.probabilityNodeToleafPerSinglesSheets[j + k].Add(nodeProbability * element);
}
}
}
memory.Add(new MemoriaParaP151(Tree.GetNode(), Tree.probabilityNodeToleafPerSinglesSheets));
}
else
{
Tree.probabilityNodeToleafPerSinglesSheets[0].Add(1.0);
memory.Add(new MemoriaParaP151(Tree.GetNode(), Tree.probabilityNodeToleafPerSinglesSheets));
}
}
else
{
Tree.probabilityNodeToleafPerSinglesSheets = savedNode.probabilityNodeToleafPerSinglesSheets;
}
return found;
}
private static NTree <ItemDto> GetPagesInPortalGroupInternal(int sortOrder)
{
var treeNode = new NTree <ItemDto> {
Data = new ItemDto {
Key = RootKey
}
};
var portals = GetPortalGroup(sortOrder);
treeNode.Children = portals.Select(dto => new NTree <ItemDto> {
Data = dto
}).ToList();
return(treeNode);
}
public TreeMenu GetSkillMenu()
{
var skillTree = new NTree(new Node("Get High", new GTASprite("mpinventory", "mp_specitem_weed"), NodeType.Skill), TreeType.Skill, new Point(50, 120));
skillTree.AddChild(new Node("Blazed Off Glory", new GTASprite("mpcarhud", "ocelot"), NodeType.Skill))
.AddChild(new Node("Reject Nonsense", new GTASprite("mpinventory", "mp_specitem_heroin"), NodeType.Skill))
.AddChild(new Node("Get Hammered", new GTASprite("mpinventory", "survival"), NodeType.Skill));
var toughen = skillTree.AddChild(new Node("Toughen Up", new GTASprite("mpinventory", "drug_trafficking"), NodeType.Skill))
.AddChild(new Node("Reinforcements", new GTASprite("mpinventory", "team_deathmatch"), NodeType.Skill));
toughen.AddChild(new Node("Rampage", new GTASprite("heisthud", "hc_trevor"), NodeType.Skill, TreeDirection.Down));
return(new TreeMenu(skillTree));
}
public void Equals_NTree1LevelSameValue_Returns_True()
{
// Arrange
var value = 5;
var otherTree = new NTree <int>(value);
var sut = new NTree <int>(value);
// Act
var result = sut.Equals(otherTree);
// Assert
Assert.True(result);
}
public void NTree_Object_WhithChilds(object value, string childsValues)
{
// Arrange
var childs = childsValues.Split(' ')
.Select(s => new NTree <object>(s))
.ToList();
// Act
var sut = new NTree <object>(value, childs);
// Assert
Assert.Equal(sut.Value, value);
Assert.Same(sut.ChildsList, childs);
Assert.True(sut.ChildsEnumerable.SequenceEqual(childs));
}
public void Equals_NTree1LevelDifferentValue_Returns_False()
{
// Arrange
var value1 = 5;
var value2 = 50;
var otherTree = new NTree <int>(value1);
var sut = new NTree <int>(value2);
// Act
var result = sut.Equals(otherTree);
// Assert
Assert.False(result);
}
/// <summary>
/// Find the path to the partular node in the tree from the root node in the tree.
/// Returns an array of 'Direction's.
/// </summary>
/// <param name="puzzle"></param>
/// <returns></returns>
public Direction[] PathToNode(NTree<PuzzleNode> puzzle)
{
Direction[] result;
if (puzzle.Parent == null) //If this is the root node, there is no path!
{
result = new Direction[0];
return result;
}
else //Other wise, path to here is the path to parent
// plus parent to here
{
Direction[] pathToParent = PathToNode(puzzle.Parent);
result = new Direction[pathToParent.Length + 1];
for (int i = 0; i < pathToParent.Length; i++)
{
result[i] = pathToParent[i];
}
result[result.Length - 1] = puzzle.Value.PathFromParent;
return result;
}
}
public void NTreePushesEntities()
{
var objs = TestResourceFactory.GetMockClassAObjects(50).ToList();
var seedIndex = new Seed32();
var seedSegment = new Seed64();
objs.ForEach(o => o.Id = seedIndex.Increment());
var toAdd = objs.Select(o => new Tuple<MockClassA, long>(o, seedSegment.Increment())).ToList();
using (var tree = new NTree<int, MockClassA, long>("Id", true))
{
var ids = tree.AddOrUpdateRange(toAdd);
tree.AddOrUpdate(toAdd.First());
Assert.AreEqual(50, tree.Length);
Assert.AreEqual(5L, tree.GetFirstByIndex(5));
Assert.AreEqual(5, tree.GetFirstBySegment(5));
Assert.AreEqual(1, tree.GetByIndex(1).Count());
Assert.AreEqual(5, tree.GetFirstBySegment(5));
}
}
private NTree<ItemDto> SortFoldersInternal(int portalId, NTree<ItemIdDto> openedNodesTree, int sortOrder, string permissions)
{
var sortedTree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } };
SortFoldersRecursevely(portalId, sortedTree, openedNodesTree, sortOrder, permissions);
return sortedTree;
}
private NTree<ItemDto> GetFoldersInternal(int portalId, int sortOrder, string permissions)
{
var tree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } };
var children = ApplySort(GetFolderDescendantsInternal(portalId, -1, sortOrder, string.Empty, permissions), sortOrder).Select(dto => new NTree<ItemDto> { Data = dto }).ToList();
tree.Children = children;
foreach (var child in tree.Children)
{
children = ApplySort(GetFolderDescendantsInternal(portalId, child.Data.Key, sortOrder, string.Empty, permissions), sortOrder).Select(dto => new NTree<ItemDto> { Data = dto }).ToList();
child.Children = children;
}
return tree;
}
private NTree<ItemDto> GetTreePathForPageInternal(int portalId, int selectedItemId, int sortOrder, bool includePortalTree = false)
{
var tree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } };
if (selectedItemId <= 0)
{
return tree;
}
var pages = GetPortalPages(portalId);
if (pages == null)
{
return tree;
}
var page = pages.SingleOrDefault(pageInfo => pageInfo.TabID == selectedItemId);
if (page == null)
{
return tree;
}
var selfTree = new NTree<ItemDto> { Data = new ItemDto
{
Key = page.TabID.ToString(CultureInfo.InvariantCulture),
Value = page.LocalizedTabName,
HasChildren = page.HasChildren,
Selectable = true
} };
var parentId = page.ParentId;
var parentTab = parentId > 0 ? pages.SingleOrDefault(t => t.TabID == parentId) : null;
while (parentTab != null)
{
// load all sibiling
var siblingTabs = GetChildrenOf(pages, parentId);
siblingTabs = ApplySort(siblingTabs, sortOrder);
var siblingTabsTree = siblingTabs.Select(t => new NTree<ItemDto> { Data = t }).ToList();
// attach the tree
if (selfTree.Children != null)
{
foreach (var node in siblingTabsTree)
{
if (node.Data.Key == selfTree.Data.Key)
{
node.Children = selfTree.Children;
break;
}
}
}
selfTree = new NTree<ItemDto>
{
Data = new ItemDto
{
Key = parentId.ToString(CultureInfo.InvariantCulture),
Value = parentTab.LocalizedTabName,
HasChildren = true,
Selectable = true
},
Children = siblingTabsTree
};
parentId = parentTab.ParentId;
parentTab = parentId > 0 ? pages.SingleOrDefault(t => t.TabID == parentId) : null;
}
// retain root pages
var rootTabs = GetChildrenOf(pages, Null.NullInteger);
rootTabs = ApplySort(rootTabs, sortOrder);
var rootTree = rootTabs.Select(dto => new NTree<ItemDto> { Data = dto }).ToList();
foreach (var node in rootTree)
{
if (node.Data.Key == selfTree.Data.Key)
{
node.Children = selfTree.Children;
break;
}
}
if (includePortalTree)
{
var myGroup = GetMyPortalGroup();
var portalTree = myGroup.Select(
portal => new NTree<ItemDto>
{
Data = new ItemDto
{
Key = PortalPrefix + portal.PortalID.ToString(CultureInfo.InvariantCulture),
Value = portal.PortalName,
HasChildren = true,
Selectable = false
}
}).ToList();
foreach (var node in portalTree)
{
if (node.Data.Key == PortalPrefix + portalId.ToString(CultureInfo.InvariantCulture))
{
node.Children = rootTree;
break;
}
}
rootTree = portalTree;
}
tree.Children = rootTree;
return tree;
}
private NTree<ItemDto> GetTreePathForPageInternal(string itemId, int sortOrder, bool includePortalTree = false)
{
var tree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } };
int itemIdAsInt;
if (string.IsNullOrEmpty(itemId) || !int.TryParse(itemId, out itemIdAsInt))
{
return tree;
}
var portals = PortalController.GetPortalDictionary();
int portalId;
if (portals.ContainsKey(itemIdAsInt))
{
portalId = portals[itemIdAsInt];
}
else
{
return tree;
}
return GetTreePathForPageInternal(portalId, itemIdAsInt, sortOrder, includePortalTree);
}
private static void SortPagesRecursevely(IList<TabInfo> tabs, NTree<ItemDto> treeNode, NTree<ItemIdDto> openedNode, int sortOrder)
{
if (openedNode == null)
{
return;
}
var children = ApplySort(GetChildrenOf(tabs, openedNode.Data.Id), sortOrder).Select(dto => new NTree<ItemDto> { Data = dto }).ToList();
treeNode.Children = children;
if (openedNode.HasChildren())
{
foreach (var openedNodeChild in openedNode.Children)
{
var treeNodeChild = treeNode.Children.Find(child => String.Equals(child.Data.Key, openedNodeChild.Data.Id, StringComparison.InvariantCultureIgnoreCase));
if (treeNodeChild == null)
{
continue;
}
SortPagesRecursevely(tabs, treeNodeChild, openedNodeChild, sortOrder);
}
}
}
private NTree<ItemDto> SortPagesInPortalGroupInternal(NTree<ItemIdDto> openedNode, int sortOrder)
{
var treeNode = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } };
if (openedNode == null)
{
return treeNode;
}
var portals = GetPortalGroup(sortOrder);
treeNode.Children = portals.Select(dto => new NTree<ItemDto> { Data = dto }).ToList();
if (openedNode.HasChildren())
{
foreach (var openedNodeChild in openedNode.Children)
{
var portalIdString = openedNodeChild.Data.Id;
var treeNodeChild = treeNode.Children.Find(child => String.Equals(child.Data.Key, portalIdString, StringComparison.InvariantCultureIgnoreCase));
if (treeNodeChild == null)
{
continue;
}
int portalId;
if (!int.TryParse(portalIdString.Replace(PortalPrefix, string.Empty), out portalId))
{
portalId = -1;
}
var treeOfPages = SortPagesInternal(portalId, openedNodeChild, sortOrder);
treeNodeChild.Children = treeOfPages.Children;
}
}
return treeNode;
}
private NTree<ItemDto> GetPagesInternal(int portalId, int sortOrder, bool includeDisabled = false, bool includeAllTypes = false)
{
if (portalId == -1)
{
portalId = GetActivePortalId();
}
var tabs = GetPortalPages(portalId, includeDisabled, includeAllTypes);
var sortedTree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } };
if (tabs == null)
{
return sortedTree;
}
var children = ApplySort(GetChildrenOf(tabs, Null.NullInteger), sortOrder).Select(dto => new NTree<ItemDto> { Data = dto }).ToList();
sortedTree.Children = children;
return sortedTree;
}
private NTree<ItemDto> GetTreePathForFolderInternal(string selectedItemId, int sortOrder, string permission)
{
var tree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } };
int itemId;
if (string.IsNullOrEmpty(selectedItemId) || !int.TryParse(selectedItemId, out itemId))
{
return tree;
}
if (itemId <= 0)
{
return tree;
}
var folder = FolderManager.Instance.GetFolder(itemId);
if (folder == null)
{
return tree;
}
var hasPermission = string.IsNullOrEmpty(permission) ?
(HasPermission(folder, "BROWSE") || HasPermission(folder, "READ")) :
HasPermission(folder, permission.ToUpper());
if (!hasPermission) return new NTree<ItemDto>();
var selfTree = new NTree<ItemDto> { Data = new ItemDto
{
Key = folder.FolderID.ToString(CultureInfo.InvariantCulture),
Value = folder.FolderName,
HasChildren = HasChildren(folder, permission),
Selectable = true
} };
var parentId = folder.ParentID;
var parentFolder = parentId > 0 ? FolderManager.Instance.GetFolder(parentId) : null;
while (parentFolder != null)
{
// load all sibling
var siblingFolders = GetFolderDescendants(parentFolder, string.Empty, permission)
.Select(folderInfo => new ItemDto
{
Key = folderInfo.FolderID.ToString(CultureInfo.InvariantCulture),
Value = folderInfo.FolderName,
HasChildren = HasChildren(folderInfo, permission),
Selectable = true
}).ToList();
siblingFolders = ApplySort(siblingFolders, sortOrder).ToList();
var siblingFoldersTree = siblingFolders.Select(f => new NTree<ItemDto> { Data = f }).ToList();
// attach the tree
if (selfTree.Children != null)
{
foreach (var node in siblingFoldersTree)
{
if (node.Data.Key == selfTree.Data.Key)
{
node.Children = selfTree.Children;
break;
}
}
}
selfTree = new NTree<ItemDto> { Data = new ItemDto
{
Key = parentId.ToString(CultureInfo.InvariantCulture),
Value = parentFolder.FolderName,
HasChildren = true,
Selectable = true
}, Children = siblingFoldersTree
};
parentId = parentFolder.ParentID;
parentFolder = parentId > 0 ? FolderManager.Instance.GetFolder(parentId) : null;
}
selfTree.Data.Value = SharedConstants.RootFolder;
tree.Children.Add(selfTree);
return tree;
}
public abstract Direction[] Solve(NTree<PuzzleNode> aPuzzle);
private static NTree<ItemDto> GetPagesInPortalGroupInternal(int sortOrder)
{
var treeNode = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } };
var portals = GetPortalGroup(sortOrder);
treeNode.Children = portals.Select(dto => new NTree<ItemDto> { Data = dto }).ToList();
return treeNode;
}
private NTree<ItemDto> GetPagesInternal(int portalId, int sortOrder)
{
var tabs = GetPortalPages(portalId);
var sortedTree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } };
if (tabs == null)
{
return sortedTree;
}
var children = ApplySort(GetChildrenOf(tabs, Null.NullInteger), sortOrder).Select(dto => new NTree<ItemDto> { Data = dto }).ToList();
sortedTree.Children = children;
return sortedTree;
}
private NTree<ItemDto> SortPagesInternal(int portalId, NTree<ItemIdDto> openedNodesTree, int sortOrder, bool includeDisabled = false, bool includeAllTypes = false)
{
var pages = GetPortalPages(portalId, includeDisabled, includeAllTypes);
var sortedTree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } };
if (pages == null)
{
return sortedTree;
}
SortPagesRecursevely(pages, sortedTree, openedNodesTree, sortOrder);
return sortedTree;
}
private void SortFoldersRecursevely(int portalId, NTree<ItemDto> treeNode, NTree<ItemIdDto> openedNode, int sortOrder, string permissions)
{
if (openedNode == null)
{
return;
}
var children = ApplySort(GetFolderDescendantsInternal(portalId, openedNode.Data.Id, sortOrder, string.Empty, permissions), sortOrder).Select(dto => new NTree<ItemDto> { Data = dto }).ToList();
treeNode.Children = children;
if (openedNode.HasChildren())
{
foreach (var openedNodeChild in openedNode.Children)
{
var treeNodeChild = treeNode.Children.Find(child => String.Equals(child.Data.Key, openedNodeChild.Data.Id, StringComparison.InvariantCultureIgnoreCase));
if (treeNodeChild == null)
{
continue;
}
SortFoldersRecursevely(portalId, treeNodeChild, openedNodeChild, sortOrder, permissions);
}
}
}
private NTree<ItemDto> SearchPagesInternal(int portalId, string searchText, int sortOrder, bool includeDisabled = false, bool includeAllTypes = false, bool includeActive = true, bool includeHostPages = false)
{
var tree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } };
List<TabInfo> tabs;
if (portalId == -1)
{
portalId = GetActivePortalId();
}
else
{
if (!IsPortalIdValid(portalId))
{
return tree;
}
}
Func<TabInfo, bool> searchFunc;
if (String.IsNullOrEmpty(searchText))
{
searchFunc = page => true;
}
else
{
searchFunc = page => page.LocalizedTabName.IndexOf(searchText, StringComparison.InvariantCultureIgnoreCase) > -1;
}
if (portalId > -1)
{
var includeHiddenTabs = PortalSettings.UserInfo.IsSuperUser || PortalSettings.UserInfo.IsInRole("Administrators");
tabs = TabController.Instance.GetTabsByPortal(portalId).Where(tab =>
(includeActive || tab.Value.TabID != PortalSettings.ActiveTab.TabID)
&& (includeHiddenTabs || tab.Value.IsVisible)
&& (includeDisabled || !tab.Value.DisableLink)
&& (includeAllTypes || tab.Value.TabType == TabType.Normal)
&& searchFunc(tab.Value))
.OrderBy(tab => tab.Value.TabOrder)
.Select(tab => tab.Value)
.ToList();
if (PortalSettings.UserInfo.IsSuperUser && includeHostPages)
{
tabs.AddRange(TabController.Instance.GetTabsByPortal(-1).Where(tab => !tab.Value.DisableLink && searchFunc(tab.Value))
.OrderBy(tab => tab.Value.TabOrder)
.Select(tab => tab.Value)
.ToList());
}
}
else
{
if (PortalSettings.UserInfo.IsSuperUser)
{
tabs = TabController.Instance.GetTabsByPortal(-1).Where(tab => !tab.Value.DisableLink && searchFunc(tab.Value))
.OrderBy(tab => tab.Value.TabOrder)
.Select(tab => tab.Value)
.ToList();
}
else
{
return tree;
}
}
var pages = tabs.Select(tab => new ItemDto
{
Key = tab.TabID.ToString(CultureInfo.InvariantCulture),
Value = tab.LocalizedTabName,
HasChildren = false,
Selectable = true
});
tree.Children = ApplySort(pages, sortOrder).Select(dto => new NTree<ItemDto> { Data = dto }).ToList();
return tree;
}
private NTree<ItemDto> SearchFoldersInternal(int portalId, string searchText, int sortOrder, string permission)
{
var tree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } };
if (portalId > -1)
{
if (!IsPortalIdValid(portalId))
{
return tree;
}
}
else
{
portalId = PortalSettings.PortalId;
}
var allFolders = GetPortalFolders(portalId, searchText, permission);
var folders = allFolders.Select(f => new ItemDto
{
Key = f.FolderID.ToString(CultureInfo.InvariantCulture),
Value = f.FolderName,
HasChildren = false,
Selectable = true
});
tree.Children = ApplySort(folders, sortOrder).Select(dto => new NTree<ItemDto> { Data = dto }).ToList();
return tree;
}
private NTree<ItemDto> SortFilesInternal(int portalId, int parentId, string filter, int sortOrder, string permissions)
{
var sortedTree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } };
var children = GetFileItemsDto(portalId, parentId, filter, string.Empty, permissions, sortOrder).Select(dto => new NTree<ItemDto> { Data = dto }).ToList();
sortedTree.Children = children;
return sortedTree;
}
public void NTreeReturnsEmptyPageWithWrongPageId()
{
var objs = TestResourceFactory.GetMockClassAObjects(50).ToList();
var seedIndex = new Seed32();
var seedSegment = new Seed64();
objs.ForEach(o => o.Id = seedIndex.Increment());
var toAdd = objs.Select(o => new Tuple<MockClassA, long>(o, seedSegment.Increment())).ToList();
using (var tree = new NTree<int, MockClassA, long>("Id", true))
{
var ids = tree.AddOrUpdateRange(toAdd);
tree.AddOrUpdate(toAdd.First());
Assert.AreEqual(50, tree.Length);
var p = tree.GetPage(8);
Assert.AreEqual(0, p.Length);
}
}
private NTree<ItemDto> SearchPagesInPortalGroupInternal(string searchText, int sortOrder)
{
var treeNode = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } };
var portals = GetPortalGroup(sortOrder);
treeNode.Children = portals.Select(dto => new NTree<ItemDto> { Data = dto }).ToList();
foreach (var child in treeNode.Children)
{
int portalId;
if (int.TryParse(child.Data.Key.Replace(PortalPrefix, string.Empty), out portalId))
{
var pageTree = SearchPagesInternal(portalId, searchText, sortOrder);
child.Children = pageTree.Children;
}
}
return treeNode;
}
/// <summary>
/// Starts the arbitrage
/// </summary>
/// <param name="originalAmount"></param>
/// <param name="targetCurrency"></param>
/// <param name="frequencyInSec"></param>
/// <param name="profitThreshold"></param>
/// <param name="realTrading"></param>
/// <param name="allowedPairs"></param>
public void Start(decimal originalAmount, string targetCurrency, int frequencyInSec, decimal profitThreshold, bool realTrading, BtcePair[] allowedPairs)
{
realTrading = false; //!!!DO not use real trading
_allowedPairs = allowedPairs;
_pairsAsString = _allowedPairs.Select(p => BtcePairHelper.ToString(p)).ToArray();
_mustStop = false;
OnReportProgress("Starting Arbitrage - Monitoring opportunities...");
while (!_mustStop)
{
Dictionary<BtcePair, Ticker> tickers;
try
{
tickers = BtceApiV3.GetTicker(_allowedPairs);
}
catch (Exception ex)
{
Logger.Log(ex);
OnReportProgress("Error: " + ex.ToString());
System.Threading.Thread.Sleep(1000 * frequencyInSec);
continue;
}
var pairs = _allowedPairs.Where(p => p.HasCurrency(targetCurrency));
var ac = new MyAction
{
UnitsCurrency1 = 0,
UnitsCurrency2 = originalAmount,
Pair = BtcePair.Unknown
};
NTree<MyAction> tree = new NTree<MyAction>(ac);
foreach (var p in pairs)
{
BuildArbitrageTree(tickers, p, tree, originalAmount, p.Item1() == targetCurrency, targetCurrency);
}
var leaves = new List<NTree<MyAction>>();
tree.Traverse(n =>
{
if (n.Data.IsFinalAction)
{
leaves.Add(n);
}
});
decimal maxProfit = 0;
List<NTree<MyAction>> bestChain = null;
int bestIndex = 0;
for (var lIndex = 0; lIndex < leaves.Count; lIndex++)
{
// System.Diagnostics.Debug.WriteLine("Option " + (lIndex + 1));
var l = leaves[lIndex];
var t = l.GetTree();
for (var nIndex = 1; nIndex < t.Count; nIndex++)
{
var c = t[nIndex].Data;
//System.Diagnostics.Debug.WriteLine(string.Format("Converting {0:0.00###} {1:0.00###} to {2:0.00###} {3:0.00###}", c.UnitsCurrency1, c.Currency1, c.UnitsCurrency2, c.Currency2));
}
decimal profit = l.Data.UnitsCurrency2 - originalAmount;
// System.Diagnostics.Debug.WriteLine("Profit " + profit.ToString("0.00###"));
if (profit > maxProfit)
{
maxProfit = l.Data.UnitsCurrency2 - originalAmount;
bestChain = t;
bestIndex = lIndex;
}
}
if (bestChain != null)
{
//System.Diagnostics.Debug.WriteLine("Best Option: " + (bestIndex + 1));
OnReportProgress("Max profit: " + maxProfit.ToString("0.00###"));
for (var nIndex = 1; nIndex < bestChain.Count; nIndex++)
{
var c = bestChain[nIndex].Data;
OnReportProgress(c.Description);
}
_currentChain = bestChain;
var percentage = maxProfit / originalAmount * 100;
OnReportProgress(string.Format("Percentage {0:0.00}", percentage));
if (percentage > profitThreshold)
{
FollowChain(bestChain, realTrading);
}
}
else
{
System.Diagnostics.Debug.WriteLine("No profit possible");
}
System.Diagnostics.Debug.WriteLine("=======================================================================");
System.Threading.Thread.Sleep(1000 * frequencyInSec);
}
}
private NTree<ItemDto> SearchPagesInPortalGroupInternal(string treeAsJson, string searchText, int sortOrder)
{
var treeNode = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } };
var openedNode = Json.Deserialize<NTree<ItemIdDto>>(treeAsJson);
if (openedNode == null)
{
return treeNode;
}
var portals = GetPortalGroup(sortOrder);
treeNode.Children = portals.Select(dto => new NTree<ItemDto> { Data = dto }).ToList();
if (!openedNode.HasChildren())
{
return treeNode;
}
foreach (var openedNodeChild in openedNode.Children)
{
var portalIdString = openedNodeChild.Data.Id;
var treeNodeChild = treeNode.Children.Find(child => String.Equals(child.Data.Key, portalIdString, StringComparison.InvariantCultureIgnoreCase));
if (treeNodeChild == null)
{
continue;
}
int portalId;
if (int.TryParse(treeNodeChild.Data.Key.Replace(PortalPrefix, string.Empty), out portalId))
{
var pageTree = SearchPagesInternal(portalId, searchText, sortOrder);
treeNodeChild.Children = pageTree.Children;
}
}
return treeNode;
}
private NTree<ItemDto> SearchPagesInternal(int portalId, string searchText, int sortOrder)
{
var tree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } };
List<TabInfo> tabs;
if (portalId == -1)
{
portalId = GetActivePortalId();
}
else
{
if (!IsPortalIdValid(portalId))
{
return tree;
}
}
Func<TabInfo, bool> searchFunc;
if (String.IsNullOrEmpty(searchText))
{
searchFunc = page => true;
}
else
{
searchFunc = page => page.LocalizedTabName.IndexOf(searchText, StringComparison.InvariantCultureIgnoreCase) > -1;
}
var tabController = new TabController();
var allTabs = tabController.GetAllTabs().ToArray().Select(tab => (TabInfo)tab).ToList();
if (portalId > -1)
{
var includeHiddenTabs = PortalSettings.UserInfo.IsSuperUser || PortalSettings.UserInfo.IsInRole("Administrators");
if (!includeHiddenTabs) allTabs = allTabs.Where(t => t.IsVisible).ToList();
tabs = allTabs.Where(tab => tab.PortalID == portalId && !tab.DisableLink && searchFunc(tab))
.OrderBy(tab => tab.TabOrder)
.ToList();
}
else
{
if (PortalSettings.UserInfo.IsSuperUser)
{
tabs = allTabs.Where(tab => tab.PortalID == -1 && !tab.DisableLink && searchFunc(tab))
.OrderBy(tab => tab.TabOrder)
.ToList();
}
else
{
return tree;
}
}
var pages = tabs.Select(tab => new ItemDto
{
Key = tab.TabID.ToString(CultureInfo.InvariantCulture),
Value = tab.LocalizedTabName,
HasChildren = false,
Selectable = true
});
tree.Children = ApplySort(pages, sortOrder).Select(dto => new NTree<ItemDto> { Data = dto }).ToList();
return tree;
}
/// <summary>
///
/// </summary>
/// <param name="graph"></param>
/// <param name="k">number of intervals</param>
/// <returns></returns>
public IEnumerable<int> ExonChaining(NTree<string> graph, int k)
{
return null;
}
private NTree<ItemDto> SortPagesInternal(int portalId, NTree<ItemIdDto> openedNodesTree, int sortOrder)
{
var pages = GetPortalPages(portalId);
var sortedTree = new NTree<ItemDto> { Data = new ItemDto { Key = RootKey } };
if (pages == null)
{
return sortedTree;
}
SortPagesRecursevely(pages, sortedTree, openedNodesTree, sortOrder);
return sortedTree;
}
public void NTreePushesLotsOfDuplicateEntities()
{
var objs = TestResourceFactory.GetMockClassAObjects(20480).ToList();
var seedIndex = new Seed32();
var seedSegment = new Seed64();
objs.ForEach(o => o.Id = seedIndex.Increment());
var toAdd = objs.Select(o => new Tuple<MockClassA, long>(o, seedSegment.Increment())).ToList();
using (var tree = new NTree<int, MockClassA, long>("Id", true))
{
var ids = tree.AddOrUpdateRange(toAdd);
Assert.AreEqual(20480, tree.Length);
Assert.AreEqual(5, tree.GetFirstByIndex(5));
Assert.AreEqual(5, tree.GetFirstBySegment(5));
Assert.AreEqual(1, tree.GetByIndex(5).Count());
tree.AddOrUpdate(new Tuple<MockClassA, long>(TestResourceFactory.CreateRandom().WithId(seedIndex.Increment()), seedSegment.Increment()));
Assert.AreEqual(20481, tree.Length);
tree.AddOrUpdateRange(toAdd.Skip(100).Take(100).ToList());
Assert.AreEqual(20481, tree.Length);
}
}
