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 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 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 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 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 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()