Merge pull request #1059 from antgonza/delete-sample-template

delete sample template

Author: squirrelo

qiita_db/metadata_template/base_metadata_template.py

@@ -772,43 +772,6 @@ def _add_common_creation_steps_to_queue(cls, md_template, obj_id,
                                       ', '.join(["%s"] * len(headers))),
             values, many=True)
 
-    @classmethod
-    def delete(cls, id_):
-        r"""Deletes the table from the database
-
-        Parameters
-        ----------
-        id_ : obj
-            The object identifier
-
-        Raises
-        ------
-        QiitaDBUnknownIDError
-            If no metadata_template with id id_ exists
-        """
-        cls._check_subclass()
-        if not cls.exists(id_):
-            raise QiitaDBUnknownIDError(id_, cls.__name__)
-
-        table_name = cls._table_name(id_)
-        conn_handler = SQLConnectionHandler()
-
-        # Delete the sample template filepaths
-        conn_handler.execute(
-            "DELETE FROM qiita.sample_template_filepath WHERE "
-            "study_id = %s", (id_, ))
-
-        conn_handler.execute(
-            "DROP TABLE qiita.{0}".format(table_name))
-        conn_handler.execute(
-            "DELETE FROM qiita.{0} where {1} = %s".format(cls._table,
-                                                          cls._id_column),
-            (id_,))
-        conn_handler.execute(
-            "DELETE FROM qiita.{0} where {1} = %s".format(cls._column_table,
-                                                          cls._id_column),
-            (id_,))
-
     @classmethod
     def exists(cls, obj_id):
         r"""Checks if already exists a MetadataTemplate for the provided object

qiita_db/metadata_template/sample_template.py

@@ -17,7 +17,7 @@
 
 from qiita_core.exceptions import IncompetentQiitaDeveloperError
 from qiita_db.exceptions import (QiitaDBDuplicateError, QiitaDBError,
-                                 QiitaDBWarning)
+                                 QiitaDBWarning, QiitaDBUnknownIDError)
 from qiita_db.sql_connection import SQLConnectionHandler
 from qiita_db.util import (get_table_cols, get_required_sample_info_status,
                            get_mountpoint, scrub_data)
@@ -152,6 +152,63 @@ def create(cls, md_template, study):
 
         return st
 
+    @classmethod
+    def delete(cls, id_):
+        r"""Deletes the table from the database
+
+        Parameters
+        ----------
+        id_ : integer
+            The object identifier
+
+        Raises
+        ------
+        QiitaDBUnknownIDError
+            If no sample template with id id_ exists
+        QiitaDBError
+            If the study that owns this sample template has raw datas
+        """
+        cls._check_subclass()
+
+        if not cls.exists(id_):
+            raise QiitaDBUnknownIDError(id_, cls.__name__)
+
+        raw_datas = [str(rd) for rd in Study(cls(id_).study_id).raw_data()]
+        if raw_datas:
+            raise QiitaDBError("Sample template can not be erased because "
+                               "there are raw datas (%s) associated." %
+                               ', '.join(raw_datas))
+
+        table_name = cls._table_name(id_)
+        conn_handler = SQLConnectionHandler()
+
+        # Delete the sample template filepaths
+        queue = "delete_sample_template_%d" % id_
+        conn_handler.create_queue(queue)
+
+        conn_handler.add_to_queue(
+            queue,
+            "DELETE FROM qiita.sample_template_filepath WHERE study_id = %s",
+            (id_, ))
+
+        conn_handler.add_to_queue(
+            queue,
+            "DROP TABLE qiita.{0}".format(table_name))
+
+        conn_handler.add_to_queue(
+            queue,
+            "DELETE FROM qiita.{0} where {1} = %s".format(cls._table,
+                                                          cls._id_column),
+            (id_,))
+
+        conn_handler.add_to_queue(
+            queue,
+            "DELETE FROM qiita.{0} where {1} = %s".format(cls._column_table,
+                                                          cls._id_column),
+            (id_,))
+
+        conn_handler.execute_queue(queue)
+
     @property
     def study_id(self):
         """Gets the study id with which this sample template is associated

qiita_db/metadata_template/test/test_base_metadata_template.py

@@ -8,7 +8,6 @@
 
 from unittest import TestCase, main
 
-from qiita_core.util import qiita_test_checker
 from qiita_core.exceptions import IncompetentQiitaDeveloperError
 from qiita_db.study import Study
 from qiita_db.metadata_template.base_metadata_template import (
@@ -64,12 +63,5 @@ def test_clean_validate_template(self):
             MetadataTemplate._clean_validate_template(None, 1, None, None)
 
 
-@qiita_test_checker()
-class TestMetadataTemplateReadWrite(TestCase):
-    def test_delete(self):
-        """delete raises an error because it's not called from a subclass"""
-        with self.assertRaises(IncompetentQiitaDeveloperError):
-            MetadataTemplate.delete(1)
-
 if __name__ == '__main__':
     main()

qiita_db/metadata_template/test/test_sample_template.py

@@ -1229,20 +1229,26 @@ def test_create_already_prefixed_samples(self):
 
     def test_delete(self):
         """Deletes Sample template 1"""
-        SampleTemplate.create(self.metadata, self.new_study)
-        SampleTemplate.delete(2)
+        st = SampleTemplate.create(self.metadata, self.new_study)
+        SampleTemplate.delete(st.id)
+
         obs = self.conn_handler.execute_fetchall(
             "SELECT * FROM qiita.required_sample_info WHERE study_id=2")
         exp = []
         self.assertEqual(obs, exp)
+
         obs = self.conn_handler.execute_fetchall(
             "SELECT * FROM qiita.study_sample_columns WHERE study_id=2")
         exp = []
         self.assertEqual(obs, exp)
+
         with self.assertRaises(QiitaDBExecutionError):
             self.conn_handler.execute_fetchall(
                 "SELECT * FROM qiita.sample_2")
 
+        with self.assertRaises(QiitaDBError):
+            SampleTemplate.delete(1)
+
     def test_delete_unkonwn_id_error(self):
         """Try to delete a non existent prep template"""
         with self.assertRaises(QiitaDBUnknownIDError):

qiita_pet/handlers/study_handlers/description_handlers.py

@@ -640,6 +640,33 @@ def display_template(self, study, user, msg, msg_level, full_access,
                     sub_tab=sub_tab,
                     prep_tab=prep_tab)
 
+    def delete_sample_template(self, study, user, callback):
+        """Delete sample template
+
+        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
+        """
+        sample_template_id = int(self.get_argument('sample_template_id'))
+
+        try:
+            SampleTemplate.delete(sample_template_id)
+            msg = ("Sample template %d has been deleted from study: "
+                   "<b><i>%s</i></b>" % (sample_template_id, study.title))
+            msg_level = "success"
+        except Exception as e:
+            msg = "Couldn't remove %d sample template: %s" % (
+                sample_template_id, str(e))
+            msg_level = "danger"
+
+        callback((msg, msg_level, 'study_information_tab', None, None))
+
     def delete_raw_data(self, study, user, callback):
         """Delete the selected raw data
 
@@ -781,6 +808,7 @@ def post(self, study_id):
             request_approval=self.request_approval,
             make_sandbox=self.make_sandbox,
             update_investigation_type=self.update_investigation_type,
+            delete_sample_template=self.delete_sample_template,
             delete_raw_data=self.delete_raw_data,
             delete_prep_template=self.delete_prep_template,
             delete_preprocessed_data=self.delete_preprocessed_data,

qiita_pet/templates/study_description.html

@@ -184,6 +184,25 @@
   form.submit();
 }
 
+function delete_sample_template() {
+  sample_template_id = {{study.sample_template}};
+  if (confirm('Are you sure you want to delete sample template ID: ' + sample_template_id + '?')) {
+    var form = $("<form>")
+    .attr("action", window.location.href)
+    .attr("method", "post")
+    .append($("<input>")
+    .attr("type", "hidden")
+    .attr("name", "sample_template_id")
+    .attr("value", sample_template_id))
+    .append($("<input>")
+    .attr("type", "hidden")
+    .attr("name", "action")
+    .attr("value", "delete_sample_template"));
+    $("body").append(form);
+    form.submit();
+  }
+}
+
 function delete_raw_data(raw_data_filetype, raw_data_id) {
   if (confirm('Are you sure you want to delete raw data: ' + raw_data_filetype + ' (ID: ' + raw_data_id + ')?')) {
     var form = $("<form>")
@@ -537,7 +556,9 @@ <h2><i>{{study_alias}}</i></h2>
 
 <!-- Nav tabs -->
 <ul class="nav nav-tabs" role="tablist" id="myTab">
-    <li class="active"><a href="#study_information_tab" role="tab" data-toggle="tab">Study information</a></li>
+    <li class="active">
+      <a href="#study_information_tab" role="tab" data-toggle="tab">Study information</a>
+    </li>
   {% if show_data_tabs %}
     <li><a href="#raw_data_tab" role="tab" data-toggle="tab">Raw data</a></li>
     <li><a href="#preprocessed_data_tab" role="tab" data-toggle="tab">Preprocessed data</a></li>

qiita_pet/templates/study_description_templates/study_information_tab.html

@@ -43,10 +43,12 @@
 
   <table>
     <tr>
+      {% if not sample_templates %}
       <td>
         <a class="btn btn-primary" onclick="process_sample_template();">Process sample template</a>
       </td>
       <td>&nbsp; &nbsp;</td>
+      {% end %}
       {% if sample_templates %}
       <td>
         <a class="btn btn-primary" onclick="update_sample_template();">Update sample template</a>
@@ -55,6 +57,10 @@
       <td>
         <a class="btn btn-primary" onclick="extend_sample_template();">Add samples to study</a>
       </td>
+      <td>&nbsp; &nbsp;</td>
+      <td>
+        <a class="btn btn-danger glyphicon glyphicon-trash" onclick="delete_sample_template();"></a>
+      </td>
       {% end %}
   </table>
 </div>

qiita_pet/test/test_study_handlers.py

@@ -382,5 +382,59 @@ class TestEBISubmitHandler(TestHandlerBase):
     pass
 
 
+class TestDelete(TestHandlerBase):
+    database = True
+
+    def test_delete_sample_template(self):
+        response = self.post('/study/description/1',
+                             {'sample_template_id': 1,
+                              'action': 'delete_sample_template'})
+        self.assertEqual(response.code, 200)
+
+        # checking that the action was sent
+        self.assertIn("Sample template can not be erased because there are "
+                      "raw datas", response.body)
+
+    def test_delete_raw_data(self):
+        response = self.post('/study/description/1',
+                             {'raw_data_id': 1,
+                              'action': 'delete_raw_data'})
+        self.assertEqual(response.code, 200)
+
+        # checking that the action was sent
+        self.assertIn("Raw data 1 has prep template(s) associated so it can't "
+                      "be erased", response.body)
+
+    def test_delete_prep_template(self):
+        response = self.post('/study/description/1',
+                             {'prep_template_id': 1,
+                              'action': 'delete_prep_template'})
+        self.assertEqual(response.code, 200)
+
+        # checking that the action was sent
+        self.assertIn('Cannot remove prep template 1 because a preprocessed '
+                      'data has been already generated using it.',
+                      response.body)
+
+    def test_delete_preprocessed_data(self):
+        response = self.post('/study/description/1',
+                             {'preprocessed_data_id': 1,
+                              'action': 'delete_preprocessed_data'})
+        self.assertEqual(response.code, 200)
+
+        # checking that the action was sent
+        self.assertIn('Illegal operation on non sandboxed preprocessed data',
+                      response.body)
+
+    def test_delete_processed_data(self):
+        response = self.post('/study/description/1',
+                             {'processed_data_id': 1,
+                              'action': 'delete_processed_data'})
+        self.assertEqual(response.code, 200)
+
+        # checking that the action was sent
+        self.assertIn('Illegal operation on non sandboxed processed data',
+                      response.body)
+
 if __name__ == "__main__":
     main()