def test_save(self):
"""
Test that we can save a Tile object back to the database
"""
login = self.client.login(username='******', password='******')
json = {
"tiles": {
"72048cb3-adbc-11e6-9ccf-14109fd34195": [{
"tiles": {},
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "72048cb3-adbc-11e6-9ccf-14109fd34195",
"tileid": "",
"data": {
"72048cb3-adbc-11e6-9ccf-14109fd34195": "TEST 1"
}
}]
},
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "7204869c-adbc-11e6-8bec-14109fd34195",
"tileid": "",
"data": {}
}
t = Tile(json)
t.save(index=False)
tiles = Tile.objects.filter(resourceinstance_id="40000000-0000-0000-0000-000000000000")
self.assertEqual(tiles.count(), 2)
def test_apply_provisional_edit(self):
"""
Tests that provisional edit data is properly created
"""
json = {
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "72048cb3-adbc-11e6-9ccf-14109fd34195",
"tileid": "",
"data": {
"72048cb3-adbc-11e6-9ccf-14109fd34195": "TEST 1"
}
}
user = User.objects.create_user(username='******', password='******')
provisional_tile = Tile(json)
request = HttpRequest()
request.user = user
provisional_tile.save(index=False, request=request)
provisional_tile.apply_provisional_edit(user, {"test":"test"}, 'update')
provisionaledits = JSONDeserializer().deserialize(provisional_tile.provisionaledits)
userid = str(user.id)
self.assertEqual(provisionaledits[userid]['action'], 'update')
self.assertEqual(provisionaledits[userid]['reviewer'], None)
self.assertEqual(provisionaledits[userid]['value'], {"test":"test"})
self.assertEqual(provisionaledits[userid]['status'], "review")
self.assertEqual(provisionaledits[userid]['reviewtimestamp'], None)
def test_tile_deletion(self):
"""
Tests that a tile is deleted when a user is a reviewer or owner.
"""
json = {
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "72048cb3-adbc-11e6-9ccf-14109fd34195",
"tileid": "",
"data": {
"72048cb3-adbc-11e6-9ccf-14109fd34195": "TEST 1"
}
}
owner = User.objects.create_user(username='******', password='******')
reviewer = User.objects.get(username='******')
tile1 = Tile(json)
owner_request = HttpRequest()
owner_request.user = owner
tile1.save(index=False, request=owner_request)
tile1.delete(request=owner_request)
tile2 = Tile(json)
reviewer_request = HttpRequest()
reviewer_request.user = reviewer
tile2.save(index=False, request=reviewer_request)
tile2.delete(request=reviewer_request)
self.assertEqual(len(Tile.objects.all()), 0)
def test_provisional_deletion(self):
"""
Tests that a tile is NOT deleted if a user does not have the
privlages to delete a tile and that the proper provisionaledit is
applied.
"""
json = {
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "72048cb3-adbc-11e6-9ccf-14109fd34195",
"tileid": "",
"data": {
"72048cb3-adbc-11e6-9ccf-14109fd34195": "TEST 1"
}
}
provisional_user = User.objects.create_user(username='******', password='******')
reviewer = User.objects.get(username='******')
tile = Tile(json)
reviewer_request = HttpRequest()
reviewer_request.user = reviewer
tile.save(index=False, request=reviewer_request)
provisional_request = HttpRequest()
provisional_request.user = provisional_user
tile.delete(request=provisional_request)
self.assertEqual(len(Tile.objects.all()), 1)
def push_edits_to_db(self):
# read all docs that have changes
# save back to postgres db
db = self.couch['project_' + str(self.id)]
ret = []
for row in db.view('_all_docs', include_docs=True):
ret.append(row)
if 'tileid' in row.doc:
tile = Tile(row.doc)
#if tile.filter_by_perm(request.user, 'write_nodegroup'):
with transaction.atomic():
tile.save()
#tile = models.TileModel.objects.get(pk=row.doc.tileid).update(**row.doc)
return ret
def test_save_provisional_from_athoritative(self):
"""
Test that a provisional edit is created when a user that is not a
reviewer edits an athoritative tile
"""
json = {
"tiles": {
"72048cb3-adbc-11e6-9ccf-14109fd34195": [{
"tiles": {},
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "72048cb3-adbc-11e6-9ccf-14109fd34195",
"tileid": "",
"data": {
"72048cb3-adbc-11e6-9ccf-14109fd34195": "AUTHORITATIVE"
}
}]
},
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "7204869c-adbc-11e6-8bec-14109fd34195",
"tileid": "",
"data": {}
}
t = Tile(json)
t.save(index=False)
self.user = User.objects.create_user(username='******', password='******')
login = self.client.login(username='******', password='******')
tiles = Tile.objects.filter(resourceinstance_id="40000000-0000-0000-0000-000000000000")
provisional_tile = None
for tile in tiles:
if "72048cb3-adbc-11e6-9ccf-14109fd34195" in tile.data:
provisional_tile = tile
provisional_tile.data["72048cb3-adbc-11e6-9ccf-14109fd34195"] = 'PROVISIONAL'
request = HttpRequest()
request.user = self.user
provisional_tile.save(index=False, request=request)
tiles = Tile.objects.filter(resourceinstance_id="40000000-0000-0000-0000-000000000000")
provisionaledits = JSONDeserializer().deserialize(provisional_tile.provisionaledits)
self.assertEqual(tiles.count(), 2)
self.assertEqual(provisional_tile.data["72048cb3-adbc-11e6-9ccf-14109fd34195"], 'AUTHORITATIVE')
self.assertEqual(provisionaledits[str(self.user.id)]['action'], 'update')
self.assertEqual(provisionaledits[str(self.user.id)]['status'], 'review')
def copy(self):
"""
Returns a copy of this resource instance includeing a copy of all tiles associated with this resource instance
"""
# need this here to prevent a circular import error
from arches.app.models.tile import Tile
id_map = {}
new_resource = Resource()
new_resource.graph = self.graph
if len(self.tiles) == 0:
self.tiles = Tile.objects.filter(resourceinstance=self)
for tile in self.tiles:
new_tile = Tile()
new_tile.data = tile.data
new_tile.nodegroup = tile.nodegroup
new_tile.parenttile = tile.parenttile
new_tile.resourceinstance = new_resource
new_tile.sortorder = tile.sortorder
new_resource.tiles.append(new_tile)
id_map[tile.pk] = new_tile
for tile in new_resource.tiles:
if tile.parenttile:
tile.parenttile = id_map[tile.parenttile_id]
with transaction.atomic():
new_resource.save()
return new_resource
def test_save(self):
"""
Test that we can save a Tile object back to the database
"""
json = {
"tiles": {
"19999999-0000-0000-0000-000000000000": [{
"tiles": {},
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "19999999-0000-0000-0000-000000000000",
"tileid": "",
"data": {
"20000000-0000-0000-0000-000000000004": "TEST 1",
"20000000-0000-0000-0000-000000000002": "TEST 2",
"20000000-0000-0000-0000-000000000003": "TEST 3"
}
}],
"32999999-0000-0000-0000-000000000000": [{
"tiles": {},
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "32999999-0000-0000-0000-000000000000",
"tileid": "",
"data": {
"20000000-0000-0000-0000-000000000004": "TEST 4",
"20000000-0000-0000-0000-000000000002": "TEST 5",
}
}]
},
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "20000000-0000-0000-0000-000000000001",
"tileid": "",
"data": {}
}
t = Tile(json)
t.save()
tiles = models.Tile.objects.filter(resourceinstance_id="40000000-0000-0000-0000-000000000000")
self.assertEqual(tiles.count(), 3)
def test_create_new_provisional(self):
"""
Test that a new provisional tile is created when a user IS NOT a reviwer
and that an authoritative tile is created when a user IS a reviwer.
"""
self.user = User.objects.get(username='******')
json = {
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "72048cb3-adbc-11e6-9ccf-14109fd34195",
"tileid": "",
"data": {
"72048cb3-adbc-11e6-9ccf-14109fd34195": "AUTHORITATIVE"
}
}
authoritative_tile = Tile(json)
request = HttpRequest()
request.user = self.user
authoritative_tile.save(index=False, request=request)
self.user = User.objects.create_user(username='******',
password='******')
json = {
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "72048cb3-adbc-11e6-9ccf-14109fd34195",
"tileid": "",
"data": {
"72048cb3-adbc-11e6-9ccf-14109fd34195": "PROVISIONAL"
}
}
provisional_tile = Tile(json)
request = HttpRequest()
request.user = self.user
provisional_tile.save(index=False, request=request)
self.assertEqual(provisional_tile.is_provisional(), True)
self.assertEqual(authoritative_tile.is_provisional(), False)
def test_load_from_python_dict(self):
"""
Test that we can initialize a Tile object from a Python dictionary
"""
json = {
"tiles": {
"19999999-0000-0000-0000-000000000000": [{
"tiles": {},
"resourceinstance_id":
"40000000-0000-0000-0000-000000000000",
"parenttile_id":
'',
"nodegroup_id":
"19999999-0000-0000-0000-000000000000",
"tileid":
"",
"data": {
"20000000-0000-0000-0000-000000000004": "TEST 1",
"20000000-0000-0000-0000-000000000002": "TEST 2",
"20000000-0000-0000-0000-000000000003": "TEST 3"
}
}],
"32999999-0000-0000-0000-000000000000": [{
"tiles": {},
"resourceinstance_id":
"40000000-0000-0000-0000-000000000000",
"parenttile_id":
'',
"nodegroup_id":
"32999999-0000-0000-0000-000000000000",
"tileid":
"",
"data": {
"20000000-0000-0000-0000-000000000004": "TEST 4",
"20000000-0000-0000-0000-000000000002": "TEST 5",
}
}]
},
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "20000000-0000-0000-0000-000000000001",
"tileid": "",
"data": {}
}
t = Tile(json)
subTiles = t.tiles["19999999-0000-0000-0000-000000000000"]
self.assertEqual(t.resourceinstance_id,
"40000000-0000-0000-0000-000000000000")
self.assertEqual(t.data, {})
self.assertEqual(
subTiles[0].data["20000000-0000-0000-0000-000000000004"], "TEST 1")
def import_business_data_without_mapping(self, business_data, reporter):
errors = []
for resource in business_data['resources']:
if resource['resourceinstance'] != None:
if models.GraphModel.objects.filter(graphid=str(
resource['resourceinstance']['graph_id'])).count() > 0:
resourceinstance, created = ResourceInstance.objects.update_or_create(
resourceinstanceid=uuid.UUID(
str(resource['resourceinstance']
['resourceinstanceid'])),
defaults={
'graph_id':
uuid.UUID(
str(resource['resourceinstance']['graph_id'])),
'legacyid':
resource['resourceinstance']['legacyid']
})
if len(
ResourceInstance.objects.filter(
resourceinstanceid=resource['resourceinstance']
['resourceinstanceid'])) == 1:
reporter.update_resources_saved()
if resource['tiles'] != []:
reporter.update_tiles(len(resource['tiles']))
for tile in sorted(
resource['tiles'],
key=lambda k: k['parenttile_id']):
tile['parenttile_id'] = uuid.UUID(
str(tile['parenttile_id'])
) if tile['parenttile_id'] else None
tile, created = Tile.objects.update_or_create(
tileid=uuid.UUID(str(tile['tileid'])),
defaults={
'resourceinstance':
resourceinstance,
'parenttile':
Tile(
uuid.UUID(
str(tile['parenttile_id'])))
if tile['parenttile_id'] else None,
'nodegroup':
NodeGroup(
uuid.UUID(str(
tile['nodegroup_id'])))
if tile['nodegroup_id'] else None,
'data':
tile['data']
})
if len(Tile.objects.filter(
tileid=tile.tileid)) == 1:
errors = tile.validate(self.errors)
reporter.update_tiles_saved()
def get_nodegroup_tilegroup(v4_node_name, nodes, resource_id, verbose=False):
# get the corresponding v4 node and then get the tile for its nodegroup
v4_node = nodes.get(name=v4_node_name)
ng_tile = Tile().get_blank_tile(v4_node.nodegroup_id,
resourceid=resource_id)
if verbose:
print " ", ng_tile.data
print " ", ng_tile.tiles
# if there are child tiles, then the ng_tile.tileid needs to be set
# (not sure why this is the case, but it is)
if ng_tile.tileid is None:
ng_tile.tileid = uuid.uuid4()
# create a raw json representation of the node group tile and its children
# and put these into a flat list of tiles that is returned
tile_json = {
"resourceinstance_id": resource_id,
"provisionaledits": None,
"parenttile_id": ng_tile.parenttile_id,
"nodegroup_id": ng_tile.nodegroup_id,
"sortorder": 0,
"data": ng_tile.data,
"tileid": ng_tile.tileid,
}
output_tiles = [tile_json]
for tile in ng_tile.tiles:
child_tile_json = {
"tileid": tile.tileid,
"resourceinstance_id": resource_id,
"nodegroup_id": tile.nodegroup_id,
"sortorder": 0,
"provisionaledits": None,
"parenttile_id": ng_tile.tileid,
"data": tile.data,
}
output_tiles.append(child_tile_json)
return output_tiles
def test_apply_provisional_edit(self):
"""
Tests that provisional edit data is properly created
"""
json = {
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": "",
"nodegroup_id": "72048cb3-adbc-11e6-9ccf-14109fd34195",
"tileid": "",
"data": {
"72048cb3-adbc-11e6-9ccf-14109fd34195": "TEST 1"
},
}
user = User.objects.create_user(username="******",
password="******")
provisional_tile = Tile(json)
request = HttpRequest()
request.user = user
provisional_tile.save(index=False, request=request)
provisional_tile.apply_provisional_edit(user, {"test": "test"},
"update")
provisionaledits = provisional_tile.provisionaledits
userid = str(user.id)
self.assertEqual(provisionaledits[userid]["action"], "update")
self.assertEqual(provisionaledits[userid]["reviewer"], None)
self.assertEqual(provisionaledits[userid]["value"], {"test": "test"})
self.assertEqual(provisionaledits[userid]["status"], "review")
self.assertEqual(provisionaledits[userid]["reviewtimestamp"], None)
def copy(self):
"""
Returns a copy of this resource instance includeing a copy of all tiles associated with this resource instance
"""
# need this here to prevent a circular import error
from arches.app.models.tile import Tile
id_map = {}
new_resource = Resource()
new_resource.graph = self.graph
if len(self.tiles) == 0:
self.tiles = Tile.objects.filter(resourceinstance=self)
for tile in self.tiles:
new_tile = Tile()
new_tile.data = tile.data
new_tile.nodegroup = tile.nodegroup
new_tile.parenttile = tile.parenttile
new_tile.resourceinstance = new_resource
new_tile.sortorder = tile.sortorder
new_resource.tiles.append(new_tile)
id_map[tile.pk] = new_tile
for tile in new_resource.tiles:
if tile.parenttile:
tile.parenttile = id_map[tile.parenttile_id]
with transaction.atomic():
new_resource.save()
return new_resource
def test_apply_provisional_edit(self):
"""
Tests that provisional edit data is properly created
"""
json = {
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "72048cb3-adbc-11e6-9ccf-14109fd34195",
"tileid": "",
"data": {
"72048cb3-adbc-11e6-9ccf-14109fd34195": "TEST 1"
}
}
user = User.objects.create_user(username='******',
password='******')
provisional_tile = Tile(json)
request = HttpRequest()
request.user = user
provisional_tile.save(index=False, request=request)
provisional_tile.apply_provisional_edit(user, {"test": "test"},
'update')
provisionaledits = JSONDeserializer().deserialize(
provisional_tile.provisionaledits)
userid = str(user.id)
self.assertEqual(provisionaledits[userid]['action'], 'update')
self.assertEqual(provisionaledits[userid]['reviewer'], None)
self.assertEqual(provisionaledits[userid]['value'], {"test": "test"})
self.assertEqual(provisionaledits[userid]['status'], "review")
self.assertEqual(provisionaledits[userid]['reviewtimestamp'], None)
def test_provisional_deletion(self):
"""
Tests that a tile is NOT deleted if a user does not have the
privlages to delete a tile and that the proper provisionaledit is
applied.
"""
json = {
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "72048cb3-adbc-11e6-9ccf-14109fd34195",
"tileid": "",
"data": {
"72048cb3-adbc-11e6-9ccf-14109fd34195": "TEST 1"
}
}
provisional_user = User.objects.create_user(
username='******', password='******')
reviewer = User.objects.get(username='******')
tile = Tile(json)
reviewer_request = HttpRequest()
reviewer_request.user = reviewer
tile.save(index=False, request=reviewer_request)
provisional_request = HttpRequest()
provisional_request.user = provisional_user
tile.delete(request=provisional_request)
self.assertEqual(len(Tile.objects.all()), 1)
def get_blank_tile(sourcetilegroup):
if len(sourcetilegroup[0]['data']) > 0:
if sourcetilegroup[0]['data'][0] != {}:
if sourcetilegroup[0]['data'][0].keys()[0] not in blanktilecache:
blank_tile = Tile.get_blank_tile(tiles[0]['data'][0].keys()[0], resourceid=resourceinstanceid)
cache(blank_tile)
else:
blank_tile = blanktilecache[tiles[0]['data'][0].keys()[0]]
else:
blank_tile = None
else:
blank_tile = None
return blank_tile
def test_save(self):
"""
Test that we can save a Tile object back to the database
"""
login = self.client.login(username='******', password='******')
json = {
"tiles": {
"72048cb3-adbc-11e6-9ccf-14109fd34195": [{
"tiles": {},
"resourceinstance_id":
"40000000-0000-0000-0000-000000000000",
"parenttile_id":
'',
"nodegroup_id":
"72048cb3-adbc-11e6-9ccf-14109fd34195",
"tileid":
"",
"data": {
"72048cb3-adbc-11e6-9ccf-14109fd34195": "TEST 1"
}
}]
},
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "7204869c-adbc-11e6-8bec-14109fd34195",
"tileid": "",
"data": {}
}
t = Tile(json)
t.save(index=False)
tiles = Tile.objects.filter(
resourceinstance_id="40000000-0000-0000-0000-000000000000")
self.assertEqual(tiles.count(), 2)
def test_user_owns_provisional(self):
"""
Tests that a user is the owner of a provisional edit
"""
json = {
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "72048cb3-adbc-11e6-9ccf-14109fd34195",
"tileid": "",
"data": {
"72048cb3-adbc-11e6-9ccf-14109fd34195": "TEST 1"
}
}
user = User.objects.create_user(username='******', password='******')
provisional_tile = Tile(json)
request = HttpRequest()
request.user = user
provisional_tile.save(index=False, request=request)
self.assertEqual(provisional_tile.user_owns_provisional(user), True)
def test_simple_get(self):
"""
Test that we can get a Tile object
"""
json = {
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "72048cb3-adbc-11e6-9ccf-14109fd34195",
"tileid": "",
"data": {
"72048cb3-adbc-11e6-9ccf-14109fd34195": "TEST 1"
}
}
t = Tile(json)
t.save(index=False)
t2 = Tile.objects.get(tileid=t.tileid)
self.assertEqual(t.tileid, t2.tileid)
self.assertEqual(t2.data["72048cb3-adbc-11e6-9ccf-14109fd34195"], "TEST 1")
def test_get_not_existing_value_from_concept(self):
"""
Query a concept node without a value
"""
test_resource_no_value = Resource(graph_id=self.search_model_graphid)
tile = Tile(data={self.search_model_cultural_period_nodeid: ""}, nodegroup_id=self.search_model_cultural_period_nodeid)
test_resource_no_value.tiles.append(tile)
test_resource_no_value.save()
node_name = "Cultural Period Concept"
result = test_resource_no_value.get_node_values(node_name)
self.assertEqual(None, result[0])
test_resource_no_value.delete()
def test_user_owns_provisional(self):
"""
Tests that a user is the owner of a provisional edit
"""
json = {
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "72048cb3-adbc-11e6-9ccf-14109fd34195",
"tileid": "",
"data": {
"72048cb3-adbc-11e6-9ccf-14109fd34195": "TEST 1"
}
}
user = User.objects.create_user(username='******', password='******')
provisional_tile = Tile(json)
request = HttpRequest()
request.user = user
provisional_tile.save(index=False, request=request)
self.assertEqual(provisional_tile.user_owns_provisional(user), True)
def test_simple_get(self):
"""
Test that we can get a Tile object
"""
json = {
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "72048cb3-adbc-11e6-9ccf-14109fd34195",
"tileid": "",
"data": {
"72048cb3-adbc-11e6-9ccf-14109fd34195": "TEST 1"
}
}
t = Tile(json)
t.save(index=False)
t2 = Tile.objects.get(tileid=t.tileid)
self.assertEqual(t.tileid, t2.tileid)
self.assertEqual(t2.data["72048cb3-adbc-11e6-9ccf-14109fd34195"], "TEST 1")
def update_or_create_tile(src_tile):
tile = None
src_tile["parenttile_id"] = uuid.UUID(
str(src_tile["parenttile_id"])
) if src_tile["parenttile_id"] else None
defaults = {
"resourceinstance":
resourceinstance,
"parenttile_id":
str(src_tile["parenttile_id"])
if src_tile["parenttile_id"] else None,
"nodegroup_id":
str(src_tile["nodegroup_id"])
if src_tile["nodegroup_id"] else None,
"data":
src_tile["data"],
}
new_values = {
"tileid": uuid.UUID(str(src_tile["tileid"]))
}
new_values.update(defaults)
if overwrite == "overwrite":
tile = Tile(**new_values)
else:
try:
tile = Tile.objects.get(tileid=uuid.UUID(
str(src_tile["tileid"])))
for key, value in defaults.items():
setattr(tile, key, value)
except Tile.DoesNotExist:
tile = Tile(**new_values)
if tile is not None:
resourceinstance.tiles.append(tile)
reporter.update_tiles_saved()
for child in src_tile["tiles"]:
update_or_create_tile(child)
def post(self, request):
member_of_set_nodegroup_id = "63e49254-c444-11e9-afbe-a4d18cec433a"
related_resource_id = request.POST.get("relatedresourceid")
data = JSONDeserializer().deserialize(request.POST.get("data"))
nodegroup_id = request.POST.get("nodegroupid", member_of_set_nodegroup_id)
node_id = request.POST.get("node_id", member_of_set_nodegroup_id)
transaction_id = request.POST.get("transactionid", None)
try:
with transaction.atomic():
for datum in data:
action = datum["action"]
resource_id = datum["resourceid"] if "resourceid" in datum else None
tile_id = datum["tileid"] if "tileid" in datum else None
related_resource_template = {
"resourceId": "",
"ontologyProperty": "",
"resourceXresourceId": "",
"inverseOntologyProperty": "",
}
if tile_id is not None:
tile = Tile.objects.get(pk=tile_id)
else:
try:
tile = Tile.objects.get(resourceinstance=resource_id, nodegroup=nodegroup_id)
except ObjectDoesNotExist as e:
tile = Tile.get_blank_tile(nodeid=node_id, resourceid=resource_id)
tile.data[node_id] = []
list_of_rr_resources = [data["resourceId"] for data in tile.data[node_id]]
if related_resource_id not in list_of_rr_resources and action == "add":
related_resource_template["resourceId"] = related_resource_id
tile.data[node_id].append(related_resource_template)
tile.save(transaction_id=transaction_id)
elif related_resource_id in list_of_rr_resources and action == "remove":
rr_data = tile.data[node_id]
tile.data[node_id] = [rr for rr in rr_data if rr["resourceId"] != related_resource_id]
tile.save(transaction_id=transaction_id)
return JSONResponse({"result": "success"})
except Exception as e:
logger.exception(e)
response = {"result": "failed", "message": [_("Request Failed"), _("Unable to save")]}
return JSONResponse(response, status=500)
def get_blank_tile(source_data):
if len(source_data) > 0:
if source_data[0] != {}:
key = str(source_data[0].keys()[0])
if key not in blanktilecache:
blank_tile = Tile.get_blank_tile(key)
cache(blank_tile)
else:
blank_tile = blanktilecache[key]
else:
blank_tile = None
else:
blank_tile = None
# return deepcopy(blank_tile)
return cPickle.loads(cPickle.dumps(blank_tile, -1))
def test_validation(self):
"""
Test that we can get a Tile object
"""
json = {
"tiles": {},
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "20000000-0000-0000-0000-000000000001",
"tileid": "",
"data": {
"20000000-0000-0000-0000-000000000004": "TEST 1"
}
}
t = Tile(json)
self.assertTrue(t.validate()['is_valid'])
json['data']['20000000-0000-0000-0000-000000000004'] = ''
t2 = Tile(json)
self.assertFalse(t2.validate()['is_valid'])
def test_simple_get(self):
"""
Test that we can get a Tile object
"""
json = {
"tiles": {},
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "20000000-0000-0000-0000-000000000001",
"tileid": "",
"data": {
"20000000-0000-0000-0000-000000000004": "TEST 1"
}
}
t = Tile(json)
t.save()
t2 = Tile.get(tileid=t.tileid)
self.assertEqual(t.tileid, t2.tileid)
self.assertEqual(t2.data["20000000-0000-0000-0000-000000000004"], "TEST 1")
def get_blank_tile(source_data):
if len(source_data) > 0:
if source_data[0] != {}:
key = str(source_data[0].keys()[0])
if key not in blanktilecache:
blank_tile = Tile.get_blank_tile(key)
cache(blank_tile)
else:
blank_tile = blanktilecache[key]
else:
blank_tile = None
else:
blank_tile = None
# return deepcopy(blank_tile)
return cPickle.loads(cPickle.dumps(blank_tile, -1))
def test_create_new_authoritative(self):
"""
Test that a new authoritative tile is created when a user IS a reviwer.
"""
self.user = User.objects.get(username="******")
json = {
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": "",
"nodegroup_id": "72048cb3-adbc-11e6-9ccf-14109fd34195",
"tileid": "",
"data": {
"72048cb3-adbc-11e6-9ccf-14109fd34195": "AUTHORITATIVE"
},
}
authoritative_tile = Tile(json)
request = HttpRequest()
request.user = self.user
authoritative_tile.save(index=False, request=request)
self.assertEqual(authoritative_tile.is_provisional(), False)
def test_load_from_JSON(self):
"""
Test that we can initialize a Tile object from JSON
"""
json = '{"tiles": {"99999999-0000-0000-0000-000000000000": [], "99999999-0000-0000-0000-000000000001": [{"parenttile_id": null, "nodegroup_id": "99999999-0000-0000-0000-000000000001", "resourceinstance_id": "40000000-0000-0000-0000-000000000000", "tileid": "985da56d-316a-4f2e-8759-8e17b6cad918", "data": {"20000000-0000-0000-0000-000000000004": "TEST 2", "20000000-0000-0000-0000-000000000002": "TEST 1"}}]}, "resourceinstance_id": "40000000-0000-0000-0000-000000000000", "parenttile_id": null, "nodegroup_id": "21111111-0000-0000-0000-000000000000", "tileid": "", "data": null}'
t = Tile(json)
subTiles = t.tiles["99999999-0000-0000-0000-000000000001"]
self.assertEqual(t.resourceinstance_id,
"40000000-0000-0000-0000-000000000000")
self.assertEqual(t.data, {})
self.assertEqual(
subTiles[0].data["20000000-0000-0000-0000-000000000002"], "TEST 1")
def get_blank_tile(sourcetilegroup):
if len(sourcetilegroup[0]['data']) > 0:
if sourcetilegroup[0]['data'][0] != {}:
if sourcetilegroup[0]['data'][0].keys(
)[0] not in blanktilecache:
blank_tile = Tile.get_blank_tile(
tiles[0]['data'][0].keys()[0],
resourceid=resourceinstanceid)
cache(blank_tile)
else:
blank_tile = blanktilecache[
tiles[0]['data'][0].keys()[0]]
else:
blank_tile = None
else:
blank_tile = None
return blank_tile
def get_blank_tile(self, sourcetilegroup, blanktilecache, tiles, resourceinstanceid):
if len(sourcetilegroup[0]["data"]) > 0:
if sourcetilegroup[0]["data"][0] != {}:
if list(sourcetilegroup[0]["data"][0].keys())[0] not in blanktilecache:
blank_tile = Tile.get_blank_tile(list(tiles[0]["data"][0].keys())[0], resourceid=resourceinstanceid)
if blank_tile.data != {}:
for tile in blank_tile.tiles:
if isinstance(tile, Tile):
for key in list(tile.data.keys()):
blanktilecache[key] = blank_tile
else:
blank_tile = blanktilecache[list(tiles[0]["data"][0].keys())[0]]
else:
blank_tile = None
else:
blank_tile = None
return blank_tile
def get_blank_tile(self, sourcetilegroup, blanktilecache, tiles, resourceinstanceid):
if len(sourcetilegroup[0]['data']) > 0:
if sourcetilegroup[0]['data'][0] != {}:
if sourcetilegroup[0]['data'][0].keys()[0] not in blanktilecache:
blank_tile = Tile.get_blank_tile(tiles[0]['data'][0].keys()[0], resourceid=resourceinstanceid)
if blank_tile.data != {}:
for tile in blank_tile.tiles.values():
if isinstance(tile, Tile):
for key in tile.data.keys():
blanktilecache[key] = blank_tile
else:
blank_tile = blanktilecache[tiles[0]['data'][0].keys()[0]]
else:
blank_tile = None
else:
blank_tile = None
return blank_tile
def test_create_new_provisional(self):
"""
Test that a new provisional tile is created when a user IS NOT a reviwer
and that an authoritative tile is created when a user IS a reviwer.
"""
self.user = User.objects.get(username='******')
json = {
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "72048cb3-adbc-11e6-9ccf-14109fd34195",
"tileid": "",
"data": {
"72048cb3-adbc-11e6-9ccf-14109fd34195": "AUTHORITATIVE"
}
}
authoritative_tile = Tile(json)
request = HttpRequest()
request.user = self.user
authoritative_tile.save(index=False, request=request)
self.user = User.objects.create_user(username='******', password='******')
json = {
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "72048cb3-adbc-11e6-9ccf-14109fd34195",
"tileid": "",
"data": {
"72048cb3-adbc-11e6-9ccf-14109fd34195": "PROVISIONAL"
}
}
provisional_tile = Tile(json)
request = HttpRequest()
request.user = self.user
provisional_tile.save(index=False, request=request)
self.assertEqual(provisional_tile.is_provisional(), True)
self.assertEqual(authoritative_tile.is_provisional(), False)
def handle(self, *args, **options):
if options["set_empty"]:
value = None
elif options["set_value"]:
value = options["set_value"]
try:
id = uuid.UUID(options["node"])
nodes = Node.objects.filter(nodeid=id)
except ValueError:
nodes = Node.objects.filter(name=options["node"])
if len(nodes) == 0:
print("cancelling, no nodes match this name.")
exit()
elif len(nodes) > 1:
print("multiple nodes match this name:")
for node in nodes:
print(f"{node.name} - {node.pk} - {node.graph.name}")
print("\nAll of these nodes will be updated. To choose a specific "\
"one, rerun this command using the node id instead of name.")
if not input("\nproceed? y/N ").lower().startswith("y"):
print("cancelled")
exit()
for node in nodes:
print(f"{node.name} - {node.pk} - {node.graph.name}")
tiles = Tile.objects.filter(nodegroup_id=node.nodegroup)
nodeid = str(node.pk)
for t in tiles:
old_value = t.data.get(nodeid, "<no previously saved value>")
if options["set_empty"] or options["set_value"]:
if options["set_empty"]:
new_value = None
elif options["set_value"]:
new_value = options["set_value"]
Tile().update_node_value(nodeid, new_value, tileid=t.tileid)
print(f"{t.resourceinstance_id}: {old_value} --> {new_value}")
else:
print(f"{t.resourceinstance_id}: {old_value}")
print(f" tiles: {tiles.count()}")
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)
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)
return JSONResponse(tile)
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)
t.sortorder = sortorder
t.save(update_fields=['sortorder'], request=request)
sortorder = sortorder + 1
return JSONResponse(data)
return HttpResponseNotFound()
def post(self, request):
datatype_factory = DataTypeFactory()
tileid = request.POST.get("tileid")
nodeid = request.POST.get("nodeid")
data = request.POST.get("data")
resourceid = request.POST.get("resourceinstanceid", None)
try:
node = models.Node.objects.get(nodeid=nodeid)
datatype = datatype_factory.get_instance(node.datatype)
except Exception as e:
return JSONResponse(e)
data = datatype.process_api_data(data)
new_tile = tile_model.update_node_value(nodeid,
data,
tileid,
resourceinstanceid=resourceid)
response = JSONResponse(new_tile)
return response
def post(self, request):
if self.action == 'update_tile':
json = request.POST.get('data', None)
if json != None:
data = JSONDeserializer().deserialize(json)
tile = Tile(data)
with transaction.atomic():
try:
tile.save(request=request)
except ValidationError as e:
return JSONResponse(
{
'status': 'false',
'message': e.args
}, status=500)
return JSONResponse(tile)
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)
t.sortorder = sortorder
t.save(update_fields=['sortorder'],
request=request)
sortorder = sortorder + 1
return JSONResponse(data)
return HttpResponseNotFound()
def update_or_create_tile(src_tile):
src_tile['parenttile_id'] = uuid.UUID(str(src_tile['parenttile_id'])) if src_tile[
'parenttile_id'] else None
tile, created = Tile.objects.update_or_create(
tileid=uuid.UUID(str(src_tile['tileid'])),
defaults={
'resourceinstance': resourceinstance,
'parenttile': Tile(uuid.UUID(str(src_tile['parenttile_id'])))
if src_tile['parenttile_id'] else None,
'nodegroup': NodeGroup(uuid.UUID(str(src_tile['nodegroup_id'])))
if src_tile['nodegroup_id'] else None,
'data': src_tile['data']
}
)
if len(Tile.objects.filter(tileid=tile.tileid)) == 1:
errors = tile.validate(self.errors)
reporter.update_tiles_saved()
for child in src_tile['tiles']:
update_or_create_tile(child)
def post_save(self, tile, request):
tile_already_exists = models.TileModel.objects.filter(
resourceinstance_id=tile.resourceinstance_id).filter(
nodegroup_id=self.config["selected_nodegroup"]).exists()
if not tile_already_exists:
try:
if int(self.config['last_value']) == 0:
new_number = str(
int(self.config['starting_value']) +
int(self.config['last_value']) + 1)
else:
new_number = str(int(self.config['last_value']) + 1)
new_value = self.config['prefix'] + (
(7 - len(new_number)) * '0') + new_number + self.config[
'suffix'] #EAMENA numbers are 7 digits long
fn = models.FunctionXGraph.objects.get(
Q(function_id="2cc07b0a-adbd-4721-86ce-dad1699caa86"),
Q(graph_id=tile.resourceinstance.graph_id))
fn.config['last_value'] = new_number
fn.save()
nodegroup_id = self.config["selected_nodegroup"]
target_node = self.config['target_node']
nodegroup = models.NodeGroup.objects.get(pk=nodegroup_id)
if tile.nodegroup.nodegroupid == nodegroup.nodegroupid:
tile.data[target_node] = new_value
return
if nodegroup.parentnodegroup_id == tile.nodegroup.nodegroupid:
return
else:
tile = Tile.update_node_value(
target_node,
new_value,
nodegroupid=nodegroup_id,
resourceinstanceid=tile.resourceinstance_id)
except Exception:
logger.exception(
"The incrementor function is unable to create incremented value"
)
def test_validation(self):
"""
Test that we can get a Tile object
"""
json = {
"tiles": {},
"resourceinstance_id": "40000000-0000-0000-0000-000000000000",
"parenttile_id": '',
"nodegroup_id": "20000000-0000-0000-0000-000000000001",
"tileid": "",
"data": {
"20000000-0000-0000-0000-000000000004": "TEST 1"
}
}
t = Tile(json)
self.assertTrue(t.validate()['is_valid'])
json['data']['20000000-0000-0000-0000-000000000004'] = ''
t2 = Tile(json)
self.assertFalse(t2.validate()['is_valid'])
def push_edits_to_db(self, synclog=None, userid=None):
# read all docs that have changes
# save back to postgres db
db = self.couch.create_db("project_" + str(self.id))
user_lookup = {}
is_reviewer = False
sync_user = None
sync_user_id = None
if userid is not None:
sync_user = User.objects.get(pk=userid)
sync_user_id = str(sync_user.id)
with transaction.atomic():
couch_docs = self.couch.all_docs(db)
for row in couch_docs:
if row.doc["type"] == "resource":
if self.check_if_revision_exists(row.doc) is False:
if "provisional_resource" in row.doc and row.doc[
"provisional_resource"] == "true":
resourceinstance, created = ResourceInstance.objects.update_or_create(
resourceinstanceid=uuid.UUID(
str(row.doc["resourceinstanceid"])),
defaults=dict(graph_id=uuid.UUID(
str(row.doc["graph_id"]))),
)
if created is True:
self.save_revision_log(row.doc, synclog,
"create")
else:
self.save_revision_log(row.doc, synclog,
"update")
print("Resource {0} Saved".format(
row.doc["resourceinstanceid"]))
else:
print("{0}: already saved".format(row.doc["_rev"]))
for row in couch_docs:
if row.doc[
"type"] == "tile" and ResourceInstance.objects.filter(
pk=row.doc["resourceinstance_id"]).exists():
if self.check_if_revision_exists(row.doc) is False:
if "provisionaledits" in row.doc and row.doc[
"provisionaledits"] is not None:
action = "update"
try:
tile = Tile.objects.get(
tileid=row.doc["tileid"])
prov_edit = self.get_provisional_edit(
row.doc, tile, sync_user_id, db)
if prov_edit is not None:
tile.data = prov_edit
# If there are conflicting documents, lets clear those out
if "_conflicts" in row.doc:
for conflict_rev in row.doc["_conflicts"]:
conflict_data = db.get(
row.id, rev=conflict_rev)
if conflict_data[
"provisionaledits"] != "" and conflict_data[
"provisionaledits"] is not None:
if sync_user_id in conflict_data[
"provisionaledits"]:
tile.data = conflict_data[
"provisionaledits"][
sync_user_id]["value"]
# Remove conflicted revision from couch
db.delete(conflict_data)
except Tile.DoesNotExist:
action = "create"
tile = Tile(row.doc)
prov_edit = self.get_provisional_edit(
row.doc, tile, sync_user_id, db)
if prov_edit is not None:
tile.data = prov_edit
self.handle_reviewer_edits(sync_user, tile)
tile.save(user=sync_user)
self.save_revision_log(row.doc, synclog, action)
print("Tile {0} Saved".format(row.doc["tileid"]))
db.compact()
def load(self, resourceid, formid=None, user=None):
tiles = Tile.objects.filter(
resourceinstance_id=resourceid).order_by('sortorder')
# get the form and card data
if formid is not None:
form = models.Form.objects.get(pk=formid)
formxcards = form.formxcard_set.all()
form_obj = {
'id': form.pk,
'title': form.title,
'subtitle': form.subtitle
}
form_obj['cardgroups'] = []
for formxcard in formxcards:
card = Card.objects.get(cardid=formxcard.card_id)
if card.filter_by_perm(user, 'read_nodegroup'):
card_obj = JSONSerializer().serializeToPython(card)
form_obj['cardgroups'].append(card_obj)
self.forms = [form_obj]
# get the actual tile data
for form in self.forms:
for cardgroup in form['cardgroups']:
self.tiles[cardgroup['nodegroup_id']] = JSONSerializer(
).serializeToPython(
tiles.filter(nodegroup_id=cardgroup['nodegroup_id']))
if len(self.tiles[cardgroup['nodegroup_id']]) > 0:
for parentTile in self.tiles[cardgroup['nodegroup_id']]:
parentTile['tiles'] = {}
for card in cardgroup['cards']:
parentTile['tiles'][card['nodegroup_id']] = []
for tile in JSONSerializer().serializeToPython(
tiles.filter(
parenttile_id=parentTile['tileid'])):
# only append tiles that havn't been filtered out by user permissions
if str(tile['nodegroup_id']
) in parentTile['tiles']:
parentTile['tiles'][str(
tile['nodegroup_id'])].append(tile)
# get the blank tile data
for form in self.forms:
for cardgroup in form['cardgroups']:
# add blank parent tile
parentTile = JSONSerializer().serializeToPython(Tile())
parentTile['tileid'] = ''
parentTile['parenttile_id'] = None
parentTile['resourceinstance_id'] = resourceid
parentTile['nodegroup_id'] = cardgroup['nodegroup_id']
parentTile['tiles'] = {}
parentTile['data'] = {}
for widget in cardgroup['widgets']:
parentTile['data'][widget['node_id']] = None
# add a blank tile for the cardgroup
self.blanks[parentTile['nodegroup_id']] = [parentTile]
for card in cardgroup['cards']:
# make a blank tile
tile = JSONSerializer().serializeToPython(Tile())
tile['tileid'] = ''
tile['parenttile_id'] = None # parentTile
tile['resourceinstance_id'] = resourceid
tile['nodegroup_id'] = card['nodegroup_id']
tile['tiles'] = {}
tile['data'] = {}
for widget in card['widgets']:
tile['data'][widget['node_id']] = None
if (card['cardinality'] == '1'):
parentTile['tiles'][card['nodegroup_id']] = [tile]
else:
parentTile['tiles'][card['nodegroup_id']] = []
# add a blank tile for each card
self.blanks[tile['nodegroup_id']] = [tile]
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 != None:
accepted_provisional_edit = JSONDeserializer().deserialize(
accepted_provisional)
if json != None:
data = JSONDeserializer().deserialize(json)
if data['resourceinstance_id'] == '':
data['resourceinstance_id'] = uuid.uuid4()
try:
models.ResourceInstance.objects.get(
pk=data['resourceinstance_id'])
except ObjectDoesNotExist:
resource = Resource()
graphid = models.Node.objects.filter(
nodegroup=data['nodegroup_id'])[0].graph_id
resource.graph_id = graphid
resource.save(user=request.user)
data['resourceinstance_id'] = resource.pk
resource.index()
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:
if accepted_provisional == None:
tile.save(request=request)
else:
if accepted_provisional is not None:
provisional_editor = User.objects.get(
pk=accepted_provisional_edit["user"])
tile.save(
provisional_edit_log_details={
"user": request.user,
"action": "accept edit",
"edit": accepted_provisional_edit,
"provisional_editor":
provisional_editor
})
if tile_id == '4345f530-aa90-48cf-b4b3-92d1185ca439':
import couchdb
import json as json_json
couch = couchdb.Server(settings.COUCHDB_URL)
for project in models.MobileSurveyModel.objects.all(
):
db = couch['project_' + str(project.id)]
#tile = models.TileModel.objects.get(pk='4345f530-aa90-48cf-b4b3-92d1185ca439')
tile_json = json_json.loads(
JSONSerializer().serialize(tile))
tile_json['_id'] = tile_json['tileid']
for row in db.view('_all_docs',
include_docs=True):
if 'tileid' in row.doc and tile_json[
'_id'] == row.doc['_id']:
tile_json['_rev'] = row.doc['_rev']
db.save(tile_json)
if tile.provisionaledits is not None and str(
request.user.id) in tile.provisionaledits:
tile.data = tile.provisionaledits[str(
request.user.id)]['value']
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)
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, reviewer=request.user)
elif tileid is not None and users is not None:
users = jsonparser.loads(users)
for user in users:
self.delete_provisional_edit(tile,
user,
reviewer=request.user)
if is_provisional == True:
return JSONResponse({'result': 'delete'})
else:
return JSONResponse({'result': 'success'})
return HttpResponseNotFound()
def data_walk(self, data_node, tree_node, result, tile=None):
for k, v in data_node.items():
if k in ["@id", "@type"]:
continue
# always a list
for vi in v:
if "@value" in vi:
# We're a literal value
value = vi["@value"]
clss = vi.get(
"@type",
"http://www.w3.org/2000/01/rdf-schema#Literal")
uri = None
is_literal = True
else:
# We're an entity
uri = vi.get("@id", "")
try:
clss = vi["@type"][0]
except:
# {"@id": "http://something/.../"}
# with no @type. This is typically an external concept URI
# Look for it in the children of current node
possible_cls = []
for tn in tree_node["children"]:
if tn.startswith(k):
possible_cls.append(tn.replace(k, "")[1:])
if len(possible_cls) == 1:
clss = possible_cls[0]
else:
raise ValueError(
f"Multiple possible branches and no @type given: {vi}"
)
value = None
is_literal = False
# Find precomputed possible branches by prop/class combination
key = f"{k} {clss}"
if key in tree_node["datatype"].ignore_keys():
# these are handled by the datatype itself
continue
elif not key in tree_node["children"] and is_literal:
# grumble grumble
# model has xsd:string, default is rdfs:Literal
key = f"{k} http://www.w3.org/2001/XMLSchema#string"
if not key in tree_node["children"]:
raise ValueError(
f"property/class combination does not exist in model: {k} {clss}"
)
elif not key in tree_node["children"]:
raise ValueError(
f"property/class combination does not exist in model: {k} {clss}"
)
options = tree_node["children"][key]
possible = []
ignore = []
for o in options:
# print(f"Considering:\n {vi}\n {o['name']}")
if is_literal and o["datatype"].is_a_literal_in_rdf():
if len(o["datatype"].validate(value)) == 0:
possible.append([o, value])
else:
print(
f"Could not validate {value} as a {o['datatype']}"
)
elif not is_literal and not o[
"datatype"].is_a_literal_in_rdf():
if self.is_concept_node(uri):
collid = o["config"]["collection_id"]
try:
if self.validate_concept_in_collection(
uri, collid):
possible.append([o, uri])
else:
print(
f"Concept URI {uri} not in Collection {collid}"
)
except:
print(
f"Errored testing concept {uri} in collection {collid}"
)
elif self.is_semantic_node(o):
possible.append([o, ""])
elif o["datatype"].accepts_rdf_uri(uri):
# print(f"datatype for {o['name']} accepts uri")
possible.append([o, uri])
else:
# This is when the current option doesn't match, but could be
# non-ambiguous resource-instance vs semantic node
continue
else:
raise ValueError("No possible match?")
# print(f"Possible is: {[x[0]['name'] for x in possible]}")
if not possible:
# print(f"Tried: {options}")
raise ValueError(
f"Data does not match any actual node, despite prop/class combination {k} {clss}:\n{vi}"
)
elif len(possible) > 1:
# descend into data to check if there are further clarifying features
possible2 = []
for p in possible:
try:
# Don't really create data, so pass anonymous result dict
self.data_walk(vi, p[0], {}, tile)
possible2.append(p)
except:
# Not an option
pass
if not possible2:
raise ValueError(
"Considering branches, data does not match any node, despite a prop/class combination"
)
elif len(possible2) > 1:
raise ValueError(
f"Even after considering branches, data still matches more than one node: {[x[0]['name'] for x in possible2]}"
)
else:
branch = possible2[0]
else:
branch = possible[0]
if not self.is_semantic_node(branch[0]):
graph_node = branch[0]
node_value = graph_node["datatype"].from_rdf(vi)
# We know now that it can go into the branch
# Determine if we can collapse the data into a -list or not
bnodeid = branch[0]["node_id"]
create_new_tile = False
if branch[0]["node_id"] == branch[0]["nodegroup_id"]:
create_new_tile = True
bnode = {
"data": [],
"nodegroup_id": branch[0]["nodegroup_id"],
"cardinality": branch[0]["cardinality"]
}
if create_new_tile:
parenttile_id = tile.tileid if tile else None
tile = Tile(
tileid=uuid.uuid4(),
resourceinstance_id=self.resource.pk,
parenttile_id=parenttile_id,
nodegroup_id=branch[0]["nodegroup_id"],
data={},
)
self.resource.tiles.append(tile)
elif "tile" in result and result["tile"]:
tile = result["tile"]
bnode["tile"] = tile
if bnodeid in result:
if branch[0]["datatype"].collects_multiple_values():
# append to previous tile
if type(node_value) != list:
node_value = [node_value]
bnode = result[bnodeid][0]
bnode["data"].append(branch[1])
if not self.is_semantic_node(branch[0]):
try:
n = bnode["tile"].data[bnodeid]
except:
n = []
bnode["tile"].data[bnodeid] = n
if type(n) != list:
bnode["tile"].data[bnodeid] = [n]
bnode["tile"].data[bnodeid].extend(node_value)
elif branch[0]["cardinality"] != "n":
bnode = result[bnodeid][0]
if node_value == bnode["tile"].data[bnodeid]:
# No-op, attempt to readd same value
pass
else:
raise ValueError(
f"Attempt to add a value to cardinality 1, non-list node {k} {clss}:\n {vi}"
)
else:
bnode["data"].append(branch[1])
if not self.is_semantic_node(branch[0]):
# print(f"Adding to existing (n): {node_value}")
tile.data[bnodeid] = node_value
result[bnodeid].append(bnode)
else:
if not self.is_semantic_node(branch[0]):
tile.data[bnodeid] = node_value
bnode["data"].append(branch[1])
result[bnodeid] = [bnode]
if not is_literal:
# Walk down non-literal branches in the data
self.data_walk(vi, branch[0], bnode, tile)
# Finally, after processing all of the branches for this node, check required nodes are present
for path in tree_node["children"].values():
for kid in path:
if kid["required"] and not f"{kid['node_id']}" in result:
raise ValueError(
f"Required field not present: {kid['name']}")
def post(self, request):
if self.action == 'update_tile':
json = request.POST.get('data', None)
if json != None:
data = JSONDeserializer().deserialize(json)
try:
models.ResourceInstance.objects.get(pk=data['resourceinstance_id'])
except ObjectDoesNotExist:
resource = Resource()
resource.resourceinstanceid = data['resourceinstance_id']
graphid = models.Node.objects.filter(nodegroup=data['nodegroup_id'])[0].graph_id
resource.graph_id = graphid
resource.save(user=request.user)
resource.index()
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)
if tile_id == '4345f530-aa90-48cf-b4b3-92d1185ca439':
import couchdb
import json as json_json
couch = couchdb.Server(settings.COUCHDB_URL)
for project in models.MobileSurveyModel.objects.all():
db = couch['project_' + str(project.id)]
#tile = models.TileModel.objects.get(pk='4345f530-aa90-48cf-b4b3-92d1185ca439')
tile_json = json_json.loads(JSONSerializer().serialize(tile))
tile_json['_id'] = tile_json['tileid']
for row in db.view('_all_docs', include_docs=True):
if 'tileid' in row.doc and tile_json['_id'] == row.doc['_id']:
tile_json['_rev'] = row.doc['_rev']
db.save(tile_json)
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)
if self.action == 'delete_provisional_tile':
data = request.POST
if 'tileid' in data:
provisionaledits = self.delete_provisional_edit(data, request)
return JSONResponse(provisionaledits)
else:
payload = data.get('payload', None)
if payload is not None:
edits = jsonparser.loads(payload)
for edit in edits['edits']:
provisionaledits = self.delete_provisional_edit(edit, request)
return JSONResponse({'result':'success'})
return HttpResponseNotFound()
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 != None:
accepted_provisional_edit = JSONDeserializer().deserialize(
accepted_provisional)
if json != None:
data = JSONDeserializer().deserialize(json)
if data['resourceinstance_id'] == '':
data['resourceinstance_id'] = uuid.uuid4()
try:
models.ResourceInstance.objects.get(
pk=data['resourceinstance_id'])
except ObjectDoesNotExist:
resource = Resource()
graphid = models.Node.objects.filter(
nodegroup=data['nodegroup_id'])[0].graph_id
resource.graph_id = graphid
resource.save(user=request.user)
data['resourceinstance_id'] = resource.pk
resource.index()
tile_id = data['tileid']
if tile_id != None and tile_id != '':
try:
old_tile = Tile.objects.get(pk=tile_id)
clean_resource_cache(old_tile)
except ObjectDoesNotExist:
return JSONResponse(
{
'status':
'false',
'message': [
_('This tile is no longer available'),
_('It was likely deleted by another user')
]
},
status=500)
tile = Tile(data)
if tile.filter_by_perm(request.user, 'write_nodegroup'):
with transaction.atomic():
try:
if accepted_provisional == 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, 'test')
return JSONResponse(
{
'status':
'false',
'message': [
e.message,
_('Unable to Save. Please verify your input is valid'
)
]
},
status=500)
except Exception as e:
message = "Unable to save. A {0} has occurred. Arguments: {1!r}".format(
type(e).__name__, e.args)
return JSONResponse(
{
'status':
'false',
'message': [
message,
_('Please contact your system administrator'
)
]
},
status=500)
else:
if accepted_provisional is not None:
provisional_editor = User.objects.get(
pk=accepted_provisional_edit["user"])
tile.save(
provisional_edit_log_details={
"user": request.user,
"action": "accept edit",
"edit": accepted_provisional_edit,
"provisional_editor":
provisional_editor
})
if tile.provisionaledits is not None and str(
request.user.id) in tile.provisionaledits:
tile.data = tile.provisionaledits[str(
request.user.id)]['value']
except ValidationError as e:
return JSONResponse(
{
'status': 'false',
'message': e.args
},
status=500)
except Exception as e:
exception_title = 'Saving tile failed'
exception_message = str(e)
if hasattr(e, 'message') and e.message:
exception_message += "({0})".format(e.message)
logger.error(exception_title +
''' [Tile id: {tile_id}] \
[Exception message: {message}] \
[Exception trace: {trace}]'''.format(
tile_id=tile_id,
message=exception_message,
trace=traceback.format_exc()))
return JSONResponse(
{
'status':
'false',
'message': [
_(exception_title),
_(str(exception_message))
]
},
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)
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, reviewer=request.user)
elif tileid is not None and users is not None:
users = jsonparser.loads(users)
for user in users:
self.delete_provisional_edit(tile,
user,
reviewer=request.user)
if is_provisional == True:
return JSONResponse({'result': 'delete'})
else:
return JSONResponse({'result': 'success'})
return HttpResponseNotFound()
