def bulk_delete(models: Optional[List[Annotation]],
commit: bool = True) -> None:
item_ids = [model.id for model in models] if models else []
try:
db.session.query(Annotation).filter(
Annotation.id.in_(item_ids)).delete(
synchronize_session="fetch")
if commit:
db.session.commit()
except SQLAlchemyError as ex:
db.session.rollback()
raise DAODeleteFailedError() from ex
def delete(cls, model: Model, commit: bool = True) -> Model:
"""
Generic delete a model
:raises: DAOCreateFailedError
"""
try:
db.session.delete(model)
if commit:
db.session.commit()
except SQLAlchemyError as ex: # pragma: no cover
db.session.rollback()
raise DAODeleteFailedError(exception=ex) from ex
return model
def test_delete_dataset_sqlalchemy_error(self, mock_dao_delete):
"""
Dataset API: Test delete dataset sqlalchemy error
"""
mock_dao_delete.side_effect = DAODeleteFailedError()
dataset = self.insert_default_dataset()
self.login(username="******")
uri = f"api/v1/dataset/{dataset.id}"
rv = self.delete_assert_metric(uri, "delete")
data = json.loads(rv.data.decode("utf-8"))
assert rv.status_code == 422
assert data == {"message": "Dataset could not be deleted."}
db.session.delete(dataset)
db.session.commit()
def bulk_delete(models: Optional[List[ReportSchedule]],
commit: bool = True) -> None:
item_ids = [model.id for model in models] if models else []
try:
# Clean owners secondary table
report_schedules = (db.session.query(ReportSchedule).filter(
ReportSchedule.id.in_(item_ids)).all())
for report_schedule in report_schedules:
report_schedule.owners = []
for report_schedule in report_schedules:
db.session.delete(report_schedule)
if commit:
db.session.commit()
except SQLAlchemyError as ex:
db.session.rollback()
raise DAODeleteFailedError(str(ex)) from ex
def test_delete_dataset_sqlalchemy_error(self, mock_dao_delete):
"""
Dataset API: Test delete dataset sqlalchemy error
"""
mock_dao_delete.side_effect = DAODeleteFailedError()
admin = self.get_user("admin")
table = self.insert_dataset("ab_permission", "", [admin.id],
get_example_database())
self.login(username="******")
uri = f"api/v1/dataset/{table.id}"
rv = self.client.delete(uri)
data = json.loads(rv.data.decode("utf-8"))
self.assertEqual(rv.status_code, 422)
self.assertEqual(data, {"message": "Dataset could not be deleted."})
db.session.delete(table)
db.session.commit()
def bulk_delete_logs(
model: ReportSchedule,
from_date: datetime,
session: Optional[Session] = None,
commit: bool = True,
) -> Optional[int]:
session = session or db.session
try:
row_count = (session.query(ReportExecutionLog).filter(
ReportExecutionLog.report_schedule == model,
ReportExecutionLog.end_dttm < from_date,
).delete(synchronize_session="fetch"))
if commit:
session.commit()
return row_count
except SQLAlchemyError as ex:
session.rollback()
raise DAODeleteFailedError(str(ex)) from ex
