def delete(self, request, resourceid=None):
delete_error = _("Unable to Delete Resource")
delete_msg = _(
"User does not have permissions to delete this instance because the instance or its data is restricted"
)
try:
if resourceid is not None:
if user_can_delete_resource(request.user, resourceid) is False:
return JSONErrorResponse(delete_error, delete_msg)
ret = Resource.objects.get(pk=resourceid)
try:
deleted = ret.delete(user=request.user)
except ModelInactiveError as e:
message = _(
"Unable to delete. Please verify the model status is active"
)
return JSONResponse(
{
"status": "false",
"message": [_(e.title),
_(str(message))]
},
status=500)
except PermissionDenied:
return JSONErrorResponse(delete_error, delete_msg)
if deleted is True:
return JSONResponse(ret)
else:
return JSONErrorResponse(delete_error, delete_msg)
return HttpResponseNotFound()
except PermissionDenied:
return JSONErrorResponse(delete_error, delete_msg)
def make_collection(request, conceptid):
concept = Concept().get(id=conceptid, values=[])
try:
collection_concept = concept.make_collection()
return JSONResponse({'collection': collection_concept, 'title': _('Success'), 'message': _('Collection successfully created from the selected concept')})
except:
return JSONErrorResponse(_('Unable to Make Collection'), _('Unable to make a collection from the selected concept.'))
def delete(self, request):
json = request.body
if json is not None:
ret = []
data = JSONDeserializer().deserialize(json)
resource_instance = models.ResourceInstance.objects.get(pk=data["resourceinstance_id"])
is_active = resource_instance.graph.isactive
with transaction.atomic():
try:
tile = Tile.objects.get(tileid=data["tileid"])
except ObjectDoesNotExist:
return JSONErrorResponse(_("This tile is no longer available"), _("It was likely already deleted by another user"))
user_is_reviewer = user_is_resource_reviewer(request.user)
if (user_is_reviewer or tile.is_provisional() is True) and is_active is True:
if tile.filter_by_perm(request.user, "delete_nodegroup"):
nodegroup = models.NodeGroup.objects.get(pk=tile.nodegroup_id)
if tile.is_provisional() is True and len(list(tile.provisionaledits.keys())) == 1:
provisional_editor_id = list(tile.provisionaledits.keys())[0]
edit = tile.provisionaledits[provisional_editor_id]
provisional_editor = User.objects.get(pk=provisional_editor_id)
reviewer = request.user
tile.delete(
request=request,
provisional_edit_log_details={
"user": reviewer,
"action": "delete edit",
"edit": edit,
"provisional_editor": provisional_editor,
},
)
else:
tile.delete(request=request)
tile.after_update_all()
update_system_settings_cache(tile)
return JSONResponse(tile)
else:
return JSONErrorResponse(_("Request Failed"), _("Permission Denied"))
elif is_active is False:
response = {"status": "false", "message": [_("Request Failed"), _("Unable to delete. Verify model status is active")]}
return JSONResponse(response, status=500)
else:
return JSONErrorResponse(
_("Request Failed"), _("You do not have permissions to delete a tile with authoritative data.")
)
return HttpResponseNotFound()
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",
"slug",
"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
if graph.isresource is False and "root" in data["graph"]:
node.config = data["graph"]["root"]["config"]
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 delete(self, request, graphid):
if self.action == "delete_node":
data = JSONDeserializer().deserialize(request.body)
try:
graph = Graph.objects.get(graphid=graphid)
graph.delete_node(node=data.get("nodeid", None))
return JSONResponse({})
except GraphValidationError as e:
return JSONErrorResponse(e.title, e.message)
elif self.action == "delete_instances":
try:
graph = Graph.objects.get(graphid=graphid)
graph.delete_instances()
return JSONResponse({
"success":
True,
"message":
"All the resources associated with the Model '{0}' have been successfully deleted."
.format(graph.name),
"title":
"Resources Successfully Deleted.",
})
except GraphValidationError as e:
return JSONErrorResponse(e.title, e.message)
except ModelInactiveError as e:
return JSONErrorResponse(e.title, e.message)
elif self.action == "delete_graph":
try:
graph = Graph.objects.get(graphid=graphid)
if graph.isresource:
graph.delete_instances()
graph.isactive = False
graph.save(validate=False)
graph.delete()
return JSONResponse({"success": True})
except GraphValidationError as e:
return JSONErrorResponse(e.title, e.message)
return HttpResponseNotFound()
def delete(self, request, resourceid=None):
if resourceid is not None:
ret = Resource.objects.get(pk=resourceid)
try:
deleted = ret.delete(user=request.user)
except ModelInactiveError as e:
message = _("Unable to delete. Please verify the model status is active")
return JSONResponse({"status": "false", "message": [_(e.title), _(str(message))]}, status=500)
if deleted is True:
return JSONResponse(ret)
else:
return JSONErrorResponse("Unable to Delete Resource", "Provisional users cannot delete resources with authoritative data")
return HttpResponseNotFound()
def handle_save_error(self, e, tile_id="", title=_("Saving tile failed"), message=None):
if message is None:
message = type(e).__name__
if hasattr(e, "message") and e.message:
message += ": {0}".format(e.message)
else:
message = str(e)
logger.error(
title
+ """ [Tile id: {tile_id}] \
[Exception message: {message}] \
[Exception trace: {trace}]""".format(
tile_id=tile_id, message=message, trace=traceback.format_exc()
)
)
return JSONErrorResponse(_(title), _(str(message)), {"message": message, "title": title})
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 download_files(self, request):
try:
tileids = jsonparser.loads(request.GET.get("tiles", None))
nodeid = request.GET.get("node", None)
tiles = Tile.objects.filter(pk__in=tileids)
files = sum(
[[{
"name":
file["name"],
"outputfile":
models.File.objects.get(pk=file["file_id"]).path
} for file in tile.data[nodeid]] for tile in tiles],
[],
)
response = arches_zip.zip_response(files,
"file-viewer-download.zip")
return response
except TypeError as e:
logger.error("Tile id array required to download files.")
return JSONErrorResponse(_("Request Failed"), _(e))
def post(self, request, graphid=None):
ret = {}
try:
if self.action == "import_graph":
graph_file = request.FILES.get("importedGraph").read()
graphs = JSONDeserializer().deserialize(graph_file)["graph"]
ret = GraphImporter.import_graph(graphs)
else:
if graphid is not None:
graph = Graph.objects.get(graphid=graphid)
data = JSONDeserializer().deserialize(request.body)
if self.action == "new_graph":
isresource = data[
"isresource"] if "isresource" in data else False
name = _("New Resource Model") if isresource else _(
"New Branch")
author = request.user.first_name + " " + request.user.last_name
ret = Graph.new(name=name,
is_resource=isresource,
author=author)
elif self.action == "update_node":
old_node_data = graph.nodes.get(uuid.UUID(data["nodeid"]))
nodegroup_changed = str(
old_node_data.nodegroup_id) != data["nodegroup_id"]
updated_values = graph.update_node(data)
if "nodeid" in data and nodegroup_changed is False:
graph.save(nodeid=data["nodeid"])
else:
graph.save()
ret = JSONSerializer().serializeToPython(graph)
ret["updated_values"] = updated_values
ret["default_card_name"] = graph.temp_node_name
elif self.action == "update_node_layer":
nodeid = uuid.UUID(str(data.get("nodeid")))
node = graph.nodes[nodeid]
node.config = data["config"]
ret = graph
node.save()
elif self.action == "append_branch":
ret = graph.append_branch(data["property"],
nodeid=data["nodeid"],
graphid=data["graphid"])
ret = ret.serialize()
ret["nodegroups"] = graph.get_nodegroups()
ret["cards"] = graph.get_cards()
ret["widgets"] = graph.get_widgets()
graph.save()
elif self.action == "append_node":
ret = graph.append_node(nodeid=data["nodeid"])
graph.save()
elif self.action == "move_node":
ret = graph.move_node(data["nodeid"], data["property"],
data["newparentnodeid"])
graph.save()
elif self.action == "export_branch":
clone_data = graph.copy(root=data)
clone_data["copy"].slug = None
clone_data["copy"].save()
ret = {"success": True, "graphid": clone_data["copy"].pk}
elif self.action == "clone_graph":
clone_data = graph.copy()
ret = clone_data["copy"]
ret.slug = None
ret.save()
ret.copy_functions(
graph, [clone_data["nodes"], clone_data["nodegroups"]])
elif self.action == "reorder_nodes":
json = request.body
if json is not None:
data = JSONDeserializer().deserialize(json)
if "nodes" in data and len(data["nodes"]) > 0:
sortorder = 0
with transaction.atomic():
for node in data["nodes"]:
no = models.Node.objects.get(
pk=node["nodeid"])
no.sortorder = sortorder
no.save()
sortorder = sortorder + 1
ret = data
return JSONResponse(ret)
except GraphValidationError as e:
return JSONErrorResponse(e.title, e.message, {"status": "Failed"})
except ModelInactiveError as e:
return JSONErrorResponse(e.title, e.message)
except RequestError as e:
return JSONErrorResponse(
_("Elasticsearch indexing error"),
_("""If you want to change the datatype of an existing node.
Delete and then re-create the node, or export the branch then edit the datatype and re-import the branch."""
),
)
def search_results(request):
for_export = request.GET.get("export")
total = int(request.GET.get("total", "0"))
se = SearchEngineFactory().create()
search_results_object = {"query": Query(se)}
include_provisional = get_provisional_type(request)
permitted_nodegroups = get_permitted_nodegroups(request.user)
search_filter_factory = SearchFilterFactory(request)
try:
for filter_type, querystring in list(
request.GET.items()) + [("search-results", "")]:
search_filter = search_filter_factory.get_filter(filter_type)
if search_filter:
search_filter.append_dsl(search_results_object,
permitted_nodegroups,
include_provisional)
except Exception as err:
return JSONErrorResponse(message=err)
dsl = search_results_object.pop("query", None)
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")
dsl.include("provisional_resource")
if request.GET.get("tiles", None) is not None:
dsl.include("tiles")
if for_export is True:
results = dsl.search(index="resources", scroll="1m")
scroll_id = results["_scroll_id"]
if total <= settings.SEARCH_EXPORT_LIMIT:
pages = (total // settings.SEARCH_RESULT_LIMIT) + 1
if total > settings.SEARCH_EXPORT_LIMIT:
pages = int(settings.SEARCH_EXPORT_LIMIT //
settings.SEARCH_RESULT_LIMIT) - 1
for page in range(pages):
results_scrolled = dsl.se.es.scroll(scroll_id=scroll_id,
scroll="1m")
results["hits"]["hits"] += results_scrolled["hits"]["hits"]
else:
results = dsl.search(index="resources")
ret = {}
if results is not None:
# allow filters to modify the results
for filter_type, querystring in list(
request.GET.items()) + [("search-results", "")]:
search_filter = search_filter_factory.get_filter(filter_type)
if search_filter:
search_filter.post_search_hook(search_results_object, results,
permitted_nodegroups)
ret["results"] = results
for key, value in list(search_results_object.items()):
ret[key] = value
ret["reviewer"] = user_is_resource_reviewer(request.user)
ret["timestamp"] = datetime.now()
ret["total_results"] = dsl.count(index="resources")
return JSONResponse(ret)
else:
ret = {
"message": _("There was an error retrieving the search results")
}
return JSONResponse(ret, status=500)
def post(self, request):
if self.action == "update_tile":
json = request.POST.get("data", None)
accepted_provisional = request.POST.get("accepted_provisional",
None)
if accepted_provisional is not None:
accepted_provisional_edit = JSONDeserializer().deserialize(
accepted_provisional)
if json is not None:
data = JSONDeserializer().deserialize(json)
data[
"resourceinstance_id"] = "" if "resourceinstance_id" not in data else data[
"resourceinstance_id"]
if data["resourceinstance_id"] == "":
data["resourceinstance_id"] = uuid.uuid4()
try:
models.ResourceInstance.objects.get(
pk=data["resourceinstance_id"])
except ObjectDoesNotExist:
try:
resource = Resource(
uuid.UUID(str(data["resourceinstance_id"])))
except ValueError:
resource = Resource()
graphid = models.Node.objects.filter(
nodegroup=data["nodegroup_id"])[0].graph_id
resource.graph_id = graphid
try:
resource.save(user=request.user)
data["resourceinstance_id"] = resource.pk
resource.index()
except ModelInactiveError as e:
message = _(
"Unable to save. Please verify the model status is active"
)
return JSONResponse(
{
"status": "false",
"message": [_(e.title),
_(str(message))]
},
status=500)
tile_id = data["tileid"]
resource_instance = models.ResourceInstance.objects.get(
pk=data["resourceinstance_id"])
is_active = resource_instance.graph.isactive
if tile_id is not None and tile_id != "":
try:
old_tile = Tile.objects.get(pk=tile_id)
except ObjectDoesNotExist as e:
return self.handle_save_error(
e, _("This tile is no longer available"),
_("It was likely deleted by another user"))
tile = Tile(data)
if tile.filter_by_perm(
request.user, "write_nodegroup") and is_active is True:
try:
with transaction.atomic():
try:
if accepted_provisional is None:
try:
tile.save(request=request)
except TileValidationError as e:
resource_tiles = models.TileModel.objects.filter(
resourceinstance=tile.
resourceinstance)
if resource_tiles.count() == 0:
Resource.objects.get(
pk=tile.resourceinstance_id
).delete(request.user)
title = _(
"Unable to save. Please verify your input is valid"
)
return self.handle_save_error(
e, tile_id, title=title)
except ModelInactiveError as e:
message = _(
"Unable to save. Please verify the model status is active"
)
return JSONResponse(
{
"status":
"false",
"message":
[_(e.title),
_(str(message))]
},
status=500)
else:
if accepted_provisional is not None:
provisional_editor = User.objects.get(
pk=accepted_provisional_edit[
"user"])
prov_edit_log_details = {
"user":
request.user,
"action":
"accept edit",
"edit":
accepted_provisional_edit,
"provisional_editor":
provisional_editor,
}
tile.save(request=request,
provisional_edit_log_details=
prov_edit_log_details)
if tile.provisionaledits is not None and str(
request.user.id
) in tile.provisionaledits:
tile.data = tile.provisionaledits[str(
request.user.id)]["value"]
except Exception as e:
return self.handle_save_error(e, tile_id)
tile.after_update_all()
update_system_settings_cache(tile)
except Exception as e:
return self.handle_save_error(e, tile_id)
return JSONResponse(tile)
elif is_active is False:
response = {
"status":
"false",
"message": [
_("Request Failed"),
_("Unable to Save. Verify model status is active")
]
}
return JSONResponse(response, status=500)
else:
return JSONErrorResponse(_("Request Failed"),
_("Permission Denied"))
if self.action == "reorder_tiles":
json = request.body
if json is not None:
data = JSONDeserializer().deserialize(json)
if "tiles" in data and len(data["tiles"]) > 0:
sortorder = 0
with transaction.atomic():
for tile in data["tiles"]:
t = Tile(tile)
if t.filter_by_perm(request.user,
"write_nodegroup"):
t.sortorder = sortorder
t.save(update_fields=["sortorder"],
request=request)
sortorder = sortorder + 1
return JSONResponse(data)
if self.action == "delete_provisional_tile":
user = request.POST.get("user", None)
tileid = request.POST.get("tileid", None)
users = request.POST.get("users", None)
tile = Tile.objects.get(tileid=tileid)
is_provisional = tile.is_provisional()
if tileid is not None and user is not None:
provisionaledits = self.delete_provisional_edit(
tile, user, request)
elif tileid is not None and users is not None:
users = jsonparser.loads(users)
for user in users:
self.delete_provisional_edit(tile, user, request)
if is_provisional == True:
return JSONResponse({"result": "delete"})
else:
return JSONResponse({"result": "success"})
return HttpResponseNotFound()
def concept(request, conceptid):
f = request.GET.get("f", "json")
mode = request.GET.get("mode", "")
lang = request.GET.get("lang", request.LANGUAGE_CODE)
pretty = request.GET.get("pretty", False)
if request.method == "GET":
include_subconcepts = request.GET.get("include_subconcepts",
"true") == "true"
include_parentconcepts = request.GET.get("include_parentconcepts",
"true") == "true"
include_relatedconcepts = request.GET.get("include_relatedconcepts",
"true") == "true"
emulate_elastic_search = request.GET.get("emulate_elastic_search",
"false") == "true"
depth_limit = request.GET.get("depth_limit", None)
depth_limit = 1
if not conceptid:
return render(
request,
"views/rdm/concept-report.htm",
{
"lang":
lang,
"concept_count":
models.Concept.objects.filter(nodetype="Concept").count(),
"collection_count":
models.Concept.objects.filter(
nodetype="Collection").count(),
"scheme_count":
models.Concept.objects.filter(
nodetype="ConceptScheme").count(),
"entitytype_count":
models.Concept.objects.filter(
nodetype="EntityType").count(),
"default_report":
True,
},
)
labels = []
concept_graph = Concept().get(
id=conceptid,
include_subconcepts=include_subconcepts,
include_parentconcepts=include_parentconcepts,
include_relatedconcepts=include_relatedconcepts,
depth_limit=depth_limit,
up_depth_limit=None,
lang=lang,
semantic=(mode == "semantic" or mode == ""),
)
languages = sort_languages(models.DLanguage.objects.all(), lang)
valuetypes = models.DValueType.objects.all()
relationtypes = models.DRelationType.objects.all()
prefLabel = concept_graph.get_preflabel(lang=lang)
for subconcept in concept_graph.subconcepts:
subconcept.prefLabel = subconcept.get_preflabel(lang=lang)
for relatedconcept in concept_graph.relatedconcepts:
relatedconcept.prefLabel = relatedconcept.get_preflabel(lang=lang)
for value in concept_graph.values:
if value.category == "label":
labels.append(value)
if value.type == "image":
value.full_image_url = (
(settings.FORCE_SCRIPT_NAME
if settings.FORCE_SCRIPT_NAME is not None else "") +
settings.MEDIA_URL + value.value).replace("//", "/")
if (mode == "semantic"
or mode == "") and (concept_graph.nodetype == "Concept" or
concept_graph.nodetype == "ConceptScheme"
or concept_graph.nodetype == "EntityType"):
if concept_graph.nodetype == "ConceptScheme":
parent_relations = relationtypes.filter(category="Properties")
else:
parent_relations = (relationtypes.filter(
category="Semantic Relations").exclude(
relationtype="related").exclude(
relationtype="broader").exclude(
relationtype="broaderTransitive"))
return render(
request,
"views/rdm/concept-report.htm",
{
"FORCE_SCRIPT_NAME":
settings.FORCE_SCRIPT_NAME,
"lang":
lang,
"prefLabel":
prefLabel,
"labels":
labels,
"concept":
concept_graph,
"languages":
languages,
"sparql_providers":
get_sparql_providers(),
"valuetype_labels":
valuetypes.filter(category="label"),
"valuetype_notes":
valuetypes.filter(category="note"),
"valuetype_related_values":
valuetypes.filter(
category__in=["undefined", "identifiers"]),
"parent_relations":
parent_relations,
"related_relations":
relationtypes.filter(
Q(category="Mapping Properties")
| Q(relationtype="related")),
"concept_paths":
concept_graph.get_paths(lang=lang),
"graph_json":
JSONSerializer().serialize(
concept_graph.get_node_and_links(lang=lang)),
"direct_parents": [
parent.get_preflabel(lang=lang)
for parent in concept_graph.parentconcepts
],
},
)
elif mode == "collections":
return render(
request,
"views/rdm/entitytype-report.htm",
{
"lang":
lang,
"prefLabel":
prefLabel,
"labels":
labels,
"concept":
concept_graph,
"languages":
languages,
"valuetype_labels":
valuetypes.filter(category="label"),
"valuetype_notes":
valuetypes.filter(category="note"),
"valuetype_related_values":
valuetypes.filter(
category__in=["undefined", "identifiers"]),
"related_relations":
relationtypes.filter(relationtype="member"),
"concept_paths":
concept_graph.get_paths(lang=lang),
},
)
if request.method == "POST":
if len(request.FILES) > 0:
skosfile = request.FILES.get("skosfile", None)
imagefile = request.FILES.get("file", None)
if imagefile:
value = models.FileValue(
valueid=str(uuid.uuid4()),
value=request.FILES.get("file", None),
concept_id=conceptid,
valuetype_id="image",
language_id=lang,
)
value.save()
return JSONResponse(value)
elif skosfile:
overwrite_options = request.POST.get("overwrite_options", None)
staging_options = request.POST.get("staging_options", None)
skos = SKOSReader()
try:
rdf = skos.read_file(skosfile)
ret = skos.save_concepts_from_skos(rdf, overwrite_options,
staging_options)
return JSONResponse(ret)
except Exception as e:
return JSONErrorResponse(
_('Unable to Load SKOS File'),
_('There was an issue saving the contents of the file to Arches. '
) + str(e))
else:
data = JSONDeserializer().deserialize(request.body)
if data:
with transaction.atomic():
concept = Concept(data)
concept.save()
concept.index()
return JSONResponse(concept)
if request.method == "DELETE":
data = JSONDeserializer().deserialize(request.body)
if data:
with transaction.atomic():
concept = Concept(data)
delete_self = data[
"delete_self"] if "delete_self" in data else False
if not (delete_self and concept.id in CORE_CONCEPTS):
if concept.nodetype == "Collection":
concept.delete(delete_self=delete_self)
else:
in_use = False
if delete_self:
check_concept = Concept().get(
data["id"], include_subconcepts=True)
in_use = check_concept.check_if_concept_in_use()
if "subconcepts" in data:
for subconcept in data["subconcepts"]:
if in_use == False:
check_concept = Concept().get(
subconcept["id"],
include_subconcepts=True)
in_use = check_concept.check_if_concept_in_use(
)
if in_use == False:
concept.delete_index(delete_self=delete_self)
concept.delete(delete_self=delete_self)
else:
return JSONErrorResponse(
_('Unable to Delete'),
_('This concept or one of it\'s subconcepts is already in use by an existing resource.'
), {"in_use": in_use})
return JSONResponse(concept)
return HttpResponseNotFound
def post(self, request, surveyid):
data = JSONDeserializer().deserialize(request.body)
if models.MobileSurveyModel.objects.filter(pk=data["id"]).exists() is False:
mobile_survey_model = models.MobileSurveyModel(
id=surveyid, name=data["name"], createdby=self.request.user, lasteditedby=self.request.user
)
mobile_survey_model.save()
mobile_survey = MobileSurvey.objects.get(pk=data["id"])
self.update_identities(data, mobile_survey, mobile_survey.users.all(), "users", User, models.MobileSurveyXUser)
self.update_identities(data, mobile_survey, mobile_survey.groups.all(), "groups", Group, models.MobileSurveyXGroup)
mobile_survey_card_ids = {str(c.cardid) for c in mobile_survey.cards.all()}
form_card_ids = set(data["cards"])
cards_to_remove = mobile_survey_card_ids - form_card_ids
cards_to_add = form_card_ids - mobile_survey_card_ids
cards_to_update = mobile_survey_card_ids & form_card_ids
for card_id in cards_to_add:
models.MobileSurveyXCard.objects.create(
card=models.CardModel.objects.get(cardid=card_id), mobile_survey=mobile_survey, sortorder=data["cards"].index(card_id)
)
for card_id in cards_to_update:
mobile_survey_card = models.MobileSurveyXCard.objects.filter(mobile_survey=mobile_survey).get(
card=models.CardModel.objects.get(cardid=card_id)
)
mobile_survey_card.sortorder = data["cards"].index(card_id)
mobile_survey_card.save()
for card_id in cards_to_remove:
models.MobileSurveyXCard.objects.filter(card=models.CardModel.objects.get(cardid=card_id), mobile_survey=mobile_survey).delete()
# TODO Disabling the following section until we make emailing users optional
# if mobile_survey.active != data['active']:
# notify users in the mobile_survey that the state of the mobile_survey has changed
# if data['active']:
# self.notify_mobile_survey_start(request, mobile_survey)
# else:
# self.notify_mobile_survey_end(request, mobile_survey)
mobile_survey.name = data["name"]
mobile_survey.description = data["description"]
mobile_survey.onlinebasemaps = data["onlinebasemaps"]
if data["startdate"] != "":
mobile_survey.startdate = data["startdate"]
if data["enddate"] != "":
mobile_survey.enddate = data["enddate"]
mobile_survey.datadownloadconfig = data["datadownloadconfig"]
mobile_survey.active = data["active"]
mobile_survey.tilecache = data["tilecache"]
polygons = []
# try:
# data['bounds'].upper()
# data['bounds'] = json.loads(data['bounds'])
# except AttributeError as e:
# print('bounds is not a string')
if "features" in data["bounds"]:
for feature in data["bounds"]["features"]:
for coord in feature["geometry"]["coordinates"]:
polygons.append(Polygon(coord))
elif len(polygons) == 0:
try:
if data["bounds"]["type"] == "MultiPolygon":
for poly in data["bounds"]["coordinates"]:
for coords in poly:
polygons.append(Polygon(coords))
except AttributeError as e:
print("bounds is not a geojson geometry object")
mobile_survey.bounds = MultiPolygon(polygons)
mobile_survey.lasteditedby = self.request.user
try:
with transaction.atomic():
mobile_survey.save()
except ConnectionRefusedError as e:
error_title = _("Unable to save collector project")
error_message = _("Failed to connect to a CouchDB service")
connection_error = JSONErrorResponse(error_title, error_message)
return connection_error
except Exception as e:
error_title = _("Unable to save collector project")
logger.exception(e)
connection_error = JSONErrorResponse(error_title, e)
return connection_error
return JSONResponse({"success": True, "mobile_survey": mobile_survey})
def search_results(request, returnDsl=False):
for_export = request.GET.get("export")
pages = request.GET.get("pages", None)
total = int(request.GET.get("total", "0"))
resourceinstanceid = request.GET.get("id", None)
load_tiles = request.GET.get("tiles", False)
if load_tiles:
try:
load_tiles = json.loads(load_tiles)
except TypeError:
pass
se = SearchEngineFactory().create()
permitted_nodegroups = get_permitted_nodegroups(request.user)
include_provisional = get_provisional_type(request)
search_filter_factory = SearchFilterFactory(request)
search_results_object = {"query": Query(se)}
try:
for filter_type, querystring in list(
request.GET.items()) + [("search-results", "")]:
search_filter = search_filter_factory.get_filter(filter_type)
if search_filter:
search_filter.append_dsl(search_results_object,
permitted_nodegroups,
include_provisional)
append_instance_permission_filter_dsl(request, search_results_object)
except Exception as err:
logger.exception(err)
return JSONErrorResponse(message=err)
dsl = search_results_object.pop("query", None)
if returnDsl:
return dsl
dsl.include("graph_id")
dsl.include("root_ontology_class")
dsl.include("resourceinstanceid")
dsl.include("points")
dsl.include("permissions.users_without_read_perm")
dsl.include("permissions.users_without_edit_perm")
dsl.include("permissions.users_without_delete_perm")
dsl.include("permissions.users_with_no_access")
dsl.include("geometries")
dsl.include("displayname")
dsl.include("displaydescription")
dsl.include("map_popup")
dsl.include("provisional_resource")
if load_tiles:
dsl.include("tiles")
if for_export or pages:
results = dsl.search(index=RESOURCES_INDEX, scroll="1m")
scroll_id = results["_scroll_id"]
if not pages:
if total <= settings.SEARCH_EXPORT_LIMIT:
pages = (total // settings.SEARCH_RESULT_LIMIT) + 1
if total > settings.SEARCH_EXPORT_LIMIT:
pages = int(settings.SEARCH_EXPORT_LIMIT //
settings.SEARCH_RESULT_LIMIT) - 1
for page in range(int(pages)):
results_scrolled = dsl.se.es.scroll(scroll_id=scroll_id,
scroll="1m")
results["hits"]["hits"] += results_scrolled["hits"]["hits"]
else:
results = dsl.search(index=RESOURCES_INDEX, id=resourceinstanceid)
ret = {}
if results is not None:
if "hits" not in results:
if "docs" in results:
results = {"hits": {"hits": results["docs"]}}
else:
results = {"hits": {"hits": [results]}}
# allow filters to modify the results
for filter_type, querystring in list(
request.GET.items()) + [("search-results", "")]:
search_filter = search_filter_factory.get_filter(filter_type)
if search_filter:
search_filter.post_search_hook(search_results_object, results,
permitted_nodegroups)
ret["results"] = results
for key, value in list(search_results_object.items()):
ret[key] = value
ret["reviewer"] = user_is_resource_reviewer(request.user)
ret["timestamp"] = datetime.now()
ret["total_results"] = dsl.count(index=RESOURCES_INDEX)
ret["userid"] = request.user.id
return JSONResponse(ret)
else:
ret = {
"message": _("There was an error retrieving the search results")
}
return JSONResponse(ret, status=500)