def delete_raw_data(self, study, user, callback):
"""Delete the selected raw data
Parameters
----------
study : Study
The current study object
user : User
The current user object
callback : function
The callback function to call with the results once the processing
is done
"""
raw_data_id = int(self.get_argument('raw_data_id'))
prep_template_id = int(self.get_argument('prep_template_id'))
try:
RawData.delete(raw_data_id, prep_template_id)
msg = ("Raw data %d has been deleted from prep_template %d"
% (raw_data_id, prep_template_id))
msg_level = "success"
except Exception as e:
msg = "Couldn't remove raw data %d: %s" % (raw_data_id, str(e))
msg_level = "danger"
callback((msg, msg_level, "prep_template_tab", prep_template_id, None))
def delete_raw_data(self, study, user, callback):
"""Delete the selected raw data
Parameters
----------
study : Study
The current study object
user : User
The current user object
callback : function
The callback function to call with the results once the processing
is done
"""
raw_data_id = int(self.get_argument('raw_data_id'))
try:
RawData.delete(raw_data_id, study.id)
msg = ("Raw data %d has been deleted from study: "
"<b><i>%s</i></b>" % (raw_data_id, study.title))
msg_level = "success"
tab = 'study_information_tab'
tab_id = None
except Exception as e:
msg = "Couldn't remove %d raw data: %s" % (raw_data_id, str(e))
msg_level = "danger"
tab = 'raw_data_tab'
tab_id = raw_data_id
callback((msg, msg_level, tab, tab_id, None))
def delete_raw_data(self, study, user, callback):
"""Delete the selected raw data
Parameters
----------
study : Study
The current study object
user : User
The current user object
callback : function
The callback function to call with the results once the processing
is done
"""
raw_data_id = int(self.get_argument('raw_data_id'))
try:
RawData.delete(raw_data_id, study.id)
msg = ("Raw data %d has been deleted from study: "
"<b><i>%s</i></b>" % (raw_data_id, study.title))
msg_level = "success"
tab = 'study_information_tab'
tab_id = None
except Exception as e:
msg = "Couldn't remove %d raw data: %s" % (raw_data_id, str(e))
msg_level = "danger"
tab = 'raw_data_tab'
tab_id = raw_data_id
callback((msg, msg_level, tab, tab_id, None))
def test_delete(self):
rd = RawData.create(self.filetype, self.prep_templates,
self.filepaths)
sql_pt = """SELECT prep_template_id
FROM qiita.prep_template
WHERE raw_data_id = %s
ORDER BY prep_template_id"""
obs = self.conn_handler.execute_fetchall(sql_pt, (rd.id,))
self.assertEqual(obs, [[self.pt1.id], [self.pt2.id]])
# This delete call will only unlink the raw data from the prep template
RawData.delete(rd.id, self.pt2.id)
# Check that it successfully unlink the raw data from pt2
obs = self.conn_handler.execute_fetchall(sql_pt, (rd.id,))
self.assertEqual(obs, [[self.pt1.id]])
self.assertEqual(self.pt2.raw_data, None)
# If we try to remove the RawData now, it should raise an error
# because it still has files attached to it
with self.assertRaises(QiitaDBError):
RawData.delete(rd.id, self.pt1.id)
# Clear the files so we can actually remove the RawData
study_id = rd.studies[0]
path_for_removal = join(get_mountpoint("uploads")[0][1], str(study_id))
self._clean_up_files.extend([join(path_for_removal,
basename(f).split('_', 1)[1])
for _, f, _ in rd.get_filepaths()])
rd.clear_filepaths()
RawData.delete(rd.id, self.pt1.id)
obs = self.conn_handler.execute_fetchall(sql_pt, (rd.id,))
self.assertEqual(obs, [])
# Check that all expected rows have been deleted
sql = """SELECT EXISTS(
SELECT * FROM qiita.raw_filepath
WHERE raw_data_id = %s)"""
self.assertFalse(self.conn_handler.execute_fetchone(sql, (rd.id,))[0])
sql = """SELECT EXISTS(
SELECT * FROM qiita.raw_data
WHERE raw_data_id=%s)"""
self.assertFalse(self.conn_handler.execute_fetchone(sql, (rd.id,))[0])
def test_delete(self):
# the raw data doesn't exist
with self.assertRaises(QiitaDBUnknownIDError):
RawData.delete(1000, 1)
# the raw data and the study id are not linked or
# the study doesn't exits
with self.assertRaises(QiitaDBError):
RawData.delete(1, 1000)
# the raw data has prep templates
with self.assertRaises(QiitaDBError):
RawData.delete(1, 1)
# the raw data has linked files
with self.assertRaises(QiitaDBError):
RawData.delete(3, 1)
# the raw data is linked to a study that has not prep templates
Study(2).add_raw_data([RawData(1)])
RawData.delete(1, 2)
# delete raw data
self.assertTrue(RawData.exists(2))
RawData.delete(2, 1)
self.assertFalse(RawData.exists(2))
def test_delete_error_linked_files(self):
# the raw data has linked files
with self.assertRaises(QiitaDBError):
RawData.delete(1, 1)
def test_delete_error_prep_template_no_exists(self):
# the prep template does not exist
with self.assertRaises(QiitaDBError):
RawData.delete(1, 1000)
def test_delete_error_raw_data_not_linked(self):
# the raw data and the prep template id are not linked
with self.assertRaises(QiitaDBError):
RawData.delete(1, self.pt2.id)
def test_delete_error_no_exists(self):
# the raw data doesn't exist
with self.assertRaises(QiitaDBUnknownIDError):
RawData.delete(1000, 0)
def test_delete(self):
# the raw data doesn't exist
with self.assertRaises(QiitaDBUnknownIDError):
RawData.delete(1000, 1)
# the raw data and the study id are not linked or
# the study doesn't exits
with self.assertRaises(QiitaDBError):
RawData.delete(1, 1000)
# the raw data has prep templates
with self.assertRaises(QiitaDBError):
RawData.delete(1, 1)
# the raw data has linked files
with self.assertRaises(QiitaDBError):
RawData.delete(3, 1)
# the raw data is linked to a study that has not prep templates
Study(2).add_raw_data([RawData(1)])
RawData.delete(1, 2)
# delete raw data
self.assertTrue(RawData.exists(2))
RawData.delete(2, 1)
self.assertFalse(RawData.exists(2))
