def manager(request, nodeid):
graph = ResourceGraph(nodeid)
validations = models.Validation.objects.all()
branches = JSONSerializer().serializeToPython(
models.BranchMetadata.objects.all())
branch_nodes = models.Node.objects.filter(~Q(branchmetadata=None),
istopnode=True)
for branch in branches:
rootnode = branch_nodes.get(
branchmetadata_id=branch['branchmetadataid'])
branch['graph'] = ResourceGraph(rootnode)
datatypes = models.DDataType.objects.all()
return render(
request, 'graph-manager.htm', {
'main_script': 'graph-manager',
'graph': JSONSerializer().serialize(graph),
'validations': JSONSerializer().serialize(validations),
'branches': JSONSerializer().serialize(branches),
'datatypes': JSONSerializer().serialize(datatypes),
'node_list': {
'title': _('Node List'),
'search_placeholder': _('Find a node in the graph')
},
'permissions_list': {
'title': _('Permissions'),
'search_placeholder': _('Find a group or user account')
},
'branch_list': {
'title': _('Branch Library'),
'search_placeholder': _('Find a graph branch')
}
})
def test_copy_graph(self):
"""
test that a copy of a graph has the same number of nodes and edges and that the primary keys have been changed
and that the actual node references are different
"""
graph = ResourceGraph(self.HERITAGE_RESOURCE_FIXTURE)
graph_copy = graph.copy()
self.assertEqual(len(graph.nodes), len(graph_copy.nodes))
self.assertEqual(len(graph.edges), len(graph_copy.edges))
self.assertEqual(len(graph.nodegroups), len(graph_copy.nodegroups))
def findNodeByName(graph, name):
for key, node in graph.nodes.iteritems():
if node.name == name:
return node
return None
for key, node in graph.nodes.iteritems():
node_copy = findNodeByName(graph_copy, node.name)
self.assertIsNotNone(node_copy)
self.assertNotEqual(node.pk, node_copy.pk)
self.assertNotEqual(id(node), id(node_copy))
if node.nodegroup != None:
self.assertNotEqual(node.nodegroup, node_copy.nodegroup)
for key, newedge in graph_copy.edges.iteritems():
self.assertIsNotNone(graph_copy.nodes[newedge.domainnode_id])
self.assertIsNotNone(graph_copy.nodes[newedge.rangenode_id])
self.assertEqual(newedge.domainnode, graph_copy.nodes[newedge.domainnode.pk])
self.assertEqual(newedge.rangenode, graph_copy.nodes[newedge.rangenode.pk])
with self.assertRaises(KeyError):
graph.edges[newedge.pk]
def append_branch(request, nodeid, property, branchmetadataid):
if request.method == 'POST':
graph = ResourceGraph(nodeid)
newBranch = graph.append_branch(property, branchmetadataid=branchmetadataid)
graph.save()
return JSONResponse(newBranch)
return HttpResponseNotFound()
def load_resource_graph_file(path_to_file):
if isfile(path_to_file) and path_to_file.endswith(suffix):
basepath = path_to_file
name = basepath.split(os.sep)[-1]
with open(basepath, 'rU') as f:
file = json.load(f)
resource_graph = ResourceGraph(file['graph'][0])
resource_graph.save()
def load_resource_graph_file(path_to_file):
if isfile(path_to_file) and path_to_file.endswith(suffix):
basepath = path_to_file
name = basepath.split(os.sep)[-1]
with open(basepath, 'rU') as f:
file = json.load(f)
resource_graph = ResourceGraph(file['graph'][0])
resource_graph.save()
def append_branch(request, nodeid, property, branchmetadataid):
if request.method == 'POST':
graph = ResourceGraph(nodeid)
newBranch = graph.append_branch(property,
branchmetadataid=branchmetadataid)
graph.save()
return JSONResponse(newBranch)
return HttpResponseNotFound()
def test_nodes_are_byref(self):
"""
test that the nodes referred to in the ResourceGraph.edges are exact references to
the nodes as opposed to a node with the same attribute values
"""
graph = ResourceGraph(self.HERITAGE_RESOURCE_FIXTURE)
node_mapping = {
nodeid: id(node)
for nodeid, node in graph.nodes.iteritems()
}
for key, edge in graph.edges.iteritems():
self.assertEqual(node_mapping[edge.domainnode.pk],
id(edge.domainnode))
self.assertEqual(node_mapping[edge.rangenode.pk],
id(edge.rangenode))
for key, node in graph.nodes.iteritems():
for key, edge in graph.edges.iteritems():
newid = uuid.uuid4()
if (edge.domainnode.pk == node.pk):
node.pk = newid
self.assertEqual(edge.domainnode.pk, newid)
elif (edge.rangenode.pk == node.pk):
node.pk = newid
self.assertEqual(edge.rangenode.pk, newid)
def test_branch_append(self):
"""
test if a branch is properly appended to a graph
"""
nodes_count_before = models.Node.objects.count()
edges_count_before = models.Edge.objects.count()
nodegroups_count_before = models.NodeGroup.objects.count()
graph = ResourceGraph(self.rootNode)
graph.append_branch(
'P1', branchmetadataid=self.NODE_NODETYPE_BRANCHMETADATAID)
graph.save()
self.assertEqual(len(graph.nodes), 3)
self.assertEqual(len(graph.edges), 2)
self.assertEqual(len(graph.nodegroups), 2)
self.assertEqual(models.Node.objects.count() - nodes_count_before, 2)
self.assertEqual(models.Edge.objects.count() - edges_count_before, 2)
self.assertEqual(
models.NodeGroup.objects.count() - nodegroups_count_before, 1)
for key, edge in graph.edges.iteritems():
self.assertIsNotNone(graph.nodes[edge.domainnode_id])
self.assertIsNotNone(graph.nodes[edge.rangenode_id])
self.assertEqual(edge.domainnode, graph.nodes[edge.domainnode.pk])
self.assertEqual(edge.rangenode, graph.nodes[edge.rangenode.pk])
for key, node in graph.nodes.iteritems():
if node.istopnode:
self.assertEqual(node, self.rootNode)
appended_branch = graph.append_branch(
'P1', branchmetadataid=self.SINGLE_NODE_BRANCHMETADATAID)
graph.save()
self.assertEqual(len(graph.nodes), 4)
self.assertEqual(len(graph.edges), 3)
self.assertEqual(len(graph.nodegroups), 2)
self.assertEqual(models.Node.objects.count() - nodes_count_before, 3)
self.assertEqual(models.Edge.objects.count() - edges_count_before, 3)
self.assertEqual(
models.NodeGroup.objects.count() - nodegroups_count_before, 1)
self.assertEqual(appended_branch.root.nodegroup,
self.rootNode.nodegroup)
def test_graph_doesnt_polute_db(self):
"""
test that the mere act of creating a ResourceGraph instance
doesn't save anything to the database
"""
graph_obj = {
'nodes': [{
"status": None,
"branchmetadataid": None,
"description": "",
"name": "ROOT_NODE",
"istopnode": True,
"ontologyclass": "",
"nodeid": "55555555-343e-4af3-8857-f7322dc9eb4b",
"nodegroupid": "55555555-343e-4af3-8857-f7322dc9eb4b",
"datatype": "semantic",
"cardinality": "1"
}, {
"status": None,
"branchmetadataid": None,
"description": "",
"name": "NODE_NAME",
"istopnode": False,
"ontologyclass": "",
"nodeid": "66666666-24c9-4226-bde2-2c40ee60a26c",
"nodegroupid": "55555555-343e-4af3-8857-f7322dc9eb4b",
"datatype": "string",
"cardinality": "n"
}],
'edges': [{
"branchmetadataid": None,
"rangenodeid": "66666666-24c9-4226-bde2-2c40ee60a26c",
"name": "",
"edgeid": "11111111-d50f-11e5-8754-80e6500ee4e4",
"domainnodeid": "55555555-343e-4af3-8857-f7322dc9eb4b",
"ontologyproperty": "P2",
"description": ""
}]
}
nodes_count_before = models.Node.objects.count()
edges_count_before = models.Edge.objects.count()
nodegroups_count_before = models.NodeGroup.objects.count()
graph = ResourceGraph(graph_obj)
self.assertEqual(models.Node.objects.count() - nodes_count_before, 0)
self.assertEqual(models.Edge.objects.count() - edges_count_before, 0)
self.assertEqual(
models.NodeGroup.objects.count() - nodegroups_count_before, 0)
def test_copy_graph(self):
"""
test that a copy of a graph has the same number of nodes and edges and that the primary keys have been changed
and that the actual node references are different
"""
graph = ResourceGraph(self.HERITAGE_RESOURCE_FIXTURE)
graph_copy = graph.copy()
self.assertEqual(len(graph.nodes), len(graph_copy.nodes))
self.assertEqual(len(graph.edges), len(graph_copy.edges))
self.assertEqual(len(graph.nodegroups), len(graph_copy.nodegroups))
def findNodeByName(graph, name):
for key, node in graph.nodes.iteritems():
if node.name == name:
return node
return None
for key, node in graph.nodes.iteritems():
node_copy = findNodeByName(graph_copy, node.name)
self.assertIsNotNone(node_copy)
self.assertNotEqual(node.pk, node_copy.pk)
self.assertNotEqual(id(node), id(node_copy))
if node.nodegroup != None:
self.assertNotEqual(node.nodegroup, node_copy.nodegroup)
for key, newedge in graph_copy.edges.iteritems():
self.assertIsNotNone(graph_copy.nodes[newedge.domainnode_id])
self.assertIsNotNone(graph_copy.nodes[newedge.rangenode_id])
self.assertEqual(newedge.domainnode,
graph_copy.nodes[newedge.domainnode.pk])
self.assertEqual(newedge.rangenode,
graph_copy.nodes[newedge.rangenode.pk])
with self.assertRaises(KeyError):
graph.edges[newedge.pk]
def test_branch_append(self):
"""
test if a branch is properly appended to a graph
"""
nodes_count_before = models.Node.objects.count()
edges_count_before = models.Edge.objects.count()
nodegroups_count_before = models.NodeGroup.objects.count()
graph = ResourceGraph(self.rootNode)
graph.append_branch('P1', branchmetadataid=self.NODE_NODETYPE_BRANCHMETADATAID)
graph.save()
self.assertEqual(len(graph.nodes), 3)
self.assertEqual(len(graph.edges), 2)
self.assertEqual(len(graph.nodegroups), 2)
self.assertEqual(models.Node.objects.count()-nodes_count_before, 2)
self.assertEqual(models.Edge.objects.count()-edges_count_before, 2)
self.assertEqual(models.NodeGroup.objects.count()-nodegroups_count_before, 1)
for key, edge in graph.edges.iteritems():
self.assertIsNotNone(graph.nodes[edge.domainnode_id])
self.assertIsNotNone(graph.nodes[edge.rangenode_id])
self.assertEqual(edge.domainnode, graph.nodes[edge.domainnode.pk])
self.assertEqual(edge.rangenode, graph.nodes[edge.rangenode.pk])
for key, node in graph.nodes.iteritems():
if node.istopnode:
self.assertEqual(node, self.rootNode)
appended_branch = graph.append_branch('P1', branchmetadataid=self.SINGLE_NODE_BRANCHMETADATAID)
graph.save()
self.assertEqual(len(graph.nodes), 4)
self.assertEqual(len(graph.edges), 3)
self.assertEqual(len(graph.nodegroups), 2)
self.assertEqual(models.Node.objects.count()-nodes_count_before, 3)
self.assertEqual(models.Edge.objects.count()-edges_count_before, 3)
self.assertEqual(models.NodeGroup.objects.count()-nodegroups_count_before, 1)
self.assertEqual(appended_branch.root.nodegroup,self.rootNode.nodegroup)
def test_make_tree(self):
graph = ResourceGraph(self.HERITAGE_RESOURCE_FIXTURE)