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']) })