def run(self) -> Model:
self.validate()
try:
dataset = DatasetDAO.delete(self._model, commit=False)
view_menu = (security_manager.find_view_menu(
self._model.get_perm()) if self._model else None)
if view_menu:
permission_views = (db.session.query(
security_manager.permissionview_model).filter_by(
view_menu=view_menu).all())
for permission_view in permission_views:
db.session.delete(permission_view)
if view_menu:
db.session.delete(view_menu)
else:
if not view_menu:
logger.error(
"Could not find the data access permission for the dataset"
)
db.session.commit()
except (SQLAlchemyError, DAODeleteFailedError) as ex:
logger.exception(ex)
db.session.rollback()
raise DatasetDeleteFailedError()
return dataset
def test_migrate_role(descriptiom, new_pvms, pvm_map, external_pvms,
deleted_views, deleted_permissions):
"""
Permission migration: generic tests
"""
logger.info(descriptiom)
with create_old_role(pvm_map, external_pvms) as old_role:
role_name = old_role.name
session = db.session
# Run migrations
add_pvms(session, new_pvms)
migrate_roles(session, pvm_map)
role = db.session.query(Role).filter(
Role.name == role_name).one_or_none()
for old_pvm, new_pvms in pvm_map.items():
old_pvm_model = security_manager.find_permission_view_menu(
old_pvm.permission, old_pvm.view)
assert old_pvm_model is None
new_pvm_model = security_manager.find_permission_view_menu(
new_pvms[0].permission, new_pvms[0].view)
assert new_pvm_model is not None
assert new_pvm_model in role.permissions
# assert deleted view menus
for deleted_view in deleted_views:
assert security_manager.find_view_menu(deleted_view) is None
# assert deleted permissions
for deleted_permission in deleted_permissions:
assert security_manager.find_permission(deleted_permission) is None
# assert externals are still there
for external_pvm in external_pvms:
assert (security_manager.find_permission_view_menu(
external_pvm.permission, external_pvm.view) is not None)
def run(self) -> None:
self.validate()
if not self._models:
return None
try:
DatasetDAO.bulk_delete(self._models)
for model in self._models:
view_menu = (security_manager.find_view_menu(model.get_perm())
if model else None)
if view_menu:
permission_views = (db.session.query(
security_manager.permissionview_model).filter_by(
view_menu=view_menu).all())
for permission_view in permission_views:
db.session.delete(permission_view)
if view_menu:
db.session.delete(view_menu)
else:
if not view_menu:
logger.error(
"Could not find the data access permission for the dataset",
exc_info=True,
)
db.session.commit()
return None
except DeleteFailedError as ex:
logger.exception(ex.exception)
raise DatasetBulkDeleteFailedError()
def test_bulk_delete_dataset_items(self):
"""
Dataset API: Test bulk delete dataset items
"""
datasets = self.get_fixture_datasets()
dataset_ids = [dataset.id for dataset in datasets]
view_menu_names = []
for dataset in datasets:
view_menu_names.append(dataset.get_perm())
self.login(username="******")
uri = f"api/v1/dataset/?q={prison.dumps(dataset_ids)}"
rv = self.delete_assert_metric(uri, "bulk_delete")
data = json.loads(rv.data.decode("utf-8"))
assert rv.status_code == 200
expected_response = {"message": f"Deleted {len(datasets)} datasets"}
assert data == expected_response
datasets = (
db.session.query(SqlaTable)
.filter(SqlaTable.table_name.in_(self.fixture_tables_names))
.all()
)
assert datasets == []
# Assert permissions get cleaned
for view_menu_name in view_menu_names:
assert security_manager.find_view_menu(view_menu_name) is None
def test_delete_dataset_item(self):
"""
Dataset API: Test delete dataset item
"""
dataset = self.insert_default_dataset()
view_menu = security_manager.find_view_menu(dataset.get_perm())
assert view_menu is not None
view_menu_id = view_menu.id
self.login(username="******")
uri = f"api/v1/dataset/{dataset.id}"
rv = self.client.delete(uri)
assert rv.status_code == 200
non_view_menu = db.session.query(
security_manager.viewmenu_model).get(view_menu_id)
assert non_view_menu is None
