def get(self, request): if self.action == 'tile_history': start = request.GET.get('start') end = request.GET.get('end') edits = EditLog.objects.filter(provisional_userid=request.user.id).filter(timestamp__range=[start, end]).order_by('tileinstanceid', 'timestamp') resourceinstanceids = [e['resourceinstanceid'] for e in edits.values('resourceinstanceid')] deleted_resource_edits = EditLog.objects.filter(resourceinstanceid__in=resourceinstanceids).filter(edittype='delete') deleted_resource_instances = [e['resourceinstanceid'] for e in deleted_resource_edits.values('resourceinstanceid')] summary = {} for edit in edits: if edit.tileinstanceid not in summary: summary[edit.tileinstanceid] = {'pending': False, 'tileid': edit.tileinstanceid} summary[edit.tileinstanceid]['lasttimestamp'] = edit.timestamp summary[edit.tileinstanceid]['lastedittype'] = edit.provisional_edittype summary[edit.tileinstanceid]['reviewer'] = '' summary[edit.tileinstanceid]['resourceinstanceid'] = edit.resourceinstanceid summary[edit.tileinstanceid]['resourcedisplayname'] = edit.resourcedisplayname summary[edit.tileinstanceid]['resourcemodelid'] = edit.resourceclassid summary[edit.tileinstanceid]['nodegroupid'] = edit.nodegroupid summary[edit.tileinstanceid]['resource_deleted'] = True if edit.resourceinstanceid in deleted_resource_instances else False if edit.provisional_edittype in ['accept edit', 'delete edit']: summary[edit.tileinstanceid]['reviewer'] = edit.user_username chronological_summary = [] resource_models = models.GraphModel.objects.filter(isresource=True).exclude(graphid=settings.SYSTEM_SETTINGS_RESOURCE_MODEL_ID).values('iconclass','color','graphid','name') cards = models.CardModel.objects.all().values('name', 'nodegroup_id') card_lookup = {str(card['nodegroup_id']): card for card in cards} resource_model_lookup = {str(graph['graphid']): graph for graph in resource_models} for k, v in summary.iteritems(): if v['lastedittype'] not in ['accept edit', 'delete edit']: if models.TileModel.objects.filter(pk=k).exists(): tile = models.TileModel.objects.get(pk=k) if tile.provisionaledits is not None and str(request.user.id) in tile.provisionaledits: v['pending'] = True v['resourcemodel'] = resource_model_lookup[v['resourcemodelid']] v['card'] = card_lookup[v['nodegroupid']] if 'graphid' in v['resourcemodel']: v['resourcemodel'].pop('graphid') if 'nodegroup_id' in v['card']: v['card'].pop('nodegroup_id') chronological_summary.append(v) return JSONResponse(JSONSerializer().serialize(sorted(chronological_summary, key=lambda k: k['lasttimestamp'], reverse=True)))
def get(self, request, selectedApn): with connection.cursor() as cursor: cursor.execute( """SELECT ST_AsGeoJSON(geom)::json FROM parcels WHERE apn = %s""", [selectedApn]) feature = cursor.fetchone()[0] if not len(feature): raise Http404() response = JSONResponse({ "type": "FeatureCollection", "features": [{ "type": "Feature", "geometry": feature, "properties": {} }] }) return response
def get(self, request): site_models = [ "Archaeological Site", "Historic Cemetery", "Historic Structure" ] response = {"resources": []} for g in Graph.objects.filter(name__in=site_models): resources = Resource.objects.filter(graph_id=g.pk) for res in resources: try: siteid = res.get_node_values("FMSF ID")[0] except IndexError: continue response['resources'].append( (g.name, siteid, res.resourceinstanceid)) return JSONResponse(response)
def get(self, request, resourceid=None): if Resource.objects.filter(pk=resourceid).exists(): try: active_cons_node_list = { "Geospatial Location": "8d41e4d6-a250-11e9-accd-00224800b26d", "Name": "8d41e4ab-a250-11e9-87d1-00224800b26d", "Consultation Type": "8d41e4dd-a250-11e9-9032-00224800b26d", "Proposal": "8d41e4bd-a250-11e9-89e8-00224800b26d", "Casework Officer": "8d41e4d4-a250-11e9-a3ff-00224800b26d", "Target Date": "8d41e4cb-a250-11e9-9cf2-00224800b26d", "Consultation Log Date": "8d41e4cf-a250-11e9-a86d-00224800b26d", "Completion Date": "8d41e4cd-a250-11e9-a25b-00224800b26d", "Development Type": "8d41e4cc-a250-11e9-87b3-00224800b26d", "Application Type": "8d41e4d5-a250-11e9-b968-00224800b26d", "Application Area": "8d41e4de-a250-11e9-973b-00224800b26d", "Casework Officer": "8d41e4d4-a250-11e9-a3ff-00224800b26d", "Planning Officer": "8d41e4d7-a250-11e9-83c2-00224800b26d", "Owner": "8d41e4e1-a250-11e9-8d14-00224800b26d", "Applicant": "8d41e4ce-a250-11e9-b83c-00224800b26d", "Agent": "8d41e4d9-a250-11e9-82dc-00224800b26d", } resource = Resource.objects.get(pk=resourceid) se = SearchEngineFactory().create() document = se.search(index='resources', id=resourceid, doc_type='_doc') datatype_factory = DataTypeFactory() additional_data = {} if document['_source']['graph_id'] == '8d41e49e-a250-11e9-9eab-00224800b26d': tiles = build_resource_dict([resource], active_cons_node_list, datatype_factory) additional_data = tiles[0] ret = { 'graphid': document['_source']['graph_id'], 'graph_name': resource.graph.name, 'displaydescription': document['_source']['displaydescription'], 'map_popup': document['_source']['map_popup'], 'displayname': document['_source']['displayname'], 'geometries': document['_source']['geometries'] } ret.update(additional_data) return JSONResponse(ret) except Exception as e: logger.exception(_('Failed to fetch resource instance descriptors')) return HttpResponseNotFound()
def post(self, request): if settings.MOBILE_OAUTH_CLIENT_ID == "": message = _( "Make sure to set your MOBILE_OAUTH_CLIENT_ID in settings.py") logger.warning(message) username = request.POST.get("username", None) password = request.POST.get("password", None) user = authenticate(username=username, password=password) if user: server_settings = { "version": __version__, "clientid": settings.MOBILE_OAUTH_CLIENT_ID } response = JSONResponse(server_settings) else: response = Http401Response() return response
def post(self, request, formid): data = JSONDeserializer().deserialize(request.body) form = models.Form.objects.get(formid=formid) form.title = data['title'] form.subtitle = data['subtitle'] form.iconclass = data['iconclass'] form.visible = data['visible'] forms_x_cards = models.FormXCard.objects.filter(form=form) with transaction.atomic(): forms_x_cards.delete() for sortorder, card in enumerate(data['cards']): form_x_card = models.FormXCard( form=form, card_id=card['cardid'], sortorder=sortorder ) form_x_card.save() form.save() return JSONResponse(data)
def post(self, request, maplayerid): map_layer = models.MapLayer.objects.get(pk=maplayerid) data = JSONDeserializer().deserialize(request.body) map_layer.name = data["name"] map_layer.icon = data["icon"] map_layer.activated = data["activated"] map_layer.addtomap = data["addtomap"] map_layer.layerdefinitions = data["layer_definitions"] map_layer.centerx = data["centerx"] map_layer.centery = data["centery"] map_layer.zoom = data["zoom"] map_layer.legend = data["legend"] map_layer.searchonly = data["searchonly"] with transaction.atomic(): map_layer.save() if not map_layer.isoverlay and map_layer.addtomap: models.MapLayer.objects.filter(isoverlay=False).exclude( pk=map_layer.pk).update(addtomap=False) return JSONResponse({"success": True, "map_layer": map_layer})
def delete(self, request, surveyid): try: connection_error = False with transaction.atomic(): if surveyid is not None: ret = MobileSurvey.objects.get(pk=surveyid) ret.delete() return JSONResponse({"success": True}) except Exception as e: if connection_error is False: error_title = _("Unable to delete survey") if "strerror" in e and e.strerror == "Connection refused" or "Connection refused" in e: error_message = _("Unable to connect to CouchDB. Please confirm that CouchDB is running") else: error_message = e.message connection_error = JSONErrorResponse(error_title, error_message) return connection_error return HttpResponseNotFound()
def get(self, request): if hasattr(request.user, 'userprofile') is not True: models.UserProfile.objects.create(user=request.user) viewable_nodegroups = request.user.userprofile.viewable_nodegroups editable_nodegroups = request.user.userprofile.editable_nodegroups permitted_nodegroups = viewable_nodegroups.union(editable_nodegroups) def get_child_cardids(card, cardset): for child_card in models.CardModel.objects.filter( nodegroup__parentnodegroup_id=card.nodegroup_id): cardset.add(str(child_card.cardid)) get_child_cardids(child_card, cardset) group_ids = list(request.user.groups.values_list('id', flat=True)) projects = MobileSurvey.objects.filter(Q(users__in=[request.user]) | Q(groups__in=group_ids), active=True).distinct() projects_for_couch = [ project.serialize_for_mobile() for project in projects ] for project in projects_for_couch: project['mapboxkey'] = settings.MAPBOX_API_KEY permitted_cards = set() ordered_project_cards = project['cards'] for rootcardid in project['cards']: card = models.CardModel.objects.get(cardid=rootcardid) if str(card.nodegroup_id) in permitted_nodegroups: permitted_cards.add(str(card.cardid)) get_child_cardids(card, permitted_cards) project['cards'] = list(permitted_cards) for graph in project['graphs']: cards = [] for card in graph['cards']: if card['cardid'] in project['cards']: card['relative_position'] = ordered_project_cards.index( card['cardid'] ) if card['cardid'] in ordered_project_cards else None cards.append(card) graph['cards'] = sorted(cards, key=lambda x: x['relative_position']) response = JSONResponse(projects_for_couch, indent=4) return response
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 JSONErrorResponse(e.title, e.message)
def get(self, request): # data = JSONDeserializer().deserialize(request.body) datatype_factory = DataTypeFactory() template_id = request.GET.get('template_id') resourceinstance_id = request.GET.get('resourceinstance_id', None) self.resource = Resource.objects.get(resourceinstanceid=resourceinstance_id) self.resource.load_tiles() consultation_instance_id = None consultation = None for tile in self.resource.tiles: # self.resource is of communication model if 'a5901911-6d1e-11e9-8674-dca90488358a' in tile.data.keys(): # related-consultation nodegroup consultation_instance_id = tile.data['a5901911-6d1e-11e9-8674-dca90488358a'][0] template_name = self.get_template_path(template_id) template_path = os.path.join(settings.APP_ROOT, 'docx', template_name) self.doc = Document(template_path) new_file_name = None new_file_path = None if consultation_instance_id is not None: consultation = Resource.objects.get(resourceinstanceid=consultation_instance_id) consultation.load_tiles() if template_name == 'GLAAS Planning Letter A - No Progression - template.docx': self.edit_letter_A(consultation, datatype_factory) elif template_name == 'GLAAS Planning Letter B2 - Predetermination - template.docx': self.edit_letter_B2(consultation, datatype_factory) new_file_name = 'edited_'+template_name new_file_path = os.path.join(settings.APP_ROOT, 'uploadedfiles/docx', new_file_name) self.doc.save(new_file_path) # with open(new_file_path, "rb") as docx_file: # result = mammoth.convert_to_html(docx_file) # html = result.value # The generated HTML # with open(html_path, 'wb') as html_file: # html_file.write(html) # html_file.close() if resourceinstance_id is not None: return JSONResponse({'resource': self.resource, 'template': new_file_path, 'download': 'http://localhost:8000/files/uploadedfiles/docx/'+new_file_name }) return HttpResponseNotFound()
def get_paginated_data(self, grouped_tile_list, page_ct, page_num): paginator = Paginator(grouped_tile_list, page_ct) page_results = paginator.page(page_num) if page_results.has_next() is True: next_page_number = page_results.next_page_number() else: next_page_number = False if page_results.has_previous() is True: prev_page_number = page_results.previous_page_number() else: prev_page_number = False page_ct = paginator.num_pages pages = [page_num] if paginator.num_pages > 1: # all below creates abridged page list UI before = list(range(1, page_num)) after = list(range(page_num + 1, paginator.num_pages + 1)) default_ct = 2 ct_before = default_ct if len( after) > default_ct else default_ct * 2 - len(after) ct_after = default_ct if len( before) > default_ct else default_ct * 2 - len(before) if len(before) > ct_before: before = [1, None] + before[-1 * (ct_before - 1):] if len(after) > ct_after: after = after[0:ct_after - 1] + [None, paginator.num_pages] pages = before + pages + after page_config = { 'current_page': page_num, 'end_index': page_results.end_index(), 'has_next': page_results.has_next(), 'has_other_pages': page_results.has_other_pages(), 'has_previous': page_results.has_previous(), 'next_page_number': next_page_number, 'pages': pages, 'previous_page_number': prev_page_number, 'start_index': page_results.start_index() } return JSONResponse({ 'page_results': page_results.object_list, 'paginator': page_config })
def get(self, request, resourceid=None): if Resource.objects.filter(pk=resourceid).exclude(pk=settings.SYSTEM_SETTINGS_RESOURCE_ID).exists(): try: resource = Resource.objects.get(pk=resourceid) se = SearchEngineFactory().create() document = se.search(index="resources", id=resourceid) return JSONResponse( { "graphid": document["_source"]["graph_id"], "graph_name": resource.graph.name, "displaydescription": document["_source"]["displaydescription"], "map_popup": document["_source"]["map_popup"], "displayname": document["_source"]["displayname"], "geometries": document["_source"]["geometries"], } ) except Exception as e: logger.exception(_("Failed to fetch resource instance descriptors")) return HttpResponseNotFound()
def post(self, request): username = request.POST.get("username", None) password = request.POST.get("password", None) user = authenticate(username=username, password=password) if settings.MOBILE_OAUTH_CLIENT_ID == "": message = _("Make sure to set your MOBILE_OAUTH_CLIENT_ID in settings.py") response = HttpResponse(message, status=500) logger.warning(message) else: if user: if hasattr(user, "userprofile") is not True: models.UserProfile.objects.create(user=user) is_reviewer = user_is_resource_reviewer(user) user = JSONSerializer().serializeToPython(user) user["password"] = None user["is_reviewer"] = is_reviewer response = JSONResponse({"user": user, "clientid": settings.MOBILE_OAUTH_CLIENT_ID}) else: response = Http401Response() return response
def get(self, request, resourceid=None): lang = request.GET.get('lang', settings.LANGUAGE_CODE) start = request.GET.get('start', 0) ret = [] try: resource = Resource.objects.get(pk=resourceid) except ObjectDoesNotExist: resource = Resource() page = 1 if request.GET.get('page') == '' else int( request.GET.get('page', 1)) related_resources = resource.get_related_resources(lang=lang, start=start, limit=1000, page=page) if related_resources is not None: ret = self.paginate_related_resources(related_resources, page, request) return JSONResponse(ret)
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 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 get(self, request, resourceid=None): if resourceid is not None: se = SearchEngineFactory().create() document = se.search(index='resources', id=resourceid) resource = Resource.objects.get(pk=resourceid) return JSONResponse({ 'graphid': document['_source']['graph_id'], 'graph_name': resource.graph.name, 'displaydescription': document['_source']['displaydescription'], 'map_popup': document['_source']['map_popup'], 'displayname': document['_source']['displayname'], 'geometries': document['_source']['geometries'], }) return HttpResponseNotFound()
def post(self, request): username = request.POST.get("username", None) password = request.POST.get("password", None) user = authenticate(username=username, password=password) if user: if hasattr(user, "userprofile") is not True: models.UserProfile.objects.create(user=user) userDict = JSONSerializer().serializeToPython(user) userDict["password"] = None userDict["is_reviewer"] = user_is_resource_reviewer(user) userDict[ "viewable_nodegroups"] = user.userprofile.viewable_nodegroups userDict[ "editable_nodegroups"] = user.userprofile.editable_nodegroups userDict[ "deletable_nodegroups"] = user.userprofile.deletable_nodegroups response = JSONResponse(userDict) else: response = Http401Response() return response
def post(self, request): username = request.POST.get('username', None) password = request.POST.get('password', None) user = authenticate(username=username, password=password) if user: if hasattr(user, 'userprofile') is not True: models.UserProfile.objects.create(user=user) userDict = JSONSerializer().serializeToPython(user) userDict['password'] = None userDict['is_reviewer'] = user.userprofile.is_reviewer() userDict[ 'viewable_nodegroups'] = user.userprofile.viewable_nodegroups userDict[ 'editable_nodegroups'] = user.userprofile.editable_nodegroups userDict[ 'deletable_nodegroups'] = user.userprofile.deletable_nodegroups response = JSONResponse(userDict) else: response = Http401Response() return response
def get(self, request, graphid): self.graph = models.GraphModel.objects.get(graphid=graphid) icons = models.Icon.objects.order_by('name') resource_graphs = models.GraphModel.objects.filter(Q(isresource=True)).exclude( graphid=settings.SYSTEM_SETTINGS_RESOURCE_MODEL_ID) resource_data = [] node = models.Node.objects.get(graph_id=graphid, istopnode=True) relatable_resources = node.get_relatable_resources() for res in resource_graphs: if models.Node.objects.filter(graph=res, istopnode=True).count() > 0: node_model = models.Node.objects.get(graph=res, istopnode=True) resource_data.append({ 'id': node_model.nodeid, 'graph': res, 'is_relatable': (node_model in relatable_resources) }) data = { 'icons': JSONSerializer().serializeToPython(icons), 'node_count': models.Node.objects.filter(graph=self.graph).count(), 'resources': JSONSerializer().serializeToPython(resource_data) } return JSONResponse(data)
def post(self, request, graphid): data = JSONDeserializer().deserialize(request.body) self.graph = Graph.objects.get(graphid=graphid) with transaction.atomic(): for item in data: functionXgraph, created = models.FunctionXGraph.objects.update_or_create( pk=item["id"], defaults={ "function_id": item["function_id"], "graph_id": graphid, "config": item["config"] }) item["id"] = functionXgraph.pk # run post function save hook func = functionXgraph.function.get_class_module()() try: func.after_function_save(functionXgraph, request) except NotImplementedError: pass return JSONResponse(data)
def post(self, request): nodegroupid = None try: nodegroupid = uuid.UUID(str(request.POST.get("nodegroupid"))) except Exception as e: print(e) if self.action == "exportable" and nodegroupid is not None: exportable = json.loads(request.POST.get("exportable")) nodegroup = models.NodeGroup.objects.select_for_update().filter( nodegroupid=nodegroupid) with transaction.atomic(): for ng in nodegroup: ng.exportable = exportable ng.save() return JSONResponse({ "nodegroup": nodegroupid, "status": "success" }) return HttpResponseNotFound()
def delete(self, request, resourceid=None): lang = request.GET.get('lang', settings.LANGUAGE_CODE) se = SearchEngineFactory().create() req = dict(request.GET) ids_to_delete = req['resourcexids[]'] root_resourceinstanceid = req['root_resourceinstanceid'] for resourcexid in ids_to_delete: try: ret = models.ResourceXResource.objects.get(pk=resourcexid).delete() except: print 'resource relation does not exist' start = request.GET.get('start', 0) se.es.indices.refresh(index=se._add_prefix("resource_relations")) resource = Resource.objects.get(pk=root_resourceinstanceid[0]) page = 1 if request.GET.get('page') == '' else int(request.GET.get('page', 1)) related_resources = resource.get_related_resources(lang=lang, start=start, limit=1000, page=page) ret = [] if related_resources is not None: ret = self.paginate_related_resources(related_resources, page, request) return JSONResponse(ret, indent=4)
def post(self, request): username = request.POST.get('username', None) password = request.POST.get('password', None) user = authenticate(username=username, password=password) if settings.MOBILE_OAUTH_CLIENT_ID == '': response = HttpResponse( 'Make sure to set your MOBILE_OAUTH_CLIENT_ID in settings.py', status=500) else: if user: user = JSONSerializer().serializeToPython(user) user['password'] = None response = JSONResponse({ 'user': user, 'clientid': settings.MOBILE_OAUTH_CLIENT_ID }) else: response = Http401Response() return response
def delete(self, request, resourceid=None): lang = request.GET.get("lang", settings.LANGUAGE_CODE) se = SearchEngineFactory().create() req = dict(request.GET) ids_to_delete = req["resourcexids[]"] root_resourceinstanceid = req["root_resourceinstanceid"] for resourcexid in ids_to_delete: try: ret = models.ResourceXResource.objects.get(pk=resourcexid).delete() except ObjectDoesNotExist: logger.exception(_("Unable to delete. Relationship does not exist")) start = request.GET.get("start", 0) se.es.indices.refresh(index=se._add_prefix("resource_relations")) resource = Resource.objects.get(pk=root_resourceinstanceid[0]) page = 1 if request.GET.get("page") == "" else int(request.GET.get("page", 1)) related_resources = resource.get_related_resources(lang=lang, start=start, limit=1000, page=page) ret = [] if related_resources is not None: ret = self.paginate_related_resources(related_resources, page, request) return JSONResponse(ret, indent=4)
def get(self, request, resourceid=None): ret = {} if self.action == "get_candidates": resourceid = request.GET.get("resourceids", "") resources = Resource.objects.filter(resourceinstanceid=resourceid) ret = [] for resource in resources: res = JSONSerializer().serializeToPython(resource) res["ontologyclass"] = resource.get_root_ontology() ret.append(res) elif self.action == "get_relatable_resources": graphid = request.GET.get("graphid", None) nodes = models.Node.objects.filter(graph=graphid).exclude(istopnode=False)[0].get_relatable_resources() ret = {str(node.graph_id) for node in nodes} else: lang = request.GET.get("lang", settings.LANGUAGE_CODE) resourceinstance_graphid = request.GET.get("resourceinstance_graphid") paginate = strtobool(request.GET.get("paginate", "true")) # default to true resource = Resource.objects.get(pk=resourceid) if paginate: page = 1 if request.GET.get("page") == "" else int(request.GET.get("page", 1)) start = int(request.GET.get("start", 0)) related_resources = resource.get_related_resources( lang=lang, start=start, page=page, user=request.user, resourceinstance_graphid=resourceinstance_graphid, ) ret = self.paginate_related_resources(related_resources=related_resources, page=page, request=request) else: ret = resource.get_related_resources(lang=lang, user=request.user, resourceinstance_graphid=resourceinstance_graphid) return JSONResponse(ret)
def get(self, request): resourceid = request.GET.get('resourceid', None) nodeid = request.GET.get('nodeid', None) tileid = request.GET.get('tileid', None) if hasattr(request.user, 'userprofile') is not True: models.UserProfile.objects.create(user=request.user) viewable_nodegroups = request.user.userprofile.viewable_nodegroups nodes = models.Node.objects.filter(datatype='geojson-feature-collection', nodegroup_id__in=viewable_nodegroups) if nodeid is not None: nodes = nodes.filter(nodeid=nodeid) features = [] i = 1 for node in nodes: tiles = models.TileModel.objects.filter(nodegroup=node.nodegroup) if resourceid is not None: # resourceid = resourceid.split(',') tiles = tiles.filter(resourceinstance_id__in=resourceid.split(',')) if tileid is not None: tiles = tiles.filter(tileid=tileid) for tile in tiles: data = tile.data try: for feature_index, feature in enumerate(data[unicode(node.pk)]['features']): feature['properties']['index'] = feature_index feature['properties']['resourceinstanceid'] = tile.resourceinstance_id feature['properties']['tileid'] = tile.pk feature['properties']['nodeid'] = node.pk feature['properties']['node'] = node.name feature['properties']['model'] = node.graph.name feature['properties']['geojson'] = '%s?tileid=%s&nodeid=%s' % (reverse('geojson'), tile.pk, node.pk) feature['properties']['featureid'] = feature['id'] feature['id'] = i i += 1 features.append(feature) except KeyError: pass response = JSONResponse({'type': 'FeatureCollection', 'features': features}) return response
def paged_dropdown(request): conceptid = request.GET.get('conceptid') query = request.GET.get('query', None) query = None if query == '' else query page = int(request.GET.get('page', 1)) limit = 50 offset = (page - 1) * limit results = Concept().get_child_collections_hierarchically(conceptid, offset=offset, limit=limit, query=query) total_count = results[0][2] if len(results) > 0 else 0 data = [dict(zip(['valueto', 'depth'], d)) for d in results] data = [ dict(zip(['conceptid', 'id', 'type', 'text', 'language'], d['valueto'].values()), depth=d['depth']) for d in data ] return JSONResponse({ 'results': data, 'more': offset + limit < total_count })
def get(self, request): # via an id for a set, returns list of phys things and stuff necessary set_resourceid = (None if request.GET.get("resourceid") == "" or request.GET.get("resourceid") is None else (request.GET.get("resourceid"))) nodegroupid = request.GET.get("nodegroupid") nodeid = request.GET.get("nodeid") related = [] results = [] tiles = models.TileModel.objects.filter( resourceinstance_id=set_resourceid).filter( nodegroup_id=nodegroupid) if len(tiles) > 0: tile = tiles[0] related = tile.data[nodeid] for related_resource_item in related: search_request = HttpRequest() search_request.user = request.user search_request.GET["id"] = related_resource_item["resourceId"] result = json.loads(search_results(search_request).content) results.append(result["results"]["hits"]["hits"][0]) return JSONResponse({"items": results})
def post(self, request): messages = { "invalid_password": None, "password_validations": None, "success": None, "other": None, "mismatched": None } try: user = request.user old_password = request.POST.get("old_password") new_password = request.POST.get("new_password") new_password2 = request.POST.get("new_password2") if user.check_password(old_password) == False: messages["invalid_password"] = _("Invalid password") if new_password != new_password2: messages["mismatched"] = _( "New password and confirmation must match") try: validation.validate_password(new_password, user) except ValidationError as val_err: messages["password_validations"] = val_err.messages if messages["invalid_password"] is None and messages[ "password_validations"] is None and messages[ "mismatched"] is None: user.set_password(new_password) user.save() authenticated_user = authenticate(username=user.username, password=new_password) login(request, authenticated_user) messages["success"] = _("Password successfully updated") except Exception as err: messages["other"] = err return JSONResponse(messages)