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)
