def post(self, request, graphid):
graph = Graph.objects.get(graphid=graphid)
data = JSONDeserializer().deserialize(request.body)
for key, value in data.get('graph').iteritems():
if key in [
'iconclass', 'name', 'author', 'description', 'isresource',
'ontology_id', 'version', 'subtitle', 'isactive', 'color',
'jsonldcontext'
]:
setattr(graph, key, value)
node = models.Node.objects.get(graph_id=graphid, istopnode=True)
node.set_relatable_resources(data.get('relatable_resource_ids'))
node.ontologyclass = data.get('ontology_class') if data.get(
'graph').get('ontology_id') is not None else None
node.name = graph.name
with transaction.atomic():
graph.save()
node.save()
return JSONResponse({
'success':
True,
'graph':
graph,
'relatable_resource_ids':
[res.nodeid for res in node.get_relatable_resources()]
})
def post(self, request, graphid):
graph = Graph.objects.get(graphid=graphid)
data = JSONDeserializer().deserialize(request.body)
for key, value in data.get('graph').iteritems():
if key in ['iconclass', 'name', 'author', 'description', 'isresource',
'ontology_id', 'version', 'subtitle', 'isactive', 'color',
'jsonldcontext', 'config', 'template_id']:
setattr(graph, key, value)
node = models.Node.objects.get(graph_id=graphid, istopnode=True)
node.set_relatable_resources(data.get('relatable_resource_ids'))
try:
node.datatype = data['graph']['root']['datatype']
except KeyError as e:
print e, 'Cannot find root node datatype'
node.ontologyclass = data.get('ontology_class') if data.get('graph').get('ontology_id') is not None else None
node.name = graph.name
graph.root.name = node.name
try:
with transaction.atomic():
graph.save()
node.save()
return JSONResponse({
'success': True,
'graph': graph,
'relatable_resource_ids': [res.nodeid for res in node.get_relatable_resources()]
})
except GraphValidationError as e:
return JSONResponse({'status': 'false', 'message': e.message, 'title': e.title}, status=500)
def related_resources(request, resourceid):
## get allowed resource types based on permissions
allowedtypes = get_allowed_types(request)
is_anon = False
if request.user.username == "anonymous":
is_anon = True
if request.method == 'GET':
lang = request.GET.get('lang', settings.LANGUAGE_CODE)
start = request.GET.get('start', 0)
resources = get_related_resources(resourceid, lang, start=start, limit=15, allowedtypes=allowedtypes, is_anon=is_anon)
return JSONResponse(resources, indent=4)
if 'edit' in request.user.user_groups and request.method == 'DELETE':
se = SearchEngineFactory().create()
data = JSONDeserializer().deserialize(request.body)
entityid1 = data.get('entityid1')
entityid2 = data.get('entityid2')
resourcexid = data.get('resourcexid')
realtionshiptype = data.get('realtionshiptype')
resource = Resource(entityid1)
resource.delete_resource_relationship(entityid2, realtionshiptype)
se.delete(index='resource_relations', doc_type='all', id=resourcexid)
return JSONResponse({ 'success': True })
def post(self, request, graphid):
graph = Graph.objects.get(graphid=graphid)
data = JSONDeserializer().deserialize(request.body)
for key, value in data.get("graph").items():
if key in [
"iconclass",
"name",
"author",
"description",
"isresource",
"ontology_id",
"version",
"subtitle",
"isactive",
"color",
"jsonldcontext",
"config",
"template_id",
]:
setattr(graph, key, value)
node = models.Node.objects.get(graph_id=graphid, istopnode=True)
node.set_relatable_resources(data.get("relatable_resource_ids"))
try:
node.datatype = data["graph"]["root"]["datatype"]
except KeyError as e:
print(e, "Cannot find root node datatype")
node.ontologyclass = data.get("ontology_class") if data.get(
"graph").get("ontology_id") is not None else None
node.name = graph.name
graph.root.name = node.name
try:
with transaction.atomic():
graph.save()
node.save()
return JSONResponse({
"success":
True,
"graph":
graph,
"relatable_resource_ids":
[res.nodeid for res in node.get_relatable_resources()]
})
except GraphValidationError as e:
return JSONResponse(
{
"status": "false",
"message": e.message,
"title": e.title
},
status=500)
def delete(self, request, graphid):
if self.action == 'delete_node':
data = JSONDeserializer().deserialize(request.body)
try:
graph = Graph.objects.get(graphid=graphid)
graph.delete_node(node=data.get('nodeid', None))
return JSONResponse({})
except GraphValidationError as e:
return JSONResponse({'status': 'false', 'message': e.message, 'title': e.title}, status=500)
elif self.action == 'delete_instances':
try:
graph = Graph.objects.get(graphid=graphid)
graph.delete_instances()
return JSONResponse({
'success': True,
'message': "All the resources associated with the Model '{0}' have been successfully deleted.".format(graph.name),
'title': "Resources Successfully Deleted."})
except GraphValidationError as e:
return JSONResponse({'status': 'false', 'message': e.message, 'title': e.title}, status=500)
elif self.action == 'delete_graph':
try:
graph = Graph.objects.get(graphid=graphid)
if graph.isresource:
graph.isactive = False
graph.save(validate=False)
graph.delete_instances()
graph.delete()
return JSONResponse({'success': True})
except GraphValidationError as e:
return JSONResponse({'status': 'false', 'message': e.message, 'title': e.title}, status=500)
return HttpResponseNotFound()
def related_resources(request, resourceid):
if request.method == 'GET':
lang = request.GET.get('lang', settings.LANGUAGE_CODE)
start = request.GET.get('start', 0)
return JSONResponse(get_related_resources(resourceid, lang, start=start, limit=15), indent=4)
if 'edit' in request.user.user_groups and request.method == 'DELETE':
se = SearchEngineFactory().create()
data = JSONDeserializer().deserialize(request.body)
entityid1 = data.get('entityid1')
entityid2 = data.get('entityid2')
resourcexid = data.get('resourcexid')
realtionshiptype = data.get('realtionshiptype')
resource = Resource(entityid1)
resource.delete_resource_relationship(entityid2, realtionshiptype)
se.delete(index='resource_relations', doc_type='all', id=resourcexid)
return JSONResponse({ 'success': True })
def delete(self, request, graphid):
data = JSONDeserializer().deserialize(request.body)
if data and self.action == 'delete_node':
graph = Graph.objects.get(graphid=graphid)
graph.delete_node(node=data.get('nodeid', None))
return JSONResponse({})
return HttpResponseNotFound()
def delete_node(request, graphid):
data = JSONDeserializer().deserialize(request.body)
if data:
if request.method == 'DELETE':
graph = Graph.objects.get(graphid=graphid)
graph.delete_node(node=data.get('nodeid', None))
return JSONResponse({})
return HttpResponseNotFound()
def settings(request, graphid):
node = models.Node.objects.get(graph_id=graphid, istopnode=True)
graph = node.graph
if request.method == 'POST':
data = JSONDeserializer().deserialize(request.body)
for key, value in data.get('graph').iteritems():
setattr(graph, key, value)
graph.save()
node.set_relatable_resources(data.get('relatable_resource_ids'))
node.ontologyclass = data.get('ontology_class') if graph.ontology is not None else None
node.save()
return JSONResponse({
'success': True,
'graph': graph,
'relatable_resource_ids': [res.nodeid for res in node.get_relatable_resources()]
})
node_json = JSONSerializer().serialize(node)
icons = models.Icon.objects.order_by('name')
resource_graphs = models.GraphModel.objects.filter(Q(isresource=True), ~Q(graphid=graphid))
resource_data = []
relatable_resources = node.get_relatable_resources()
for res in resource_graphs:
if models.Node.objects.filter(graph=res, istopnode=True).count() > 0:
node = models.Node.objects.get(graph=res, istopnode=True)
resource_data.append({
'id': node.nodeid,
'graph': res,
'is_relatable': (node in relatable_resources)
})
graphs = models.GraphModel.objects.all()
ontologies = models.Ontology.objects.filter(parentontology=None)
ontology_classes = models.OntologyClass.objects.values('source', 'ontology_id')
return render(request, 'views/graph/graph-settings.htm', {
'main_script': 'views/graph/graph-settings',
'icons': JSONSerializer().serialize(icons),
'graph': JSONSerializer().serialize(graph),
'node_json': node_json,
'graphs': JSONSerializer().serialize(graphs),
'ontologies': JSONSerializer().serialize(ontologies),
'ontology_classes': JSONSerializer().serialize(ontology_classes),
'graphid': graphid,
'resource_data': JSONSerializer().serialize(resource_data),
'node_count': models.Node.objects.filter(graph=graph).count()
})
def node(request, nodeid):
if request.method == 'POST':
data = JSONDeserializer().deserialize(request.body)
if data:
node = models.Node.objects.get(nodeid=nodeid)
nodes, edges = node.get_child_nodes_and_edges()
collectors = [node_ for node_ in nodes if node_.is_collector()]
node_ids = [id_node.nodeid for id_node in nodes]
nodes = [node_ for node_ in nodes if (node_.nodegroup_id not in node_ids)]
with transaction.atomic():
node.name = data.get('name', '')
node.description = data.get('description', '')
node.istopnode = data.get('istopnode', '')
node.crmclass = data.get('crmclass', '')
node.datatype = data.get('datatype', '')
node.status = data.get('status', '')
node.validations.set(data.get('validations', []))
new_nodegroup_id = data.get('nodegroup_id', None)
cardinality = data.get('cardinality', 'n')
if node.nodegroup_id != new_nodegroup_id:
edge = models.Edge.objects.get(rangenode_id=nodeid)
parent_group = edge.domainnode.nodegroup
new_group = parent_group
if new_nodegroup_id == nodeid:
new_group, created = models.NodeGroup.objects.get_or_create(nodegroupid=nodeid, defaults={'cardinality': 'n', 'legacygroupid': None, 'parentnodegroup': None})
new_group.parentnodegroup = parent_group
new_group.cardinality = cardinality
new_group.save()
parent_group = new_group
for collector in collectors:
collector.nodegroup.parentnodegroup = parent_group
collector.nodegroup.save()
for group_node in nodes:
group_node.nodegroup = new_group
group_node.save()
node.nodegroup = new_group
node.save()
return JSONResponse({'node': node, 'group_nodes': nodes, 'collectors': collectors, 'nodegroup': node.nodegroup})
if request.method == 'DELETE':
node = models.Node.objects.get(nodeid=nodeid)
nodes, edges = node.get_child_nodes_and_edges()
edges.append(models.Edge.objects.get(rangenode=node))
nodes.append(node)
with transaction.atomic():
[edge.delete() for edge in edges]
[node.delete() for node in nodes]
return JSONResponse({})
return HttpResponseNotFound()
def get_user_from_token(self, token):
decoded_json = jws.verify(token, settings.JWT_KEY, algorithms=[settings.JWT_ALGORITHM])
decoded_dict = JSONDeserializer().deserialize(decoded_json)
username = decoded_dict.get('username', None)
expiration = decoded_dict.get('expiration', None)
user = None
try:
user = User.objects.get(username=username)
if not user.is_active:
raise Exception()
except:
raise AuthenticationFailed(_('User inactive or deleted.\n\n'))
if int(expiration) < int(time.time()):
raise AuthenticationFailed(_('Token Expired.\n\n'))
return user or AnonymousUser()
def delete(self, request, graphid):
data = JSONDeserializer().deserialize(request.body)
if data and self.action == 'delete_node':
try:
graph = Graph.objects.get(graphid=graphid)
graph.delete_node(node=data.get('nodeid', None))
return JSONResponse({})
except GraphValidationError as e:
return JSONResponse({'status': 'false', 'message': e.message, 'title': e.title}, status=500)
return HttpResponseNotFound()
def delete(self, request, graphid):
data = JSONDeserializer().deserialize(request.body)
if data and self.action == 'delete_node':
try:
graph = Graph.objects.get(graphid=graphid)
graph.delete_node(node=data.get('nodeid', None))
return JSONResponse({})
except GraphValidationError as e:
return JSONResponse({'status':'false','message':e.message, 'title':e.title}, status=500)
return HttpResponseNotFound()
def get_user_from_token(self, token):
decoded_json = jws.verify(token, settings.JWT_KEY, algorithms=[settings.JWT_ALGORITHM])
decoded_dict = JSONDeserializer().deserialize(decoded_json)
username = decoded_dict.get('username', None)
expiration = decoded_dict.get('expiration', None)
user = None
try:
user = User.objects.get(username=username)
except:
raise AuthenticationFailed(_('Invalid token.'))
if not user.is_active:
raise AuthenticationFailed(_('User inactive or deleted.'))
if int(expiration) < int(time.time()):
raise AuthenticationFailed(_('Token Expired.'))
return user or AnonymousUser()
def post(self, request, graphid):
graph = Graph.objects.get(graphid=graphid)
data = JSONDeserializer().deserialize(request.body)
for key, value in data.get('graph').iteritems():
if key in ['iconclass', 'name', 'author', 'description', 'isresource',
'ontology_id', 'version', 'subtitle', 'isactive', 'mapfeaturecolor', 'mappointsize', 'maplinewidth']:
setattr(graph, key, value)
node = models.Node.objects.get(graph_id=graphid, istopnode=True)
node.set_relatable_resources(data.get('relatable_resource_ids'))
node.ontologyclass = data.get('ontology_class') if data.get('graph').get('ontology_id') is not None else None
with transaction.atomic():
graph.save()
node.save()
return JSONResponse({
'success': True,
'graph': graph,
'relatable_resource_ids': [res.nodeid for res in node.get_relatable_resources()]
})
def post(self, request, graphid=None):
ret = {}
try:
if self.action == 'import_graph':
graph_file = request.FILES.get('importedGraph').read()
graphs = JSONDeserializer().deserialize(graph_file)['graph']
ret = GraphImporter.import_graph(graphs)
else:
if graphid is not None:
graph = Graph.objects.get(graphid=graphid)
data = JSONDeserializer().deserialize(request.body)
if self.action == 'new_graph':
isresource = data['isresource'] if 'isresource' in data else False
name = _('New Resource Model') if isresource else _('New Branch')
author = request.user.first_name + ' ' + request.user.last_name
ret = Graph.new(name=name,is_resource=isresource,author=author)
elif self.action == 'update_node':
graph.update_node(data)
ret = graph
graph.save()
elif self.action == 'update_node_layer':
nodeid = uuid.UUID(str(data.get('nodeid')))
node = graph.nodes[nodeid]
node.config = data['config']
ret = graph
node.save()
elif self.action == 'append_branch':
ret = graph.append_branch(data['property'], nodeid=data['nodeid'], graphid=data['graphid'])
graph.save()
elif self.action == 'move_node':
ret = graph.move_node(data['nodeid'], data['property'], data['newparentnodeid'])
graph.save()
elif self.action == 'clone_graph':
clone_data = graph.copy()
ret = clone_data['copy']
ret.save()
ret.copy_functions(graph, [clone_data['nodes'], clone_data['nodegroups']])
form_map = ret.copy_forms(graph, clone_data['cards'])
ret.copy_reports(graph, [form_map, clone_data['cards'], clone_data['nodes']])
return JSONResponse(ret)
except GraphValidationError as e:
return JSONResponse({'status':'false','message':e.message, 'title':e.title}, status=500)
def test_get_token(self):
"""
Test to get a JSON Web Token given a valid username and password
"""
response = self.client.post(reverse('get_token'), {
'username': '******',
'password': '******'
})
token = response.content
decoded_json = jws.verify(token,
settings.JWT_KEY,
algorithms=[settings.JWT_ALGORITHM])
decoded_dict = JSONDeserializer().deserialize(decoded_json)
username = decoded_dict.get('username', None)
self.assertTrue(response.status_code == 200)
self.assertTrue(username == 'test')
def delete(self, request, graphid):
if self.action == "delete_node":
data = JSONDeserializer().deserialize(request.body)
try:
graph = Graph.objects.get(graphid=graphid)
graph.delete_node(node=data.get("nodeid", None))
return JSONResponse({})
except GraphValidationError as e:
return JSONErrorResponse(e.title, e.message)
elif self.action == "delete_instances":
try:
graph = Graph.objects.get(graphid=graphid)
graph.delete_instances()
return JSONResponse({
"success":
True,
"message":
"All the resources associated with the Model '{0}' have been successfully deleted."
.format(graph.name),
"title":
"Resources Successfully Deleted.",
})
except GraphValidationError as e:
return JSONErrorResponse(e.title, e.message)
except ModelInactiveError as e:
return JSONErrorResponse(e.title, e.message)
elif self.action == "delete_graph":
try:
graph = Graph.objects.get(graphid=graphid)
if graph.isresource:
graph.delete_instances()
graph.isactive = False
graph.save(validate=False)
graph.delete()
return JSONResponse({"success": True})
except GraphValidationError as e:
return JSONErrorResponse(e.title, e.message)
return HttpResponseNotFound()
def delete(self, request):
data = JSONDeserializer().deserialize(request.body)
manifest_url = data.get("manifest")
manifest = models.IIIFManifest.objects.get(url=manifest_url)
canvases_in_manifest = manifest.manifest["sequences"][0]["canvases"]
canvas_ids = [
canvas["images"][0]["resource"]["service"]["@id"]
for canvas in canvases_in_manifest
]
canvases_in_use = []
for canvas_id in canvas_ids:
if self.check_canvas_in_use(canvas_id):
canvases_in_use.append(canvas_id)
if len(canvases_in_use) > 0:
canvas_labels_in_use = [
item["label"] for item in canvases_in_manifest
if item["images"][0]["resource"]["service"]["@id"] in
canvases_in_use
]
response = "This manifest cannot be deleted because the following canvases have resource annotations: {}".format(
", ".join(canvas_labels_in_use))
return JSONResponse({"message": response}, status=500)
manifest.delete()
return JSONResponse({"success": True})
def post(self, request, graphid=None):
ret = {}
try:
if self.action == "import_graph":
graph_file = request.FILES.get("importedGraph").read()
graphs = JSONDeserializer().deserialize(graph_file)["graph"]
ret = GraphImporter.import_graph(graphs)
else:
if graphid is not None:
graph = Graph.objects.get(graphid=graphid)
data = JSONDeserializer().deserialize(request.body)
if self.action == "new_graph":
isresource = data[
"isresource"] if "isresource" in data else False
name = _("New Resource Model") if isresource else _(
"New Branch")
author = request.user.first_name + " " + request.user.last_name
ret = Graph.new(name=name,
is_resource=isresource,
author=author)
elif self.action == "update_node":
old_node_data = graph.nodes.get(uuid.UUID(data["nodeid"]))
nodegroup_changed = str(
old_node_data.nodegroup_id) != data["nodegroup_id"]
updated_values = graph.update_node(data)
if "nodeid" in data and nodegroup_changed is False:
graph.save(nodeid=data["nodeid"])
else:
graph.save()
ret = JSONSerializer().serializeToPython(graph)
ret["updated_values"] = updated_values
ret["default_card_name"] = graph.temp_node_name
elif self.action == "update_node_layer":
nodeid = uuid.UUID(str(data.get("nodeid")))
node = graph.nodes[nodeid]
node.config = data["config"]
ret = graph
node.save()
elif self.action == "append_branch":
ret = graph.append_branch(data["property"],
nodeid=data["nodeid"],
graphid=data["graphid"])
ret = ret.serialize()
ret["nodegroups"] = graph.get_nodegroups()
ret["cards"] = graph.get_cards()
ret["widgets"] = graph.get_widgets()
graph.save()
elif self.action == "append_node":
ret = graph.append_node(nodeid=data["nodeid"])
graph.save()
elif self.action == "move_node":
ret = graph.move_node(data["nodeid"], data["property"],
data["newparentnodeid"])
graph.save()
elif self.action == "export_branch":
clone_data = graph.copy(root=data)
clone_data["copy"].slug = None
clone_data["copy"].save()
ret = {"success": True, "graphid": clone_data["copy"].pk}
elif self.action == "clone_graph":
clone_data = graph.copy()
ret = clone_data["copy"]
ret.slug = None
ret.save()
ret.copy_functions(
graph, [clone_data["nodes"], clone_data["nodegroups"]])
elif self.action == "reorder_nodes":
json = request.body
if json is not None:
data = JSONDeserializer().deserialize(json)
if "nodes" in data and len(data["nodes"]) > 0:
sortorder = 0
with transaction.atomic():
for node in data["nodes"]:
no = models.Node.objects.get(
pk=node["nodeid"])
no.sortorder = sortorder
no.save()
sortorder = sortorder + 1
ret = data
return JSONResponse(ret)
except GraphValidationError as e:
return JSONErrorResponse(e.title, e.message, {"status": "Failed"})
except ModelInactiveError as e:
return JSONErrorResponse(e.title, e.message)
except RequestError as e:
return JSONErrorResponse(
_("Elasticsearch indexing error"),
_("""If you want to change the datatype of an existing node.
Delete and then re-create the node, or export the branch then edit the datatype and re-import the branch."""
),
)
def post(self, request, graphid=None):
ret = {}
try:
if self.action == 'import_graph':
graph_file = request.FILES.get('importedGraph').read()
graphs = JSONDeserializer().deserialize(graph_file)['graph']
ret = GraphImporter.import_graph(graphs)
else:
if graphid is not None:
graph = Graph.objects.get(graphid=graphid)
data = JSONDeserializer().deserialize(request.body)
if self.action == 'new_graph':
isresource = data[
'isresource'] if 'isresource' in data else False
name = _('New Resource Model') if isresource else _(
'New Branch')
author = request.user.first_name + ' ' + request.user.last_name
ret = Graph.new(name=name,
is_resource=isresource,
author=author)
elif self.action == 'update_node':
graph.update_node(data)
ret = graph
graph.save()
elif self.action == 'update_node_layer':
nodeid = uuid.UUID(str(data.get('nodeid')))
node = graph.nodes[nodeid]
node.config = data['config']
ret = graph
node.save()
elif self.action == 'append_branch':
ret = graph.append_branch(data['property'],
nodeid=data['nodeid'],
graphid=data['graphid'])
graph.save()
elif self.action == 'append_node':
ret = graph.append_node(nodeid=data['nodeid'])
graph.save()
elif self.action == 'move_node':
ret = graph.move_node(data['nodeid'], data['property'],
data['newparentnodeid'])
graph.save()
elif self.action == 'export_branch':
clone_data = graph.copy(root=data)
ret = clone_data['copy']
ret.save()
elif self.action == 'clone_graph':
clone_data = graph.copy()
ret = clone_data['copy']
ret.save()
ret.copy_functions(
graph, [clone_data['nodes'], clone_data['nodegroups']])
form_map = ret.copy_forms(graph, clone_data['cards'])
ret.copy_reports(
graph,
[form_map, clone_data['cards'], clone_data['nodes']])
return JSONResponse(ret)
except GraphValidationError as e:
return JSONResponse(
{
'status': 'false',
'message': e.message,
'title': e.title
},
status=500)
def delete(self, request):
data = JSONDeserializer().deserialize(request.body)
manifest = data.get("manifest")
manifest = models.IIIFManifest.objects.get(url=manifest)
manifest.delete()
return JSONResponse({"success": True})
def post(self, request, graphid=None):
ret = {}
try:
if self.action == 'import_graph':
graph_file = request.FILES.get('importedGraph').read()
graphs = JSONDeserializer().deserialize(graph_file)['graph']
ret = GraphImporter.import_graph(graphs)
else:
if graphid is not None:
graph = Graph.objects.get(graphid=graphid)
data = JSONDeserializer().deserialize(request.body)
if self.action == 'new_graph':
isresource = data[
'isresource'] if 'isresource' in data else False
name = _('New Resource Model') if isresource else _(
'New Branch')
author = request.user.first_name + ' ' + request.user.last_name
ret = Graph.new(name=name,
is_resource=isresource,
author=author)
elif self.action == 'update_node':
updated_values = graph.update_node(data)
graph.save()
ret = JSONSerializer().serializeToPython(graph)
ret['updated_values'] = updated_values
elif self.action == 'update_node_layer':
nodeid = uuid.UUID(str(data.get('nodeid')))
node = graph.nodes[nodeid]
node.config = data['config']
ret = graph
node.save()
elif self.action == 'append_branch':
ret = graph.append_branch(data['property'],
nodeid=data['nodeid'],
graphid=data['graphid'])
ret = ret.serialize()
ret['nodegroups'] = graph.get_nodegroups()
ret['cards'] = graph.get_cards()
ret['widgets'] = graph.get_widgets()
graph.save()
elif self.action == 'append_node':
ret = graph.append_node(nodeid=data['nodeid'])
graph.save()
elif self.action == 'move_node':
ret = graph.move_node(data['nodeid'], data['property'],
data['newparentnodeid'])
graph.save()
elif self.action == 'export_branch':
clone_data = graph.copy(root=data)
clone_data['copy'].save()
ret = {'success': True, 'graphid': clone_data['copy'].pk}
elif self.action == 'clone_graph':
clone_data = graph.copy()
ret = clone_data['copy']
ret.save()
ret.copy_functions(
graph, [clone_data['nodes'], clone_data['nodegroups']])
elif self.action == 'reorder_nodes':
json = request.body
if json is not None:
data = JSONDeserializer().deserialize(json)
if 'nodes' in data and len(data['nodes']) > 0:
sortorder = 0
with transaction.atomic():
for node in data['nodes']:
no = models.Node.objects.get(
pk=node['nodeid'])
no.sortorder = sortorder
no.save()
sortorder = sortorder + 1
ret = data
return JSONResponse(ret)
except GraphValidationError as e:
return JSONResponse(
{
'status': 'false',
'success': False,
'message': e.message,
'title': e.title
},
status=500)
def post(self, request, graphid=None):
ret = {}
try:
if self.action == "import_graph":
graph_file = request.FILES.get("importedGraph").read()
graphs = JSONDeserializer().deserialize(graph_file)["graph"]
ret = GraphImporter.import_graph(graphs)
else:
if graphid is not None:
graph = Graph.objects.get(graphid=graphid)
data = JSONDeserializer().deserialize(request.body)
if self.action == "new_graph":
isresource = data[
"isresource"] if "isresource" in data else False
name = _("New Resource Model") if isresource else _(
"New Branch")
author = request.user.first_name + " " + request.user.last_name
ret = Graph.new(name=name,
is_resource=isresource,
author=author)
elif self.action == "update_node":
updated_values = graph.update_node(data)
graph.save()
ret = JSONSerializer().serializeToPython(graph)
ret["updated_values"] = updated_values
elif self.action == "update_node_layer":
nodeid = uuid.UUID(str(data.get("nodeid")))
node = graph.nodes[nodeid]
node.config = data["config"]
ret = graph
node.save()
elif self.action == "append_branch":
ret = graph.append_branch(data["property"],
nodeid=data["nodeid"],
graphid=data["graphid"])
ret = ret.serialize()
ret["nodegroups"] = graph.get_nodegroups()
ret["cards"] = graph.get_cards()
ret["widgets"] = graph.get_widgets()
graph.save()
elif self.action == "append_node":
ret = graph.append_node(nodeid=data["nodeid"])
graph.save()
elif self.action == "move_node":
ret = graph.move_node(data["nodeid"], data["property"],
data["newparentnodeid"])
graph.save()
elif self.action == "export_branch":
clone_data = graph.copy(root=data)
clone_data["copy"].save()
ret = {"success": True, "graphid": clone_data["copy"].pk}
elif self.action == "clone_graph":
clone_data = graph.copy()
ret = clone_data["copy"]
ret.save()
ret.copy_functions(
graph, [clone_data["nodes"], clone_data["nodegroups"]])
elif self.action == "reorder_nodes":
json = request.body
if json is not None:
data = JSONDeserializer().deserialize(json)
if "nodes" in data and len(data["nodes"]) > 0:
sortorder = 0
with transaction.atomic():
for node in data["nodes"]:
no = models.Node.objects.get(
pk=node["nodeid"])
no.sortorder = sortorder
no.save()
sortorder = sortorder + 1
ret = data
return JSONResponse(ret)
except GraphValidationError as e:
return JSONResponse(
{
"status": "false",
"success": False,
"message": e.message,
"title": e.title
},
status=500)
def node(request, nodeid):
if request.method == 'POST':
data = JSONDeserializer().deserialize(request.body)
if data:
node = models.Node.objects.get(nodeid=nodeid)
nodes, edges = node.get_child_nodes_and_edges()
collectors = [node_ for node_ in nodes if node_.is_collector()]
node_ids = [id_node.nodeid for id_node in nodes]
nodes = [
node_ for node_ in nodes
if (node_.nodegroup_id not in node_ids)
]
with transaction.atomic():
node.name = data.get('name', '')
node.description = data.get('description', '')
node.istopnode = data.get('istopnode', '')
node.crmclass = data.get('crmclass', '')
node.datatype = data.get('datatype', '')
node.status = data.get('status', '')
node.validations.set(data.get('validations', []))
new_nodegroup_id = data.get('nodegroup_id', None)
cardinality = data.get('cardinality', 'n')
if node.nodegroup_id != new_nodegroup_id:
edge = models.Edge.objects.get(rangenode_id=nodeid)
parent_group = edge.domainnode.nodegroup
new_group = parent_group
if new_nodegroup_id == nodeid:
new_group, created = models.NodeGroup.objects.get_or_create(
nodegroupid=nodeid,
defaults={
'cardinality': 'n',
'legacygroupid': None,
'parentnodegroup': None
})
new_group.parentnodegroup = parent_group
new_group.cardinality = cardinality
new_group.save()
parent_group = new_group
for collector in collectors:
collector.nodegroup.parentnodegroup = parent_group
collector.nodegroup.save()
for group_node in nodes:
group_node.nodegroup = new_group
group_node.save()
node.nodegroup = new_group
node.save()
return JSONResponse({
'node': node,
'group_nodes': nodes,
'collectors': collectors,
'nodegroup': node.nodegroup
})
if request.method == 'DELETE':
node = models.Node.objects.get(nodeid=nodeid)
nodes, edges = node.get_child_nodes_and_edges()
edges.append(models.Edge.objects.get(rangenode=node))
nodes.append(node)
with transaction.atomic():
[edge.delete() for edge in edges]
[node.delete() for node in nodes]
return JSONResponse({})
return HttpResponseNotFound()
def post(self, request):
if self.action == 'update_tile':
json = request.POST.get('data', None)
if json != None:
data = JSONDeserializer().deserialize(json)
try:
models.ResourceInstance.objects.get(
pk=data['resourceinstance_id'])
except ObjectDoesNotExist:
resource = Resource()
resource.resourceinstanceid = data['resourceinstance_id']
graphid = models.Node.objects.filter(
nodegroup=data['nodegroup_id'])[0].graph_id
resource.graph_id = graphid
resource.save(user=request.user)
resource.index()
tile_id = data['tileid']
if tile_id != None and tile_id != '':
old_tile = Tile.objects.get(pk=tile_id)
clean_resource_cache(old_tile)
tile = Tile(data)
if tile.filter_by_perm(request.user, 'write_nodegroup'):
with transaction.atomic():
try:
tile.save(request=request)
if tile_id == '4345f530-aa90-48cf-b4b3-92d1185ca439':
import couchdb
import json as json_json
couch = couchdb.Server(settings.COUCHDB_URL)
for project in models.MobileSurveyModel.objects.all(
):
db = couch['project_' + str(project.id)]
#tile = models.TileModel.objects.get(pk='4345f530-aa90-48cf-b4b3-92d1185ca439')
tile_json = json_json.loads(
JSONSerializer().serialize(tile))
tile_json['_id'] = tile_json['tileid']
for row in db.view('_all_docs',
include_docs=True):
if 'tileid' in row.doc and tile_json[
'_id'] == row.doc['_id']:
tile_json['_rev'] = row.doc['_rev']
db.save(tile_json)
except ValidationError as e:
return JSONResponse(
{
'status': 'false',
'message': e.args
},
status=500)
tile.after_update_all()
clean_resource_cache(tile)
update_system_settings_cache(tile)
return JSONResponse(tile)
else:
return JSONResponse(
{
'status':
'false',
'message':
[_('Request Failed'),
_('Permission Denied')]
},
status=500)
if self.action == 'reorder_tiles':
json = request.body
if json != None:
data = JSONDeserializer().deserialize(json)
if 'tiles' in data and len(data['tiles']) > 0:
sortorder = 0
with transaction.atomic():
for tile in data['tiles']:
t = Tile(tile)
if t.filter_by_perm(request.user,
'write_nodegroup'):
t.sortorder = sortorder
t.save(update_fields=['sortorder'],
request=request)
sortorder = sortorder + 1
return JSONResponse(data)
if self.action == 'delete_provisional_tile':
data = request.POST
if 'tileid' in data:
provisionaledits = self.delete_provisional_edit(data, request)
return JSONResponse(provisionaledits)
else:
payload = data.get('payload', None)
if payload is not None:
edits = jsonparser.loads(payload)
for edit in edits['edits']:
provisionaledits = self.delete_provisional_edit(
edit, request)
return JSONResponse({'result': 'success'})
return HttpResponseNotFound()
def post(self, request):
if self.action == 'update_tile':
json = request.POST.get('data', None)
if json != None:
data = JSONDeserializer().deserialize(json)
try:
models.ResourceInstance.objects.get(pk=data['resourceinstance_id'])
except ObjectDoesNotExist:
resource = Resource()
resource.resourceinstanceid = data['resourceinstance_id']
graphid = models.Node.objects.filter(nodegroup=data['nodegroup_id'])[0].graph_id
resource.graph_id = graphid
resource.save(user=request.user)
resource.index()
tile_id = data['tileid']
if tile_id != None and tile_id != '':
old_tile = Tile.objects.get(pk=tile_id)
clean_resource_cache(old_tile)
tile = Tile(data)
if tile.filter_by_perm(request.user, 'write_nodegroup'):
with transaction.atomic():
try:
tile.save(request=request)
if tile_id == '4345f530-aa90-48cf-b4b3-92d1185ca439':
import couchdb
import json as json_json
couch = couchdb.Server(settings.COUCHDB_URL)
for project in models.MobileSurveyModel.objects.all():
db = couch['project_' + str(project.id)]
#tile = models.TileModel.objects.get(pk='4345f530-aa90-48cf-b4b3-92d1185ca439')
tile_json = json_json.loads(JSONSerializer().serialize(tile))
tile_json['_id'] = tile_json['tileid']
for row in db.view('_all_docs', include_docs=True):
if 'tileid' in row.doc and tile_json['_id'] == row.doc['_id']:
tile_json['_rev'] = row.doc['_rev']
db.save(tile_json)
except ValidationError as e:
return JSONResponse({'status':'false','message':e.args}, status=500)
tile.after_update_all()
clean_resource_cache(tile)
update_system_settings_cache(tile)
return JSONResponse(tile)
else:
return JSONResponse({'status':'false','message': [_('Request Failed'), _('Permission Denied')]}, status=500)
if self.action == 'reorder_tiles':
json = request.body
if json != None:
data = JSONDeserializer().deserialize(json)
if 'tiles' in data and len(data['tiles']) > 0:
sortorder = 0
with transaction.atomic():
for tile in data['tiles']:
t = Tile(tile)
if t.filter_by_perm(request.user, 'write_nodegroup'):
t.sortorder = sortorder
t.save(update_fields=['sortorder'], request=request)
sortorder = sortorder + 1
return JSONResponse(data)
if self.action == 'delete_provisional_tile':
data = request.POST
if 'tileid' in data:
provisionaledits = self.delete_provisional_edit(data, request)
return JSONResponse(provisionaledits)
else:
payload = data.get('payload', None)
if payload is not None:
edits = jsonparser.loads(payload)
for edit in edits['edits']:
provisionaledits = self.delete_provisional_edit(edit, request)
return JSONResponse({'result':'success'})
return HttpResponseNotFound()
