def buffer(request):
spatial_filter = JSONDeserializer().deserialize(request.GET.get('filter', {'geometry':{'type':'','coordinates':[]},'buffer':{'width':'0','unit':'ft'}}))
if spatial_filter['geometry']['coordinates'] != '' and spatial_filter['geometry']['type'] != '':
return JSONResponse(_buffer(spatial_filter['geometry'],spatial_filter['buffer']['width'],spatial_filter['buffer']['unit']), geom_format='json')
return JSONResponse()
def delete(self, request):
json = request.body
if json != None:
ret = []
data = JSONDeserializer().deserialize(json)
with transaction.atomic():
tile = Tile.objects.get(tileid=data['tileid'])
if tile.filter_by_perm(request.user, 'delete_nodegroup'):
nodegroup = models.NodeGroup.objects.get(
pk=tile.nodegroup_id)
clean_resource_cache(tile)
tile.delete(request=request)
tile.after_update_all()
update_system_settings_cache(tile)
return JSONResponse(tile)
else:
return JSONResponse(
{
'status':
'false',
'message':
[_('Request Failed'),
_('Permission Denied')]
},
status=500)
return HttpResponseNotFound()
def manager(request):
resourceinstanceid = '40000000-0000-0000-0000-000000000000'
if request.method == 'GET':
form = Form(resourceinstanceid)
return render(request, 'config-manager.htm', {
'main_script': 'config-manager',
'active_page': 'Home',
'forms': form.forms,
'widgets': form.widgets,
'blanks': JSONSerializer().serialize(form.blanks),
'tiledata': JSONSerializer().serialize(form.tiles)
})
if request.method == 'POST':
json = request.body
if json != None:
data = JSONDeserializer().deserialize(json)
#print data
def saveTile(data, parenttile_id=None):
data['tileid'], created = uuid.get_or_create(data['tileid'])
tile, created = models.Tile.objects.update_or_create(
tileid = data['tileid'],
defaults = {
'nodegroup_id': data['nodegroup_id'],
'data': data['data'],
'resourceinstance_id': data['resourceinstance_id'],
'parenttile_id': data['parenttile_id']
}
)
return data
if 'tiles' in data and len(data['tiles']) > 0:
parenttile = saveTile(data)
for key, tiles in data['tiles'].iteritems():
for tile in tiles:
tile['parenttile_id'] = parenttile['tileid']
saveTile(tile)
else:
saveTile(data)
return JSONResponse(data)
if request.method == 'DELETE':
json = request.body
if json != None:
data = JSONDeserializer().deserialize(json)
print data
tile = models.Tile.objects.get(tileid = data['tileid'])
tile.delete()
tile.tileid = data['tileid']
return JSONResponse(tile)
def post(self, request):
if self.action == 'update_tile':
json = request.POST.get('data', None)
if json != None:
data = JSONDeserializer().deserialize(json)
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)
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)
return HttpResponseNotFound()
def map_layers(request, entitytypeid='all', get_centroids=False):
data = []
geom_param = request.GET.get('geom', None)
bbox = request.GET.get('bbox', '')
limit = request.GET.get('limit', settings.MAP_LAYER_FEATURE_LIMIT)
entityids = request.GET.get('entityid', '')
geojson_collection = {"type": "FeatureCollection", "features": []}
se = SearchEngineFactory().create()
query = Query(se, limit=limit)
args = {'index': 'maplayers'}
if entitytypeid != 'all':
args['doc_type'] = entitytypeid
if entityids != '':
for entityid in entityids.split(','):
geojson_collection['features'].append(
se.search(index='maplayers', id=entityid)['_source'])
return JSONResponse(geojson_collection)
data = query.search(**args)
if not data:
return JSONResponse({})
for item in data['hits']['hits']:
# Ce uporabnik ni avtenticiran, prikazemo le veljavne (to je verjetno potrebno se dodelati (mogoce da vidijo le svoje???)!!!)
if (not request.user.username != 'anonymous'):
if (item['_source']['properties']['ewstatus'] !=
settings.PUBLISHED_LABEL):
continue
if get_centroids:
item['_source']['geometry'] = item['_source']['properties'][
'centroid']
#item['_source'].pop('properties', None)
item['_source']['properties'].pop('extent', None)
item['_source']['properties'].pop('elements', None)
item['_source']['properties'].pop('entitytypeid', None)
item['_source']['properties'].pop('constructions', None)
item['_source']['properties'].pop('centroid', None)
item['_source']['properties'].pop('ewstatus', None)
item['_source']['properties'].pop('address', None)
item['_source']['properties'].pop('designations', None)
item['_source']['properties'].pop('primaryname', None)
item['_source']['properties'].pop('resource_type', None)
elif geom_param != None:
item['_source']['geometry'] = item['_source']['properties'][
geom_param]
item['_source']['properties'].pop('extent', None)
item['_source']['properties'].pop(geom_param, None)
else:
item['_source']['properties'].pop('extent', None)
item['_source']['properties'].pop('centroid', None)
geojson_collection['features'].append(item['_source'])
return JSONResponse(geojson_collection)
def map_layers(request, entitytypeid='all', get_centroids=False):
data = []
geom_param = request.GET.get('geom', None)
bbox = request.GET.get('bbox', '')
limit = request.GET.get('limit', settings.MAP_LAYER_FEATURE_LIMIT)
entityids = request.GET.get('entityid', '')
geojson_collection = {"type": "FeatureCollection", "features": []}
se = SearchEngineFactory().create()
query = Query(se, limit=limit)
args = {'index': 'maplayers'}
if entitytypeid != 'all':
args['doc_type'] = entitytypeid
if entityids != '':
for entityid in entityids.split(','):
geojson_collection['features'].append(
se.search(index='maplayers', id=entityid)['_source'])
return JSONResponse(geojson_collection)
if get_centroids:
# If we are just fetching the centroids, we can do a slightly optimised query by having elasticsearch pull out relevant fields
args['fields'] = [
'properties.centroid.coordinates', 'type', '_source.id'
]
data = query.search(**args)
geojson_collection['features'] = [{
"geometry": {
"type": "Point",
"coordinates":
item['fields']['properties.centroid.coordinates']
},
"type": "Feature",
"id": item['_id']
} for item in data['hits']['hits']]
else:
# We need the full data for each record
data = query.search(**args)
for item in data['hits']['hits']:
if geom_param != None:
item['_source']['geometry'] = item['_source']['properties'][
geom_param]
item['_source']['properties'].pop('extent', None)
item['_source']['properties'].pop(geom_param, None)
else:
item['_source']['properties'].pop('extent', None)
item['_source']['properties'].pop('centroid', None)
geojson_collection['features'].append(item['_source'])
return JSONResponse(geojson_collection)
def search_results(request):
search_results_dsl = build_search_results_dsl(request)
dsl = search_results_dsl['query']
search_buffer = search_results_dsl['search_buffer']
dsl.include('graph_id')
dsl.include('root_ontology_class')
dsl.include('resourceinstanceid')
dsl.include('points')
dsl.include('geometries')
dsl.include('displayname')
dsl.include('displaydescription')
dsl.include('map_popup')
results = dsl.search(index='resource', doc_type=get_doc_type(request))
if results is not None:
total = results['hits']['total']
page = 1 if request.GET.get('page') == '' else int(
request.GET.get('page', 1))
paginator, pages = get_paginator(request, results, total, page,
settings.SEARCH_ITEMS_PER_PAGE)
page = paginator.page(page)
# only reuturn points and geometries a user is allowed to view
geojson_nodes = get_nodegroups_by_datatype_and_perm(
request, 'geojson-feature-collection', 'read_nodegroup')
for result in results['hits']['hits']:
points = []
for point in result['_source']['points']:
if point['nodegroup_id'] in geojson_nodes:
points.append(point)
result['_source']['points'] = points
geoms = []
for geom in result['_source']['geometries']:
if geom['nodegroup_id'] in geojson_nodes:
geoms.append(geom)
result['_source']['geometries'] = geoms
ret = {}
ret['results'] = results
ret['search_buffer'] = JSONSerializer().serialize(
search_buffer) if search_buffer != None else None
ret['paginator'] = {}
ret['paginator']['current_page'] = page.number
ret['paginator']['has_next'] = page.has_next()
ret['paginator']['has_previous'] = page.has_previous()
ret['paginator']['has_other_pages'] = page.has_other_pages()
ret['paginator']['next_page_number'] = page.next_page_number(
) if page.has_next() else None
ret['paginator']['previous_page_number'] = page.previous_page_number(
) if page.has_previous() else None
ret['paginator']['start_index'] = page.start_index()
ret['paginator']['end_index'] = page.end_index()
ret['paginator']['pages'] = pages
return JSONResponse(ret)
else:
return HttpResponseNotFound(
_("There was an error retrieving the search results"))
def get(self, request, graphid, nodeid=None):
if self.action == 'export_graph':
graph = get_graphs_for_export([graphid])
graph['metadata'] = ArchesFileExporter().export_metadata()
f = JSONSerializer().serialize(graph, indent=4)
graph_name = JSONDeserializer().deserialize(f)['graph'][0]['name']
response = HttpResponse(f, content_type='json/plain')
response[
'Content-Disposition'] = 'attachment; filename="%s.json"' % (
graph_name)
return response
elif self.action == 'export_mapping_file':
mapping = create_mapping_configuration_file(graphid)
graph_name = mapping['resource_model_name']
f = json.dumps(mapping, indent=4)
# Use json.dumps above to preserve key order for mapping file.
response = HttpResponse(f, content_type='json/plain')
response[
'Content-Disposition'] = 'attachment; filename="%s.mapping"' % (
graph_name)
return response
else:
graph = Graph.objects.get(graphid=graphid)
if self.action == 'get_related_nodes':
ret = graph.get_valid_ontology_classes(nodeid=nodeid)
elif self.action == 'get_valid_domain_nodes':
ret = graph.get_valid_domain_ontology_classes(nodeid=nodeid)
return JSONResponse(ret)
return HttpResponseNotFound()
def concept_value(request):
if request.method == 'DELETE':
data = JSONDeserializer().deserialize(request.body)
if data:
with transaction.atomic():
value = ConceptValue(data)
value.delete_index()
value.delete()
return JSONResponse(value)
if request.method == 'GET':
valueid = request.GET.get('valueid')
value = models.Value.objects.get(pk=valueid)
return JSONResponse(value)
return HttpResponseNotFound
def manage_parents(request, conceptid):
if request.method == 'POST':
json = request.body
if json != None:
data = JSONDeserializer().deserialize(json)
with transaction.atomic():
if len(data['deleted']) > 0:
concept = Concept().get(id=conceptid, include=None)
for deleted in data['deleted']:
concept.addparent(deleted)
concept.delete()
concept.bulk_index()
if len(data['added']) > 0:
concept = Concept().get(id=conceptid)
for added in data['added']:
concept.addparent(added)
concept.save()
concept.bulk_index()
return JSONResponse(data)
else:
return HttpResponseNotAllowed(['POST'])
return HttpResponseNotFound()
def search_results(request):
dsl = build_search_results_dsl(request)
results = dsl.search(index='resource', doc_type=get_doc_type(request))
if results is not None:
total = results['hits']['total']
page = 1 if request.GET.get('page') == '' else int(
request.GET.get('page', 1))
paginator, pages = get_paginator(request, results, total, page,
settings.SEARCH_ITEMS_PER_PAGE)
page = paginator.page(page)
ret = {}
ret['results'] = results
ret['paginator'] = {}
ret['paginator']['current_page'] = page.number
ret['paginator']['has_next'] = page.has_next()
ret['paginator']['has_previous'] = page.has_previous()
ret['paginator']['has_other_pages'] = page.has_other_pages()
ret['paginator']['next_page_number'] = page.next_page_number(
) if page.has_next() else None
ret['paginator']['previous_page_number'] = page.previous_page_number(
) if page.has_previous() else None
ret['paginator']['start_index'] = page.start_index()
ret['paginator']['end_index'] = page.end_index()
ret['paginator']['pages'] = pages
return JSONResponse(ret)
else:
return HttpResponseNotFound(
_("There was an error retrieving the search results"))
def add_concepts_from_sparql_endpoint(request, conceptid):
if request.method == 'POST':
json = request.body
if json != None:
data = JSONDeserializer().deserialize(json)
parentconcept = Concept({
'id': conceptid,
'nodetype': data['model']['nodetype']
})
if parentconcept.nodetype == 'Concept':
relationshiptype = 'narrower'
elif parentconcept.nodetype == 'ConceptScheme':
relationshiptype = 'hasTopConcept'
provider = sparql_providers[data['endpoint']]
try:
parentconcept.subconcepts = provider.get_concepts(data['ids'])
except Exception as e:
return HttpResponseServerError(e.message)
for subconcept in parentconcept.subconcepts:
subconcept.relationshiptype = relationshiptype
parentconcept.save()
parentconcept.index()
return JSONResponse(parentconcept, indent=4)
else:
return HttpResponseNotAllowed(['POST'])
return HttpResponseNotFound()
def post(self, request, graphid):
data = JSONDeserializer().deserialize(request.body)
graph = models.GraphModel.objects.get(graphid=graphid)
template = models.ReportTemplate.objects.get(templateid=data['template_id'])
report = models.Report(name=_('New Report'), graph=graph, template=template, config=template.defaultconfig)
report.save()
return JSONResponse(report)
def get(self, request):
nodegroup_ids = JSONDeserializer().deserialize(
request.GET.get('nodegroupIds'))
identityId = request.GET.get('identityId')
identityType = request.GET.get('identityType')
ret = []
if identityType == 'group':
identity = Group.objects.get(pk=identityId)
for nodegroup_id in nodegroup_ids:
nodegroup = models.NodeGroup.objects.get(pk=nodegroup_id)
perms = [{
'codename': codename,
'name': self.get_perm_name(codename).name
} for codename in get_group_perms(identity, nodegroup)]
ret.append({'perms': perms, 'nodegroup_id': nodegroup_id})
else:
identity = User.objects.get(pk=identityId)
for nodegroup_id in nodegroup_ids:
nodegroup = models.NodeGroup.objects.get(pk=nodegroup_id)
perms = [{
'codename': codename,
'name': self.get_perm_name(codename).name
} for codename in get_user_perms(identity, nodegroup)]
# only get the group perms ("defaults") if no user defined object settings have been saved
if len(perms) == 0:
perms = [{
'codename': codename,
'name': self.get_perm_name(codename).name
} for codename in set(get_group_perms(identity, nodegroup))
]
ret.append({'perms': perms, 'nodegroup_id': nodegroup_id})
return JSONResponse(ret)
def edit_history(request, resourceid=''):
ret = []
current = None
index = -1
start = request.GET.get('start', 0)
limit = request.GET.get('limit', 10)
if resourceid != '':
dates = models.EditLog.objects.filter(
resourceid=resourceid).values_list(
'timestamp', flat=True).order_by('-timestamp').distinct(
'timestamp')[start:limit]
# dates = models.EditLog.objects.datetimes('timestamp', 'second', order='DESC')
for date in dates:
#ret[str(date)] = models.EditLog.objects.filter(resourceid = self.resource.entityid, timestamp = date)
print str(date)
for log in models.EditLog.objects.filter(
resourceid=resourceid, timestamp__in=dates).values().order_by(
'-timestamp', 'attributeentitytypeid'):
if str(log['timestamp']) != current:
current = str(log['timestamp'])
ret.append({
'date':
str(log['timestamp'].date()),
'time':
str(log['timestamp'].time().replace(
microsecond=0).isoformat()),
'log': []
})
index = index + 1
ret[index]['log'].append(log)
return JSONResponse(ret, indent=4)
def manage_parents(request, conceptid):
# need to check user credentials here
if request.method == 'POST':
json = request.body
if json != None:
data = JSONDeserializer().deserialize(json)
with transaction.atomic():
if len(data['deleted']) > 0:
concept = Concept({'id': conceptid})
for deleted in data['deleted']:
concept.addparent(deleted)
concept.delete()
if len(data['added']) > 0:
concept = Concept({'id': conceptid})
for added in data['added']:
concept.addparent(added)
concept.save()
return JSONResponse(data)
else:
return HttpResponseNotAllowed(['POST'])
return HttpResponseNotFound()
def find_overlapping(request):
'''This function queries ES when called via Ajax when a new geometry is created in the Location tab. If pre-existing resources are found within the perimeter of the polygon (or the buffered zone around a point/line/polygon), an alert is raised.'''
geomString = request.GET.get('geom', '')
geom = GEOSGeometry(geomString, srid=4326)
mindistance = settings.METER_RADIUS
if not mindistance:
mindistance = 1000 # if settings.METER_RADIUS isn't set, default to 1Km
geom.transform(3857)
buffered_geom = geom.buffer(mindistance)
buffered_geom.transform(4326)
print geom, buffered_geom
se = SearchEngineFactory().create()
query = Query(se)
boolfilter = Bool()
geoshape = GeoShape(field='geometries.value',
type=buffered_geom.geom_type,
coordinates=buffered_geom.coords)
nested = Nested(path='geometries', query=geoshape)
boolfilter.must(nested)
query.add_filter(boolfilter)
results = query.search(index='entity', doc_type='')
overlaps = []
for hit in results['hits']['hits']:
overlaps.append({
'id': hit['_id'],
'type': hit['_type'],
'primaryname': hit['_source']['primaryname']
})
return JSONResponse(overlaps)
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'
]:
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 resource_manager(request, resourcetypeid='', form_id='default', resourceid=''):
if resourceid != '':
resource = Resource(resourceid)
elif resourcetypeid != '':
resource = Resource({'entitytypeid': resourcetypeid})
if form_id == 'default':
form_id = resource.form_groups[0]['forms'][0]['id']
form = resource.get_form(form_id)
if request.method == 'DELETE':
resource.delete_index()
se = SearchEngineFactory().create()
realtionships = resource.get_related_resources(return_entities=False)
for realtionship in realtionships:
se.delete(index='resource_relations', doc_type='all', id=realtionship.resourcexid)
realtionship.delete()
resource.delete()
return JSONResponse({ 'success': True })
if request.method == 'POST':
data = JSONDeserializer().deserialize(request.POST.get('formdata', {}))
form.update(data, request.FILES)
with transaction.atomic():
if resourceid != '':
resource.delete_index()
resource.save(user=request.user)
resource.index()
resourceid = resource.entityid
return redirect('resource_manager', resourcetypeid=resourcetypeid, form_id=form_id, resourceid=resourceid)
min_max_dates = models.Dates.objects.aggregate(Min('val'), Max('val'))
if request.method == 'GET':
if form != None:
lang = request.GET.get('lang', settings.LANGUAGE_CODE)
form.load(lang)
return render(request, 'resource-manager.htm', {
'form': form,
'formdata': JSONSerializer().serialize(form.data),
'form_template': 'views/forms/' + form_id + '.htm',
'form_id': form_id,
'resourcetypeid': resourcetypeid,
'resourceid': resourceid,
'main_script': 'resource-manager',
'active_page': 'ResourceManger',
'resource': resource,
'resource_name': resource.get_primary_name(),
'resource_type_name': resource.get_type_name(),
'form_groups': resource.form_groups,
'min_date': min_max_dates['val__min'].year if min_max_dates['val__min'] != None else 0,
'max_date': min_max_dates['val__max'].year if min_max_dates['val__min'] != None else 1,
'timefilterdata': JSONSerializer().serialize(Concept.get_time_filter_data()),
})
else:
return HttpResponseNotFound('<h1>Arches form not found.</h1>')
def debug_view(request, resourceid=''):
ret = []
resource = Resource()
resource.get(resourceid)
resource_dict = resource.dictify()
return JSONResponse(resource_dict, indent=4)
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 post(self, request, cardid):
data = JSONDeserializer().deserialize(request.body)
if data:
card = Card(data)
card.save()
return JSONResponse(card)
return HttpResponseNotFound()
def get(self, request, resourceid=None):
# lang = request.GET.get('lang', settings.LANGUAGE_CODE)
start = request.GET.get('start', 0)
resource = Resource.objects.get(pk=resourceid)
related_resources = resource.get_related_resources(lang="en-US",
start=start,
limit=15)
return JSONResponse(related_resources, indent=4)
def get(self, request, resourceid=None, formid=None):
if formid is not None:
form = Form(resourceid=resourceid,
formid=formid,
user=request.user)
return JSONResponse(form)
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 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 delete(self, request, graphid):
data = JSONDeserializer().deserialize(request.body)
with transaction.atomic():
for item in data:
functionXgraph = models.FunctionXGraph.objects.get(pk=item['id'])
functionXgraph.delete()
return JSONResponse(data)
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 == '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 geocode(request):
geocoding_provider_id = request.GET.get('geocoder', '')
provider = next((provider for provider in settings.GEOCODING_PROVIDERS
if provider['id'] == geocoding_provider_id), None)
Geocoder = import_string('arches.app.utils.geocoders.' + provider['id'])
search_string = request.GET.get('q', '')
return JSONResponse({
'results':
Geocoder().find_candidates(search_string, provider['api_key'])
})
