Fixing merge conflicts

Author: josenavas

qiita_db/data.py

@@ -103,7 +103,7 @@ class BaseData(QiitaObject):
     --------
     RawData
     PreprocessedData
-    PreprocessedData
+    ProcessedData
     """
     _filepath_table = "filepath"
 
@@ -807,6 +807,73 @@ def create(cls, study, preprocessed_params_table, preprocessed_params_id,
         ppd.add_filepaths(filepaths, conn_handler)
         return ppd
 
+    @classmethod
+    def delete(cls, ppd_id):
+        """Removes the preprocessed data with id ppd_id
+
+        Parameters
+        ----------
+        ppd_id : int
+            The preprocessed data id
+
+        Raises
+        ------
+        QiitaDBStatusError
+            If the preprocessed data status is not sandbox or if the
+            preprocessed data EBI and VAMPS submission is not in a valid state
+            ['not submitted', 'failed']
+        QiitaDBError
+            If the preprocessed data has been processed
+        """
+        valid_submission_states = ['not submitted', 'failed']
+        ppd = cls(ppd_id)
+        if ppd.status != 'sandbox':
+            raise QiitaDBStatusError(
+                "Illegal operation on non sandboxed preprocessed data")
+        elif ppd.submitted_to_vamps_status() not in valid_submission_states:
+            raise QiitaDBStatusError(
+                "Illegal operation. This preprocessed data has or is being "
+                "added to VAMPS.")
+        elif ppd.submitted_to_insdc_status() not in valid_submission_states:
+            raise QiitaDBStatusError(
+                "Illegal operation. This preprocessed data has or is being "
+                "added to EBI.")
+
+        conn_handler = SQLConnectionHandler()
+
+        processed_data = [str(n[0]) for n in conn_handler.execute_fetchall(
+            "SELECT processed_data_id FROM qiita.preprocessed_processed_data "
+            "WHERE preprocessed_data_id = {0} ORDER BY "
+            "processed_data_id".format(ppd_id))]
+
+        if processed_data:
+            raise QiitaDBError(
+                "Preprocessed data %d cannot be removed because it was used "
+                "to generate the following processed data: %s" % (
+                    ppd_id, ', '.join(processed_data)))
+
+        # delete
+        queue = "delete_preprocessed_data_%d" % ppd_id
+        conn_handler.create_queue(queue)
+
+        sql = ("DELETE FROM qiita.prep_template_preprocessed_data WHERE "
+               "preprocessed_data_id = {0}".format(ppd_id))
+        conn_handler.add_to_queue(queue, sql)
+
+        sql = ("DELETE FROM qiita.preprocessed_filepath WHERE "
+               "preprocessed_data_id = {0}".format(ppd_id))
+        conn_handler.add_to_queue(queue, sql)
+
+        sql = ("DELETE FROM qiita.study_preprocessed_data WHERE "
+               "preprocessed_data_id = {0}".format(ppd_id))
+        conn_handler.add_to_queue(queue, sql)
+
+        sql = ("DELETE FROM qiita.preprocessed_data WHERE "
+               "preprocessed_data_id = {0}".format(ppd_id))
+        conn_handler.add_to_queue(queue, sql)
+
+        conn_handler.execute_queue(queue)
+
     @property
     def processed_data(self):
         r"""The processed data list generated from this preprocessed data"""
@@ -1275,7 +1342,7 @@ def delete(cls, processed_data_id):
         """
         if cls(processed_data_id).status != 'sandbox':
             raise QiitaDBStatusError(
-                "Illegal operation on non sandbox processed data")
+                "Illegal operation on non sandboxed processed data")
 
         conn_handler = SQLConnectionHandler()
 

qiita_db/metadata_template/base_metadata_template.py

@@ -45,6 +45,7 @@
 from skbio.util import find_duplicates
 
 from qiita_core.exceptions import IncompetentQiitaDeveloperError
+
 from qiita_db.exceptions import (QiitaDBUnknownIDError, QiitaDBColumnError,
                                  QiitaDBNotImplementedError,
                                  QiitaDBDuplicateHeaderError)
@@ -312,17 +313,81 @@ def handler(x):
                            " in template %d" %
                            (key, self._id, self._md_template.id))
 
-    def __setitem__(self, key, value):
-        r"""Sets the metadata value for the category `key`
+    def __setitem__(self, column, value):
+        r"""Sets the metadata value for the category `column`
 
         Parameters
         ----------
-        key : str
-            The metadata category
-        value : obj
-            The new value for the category
+        column : str
+            The column to update
+        value : str
+            The value to set. This is expected to be a str on the assumption
+            that psycopg2 will cast as necessary when updating.
+
+        Raises
+        ------
+        QiitaDBColumnError
+            If the column does not exist in the table
+        ValueError
+            If the value type does not match the one in the DB
         """
-        raise QiitaDBNotImplementedError()
+        conn_handler = SQLConnectionHandler()
+
+        # try dynamic tables
+        sql = """SELECT EXISTS (
+                    SELECT column_name
+                    FROM information_schema.columns
+                    WHERE table_name=%s
+                        AND table_schema='qiita'
+                        AND column_name=%s)"""
+        exists_dynamic = conn_handler.execute_fetchone(
+            sql, (self._dynamic_table, column))[0]
+        # try required_sample_info
+        sql = """SELECT EXISTS (
+                    SELECT column_name
+                    FROM information_schema.columns
+                    WHERE table_name=%s
+                        AND table_schema='qiita'
+                        AND column_name=%s)"""
+        exists_required = conn_handler.execute_fetchone(
+            sql, (self._table, column))[0]
+
+        if exists_dynamic:
+                sql = """UPDATE qiita.{0}
+                         SET {1}=%s
+                         WHERE sample_id=%s""".format(self._dynamic_table,
+                                                      column)
+        elif exists_required:
+            # here is not required the type check as the required fields have
+            # an explicit type check
+            sql = """UPDATE qiita.{0}
+                     SET {1}=%s
+                     WHERE sample_id=%s""".format(self._table, column)
+        else:
+            raise QiitaDBColumnError("Column %s does not exist in %s" %
+                                     (column, self._dynamic_table))
+
+        try:
+            conn_handler.execute(sql, (value, self._id))
+        except Exception as e:
+            # catching error so we can check if the error is due to different
+            # column type or something else
+            column_type = conn_handler.execute_fetchone(
+                """SELECT data_type
+                   FROM information_schema.columns
+                   WHERE column_name=%s AND table_schema='qiita'
+                """, (column,))[0]
+            value_type = type(value).__name__
+
+            if column_type != value_type:
+                raise ValueError(
+                    'The new value being added to column: "{0}" is "{1}" '
+                    '(type: "{2}"). However, this column in the DB is of '
+                    'type "{3}". Please change the value in your updated '
+                    'template or reprocess your sample template.'.format(
+                        column, value, value_type, column_type))
+            else:
+                raise e
 
     def __delitem__(self, key):
         r"""Removes the sample with sample id `key` from the database

qiita_db/metadata_template/sample_template.py

@@ -59,80 +59,6 @@ def _check_template_class(self, md_template):
         if not isinstance(md_template, SampleTemplate):
             raise IncompetentQiitaDeveloperError()
 
-    def __setitem__(self, column, value):
-        r"""Sets the metadata value for the category `column`
-
-        Parameters
-        ----------
-        column : str
-            The column to update
-        value : str
-            The value to set. This is expected to be a str on the assumption
-            that psycopg2 will cast as necessary when updating.
-
-        Raises
-        ------
-        QiitaDBColumnError
-            If the column does not exist in the table
-        """
-        conn_handler = SQLConnectionHandler()
-
-        # try dynamic tables
-        exists_dynamic = conn_handler.execute_fetchone("""
-        SELECT EXISTS (
-            SELECT column_name
-            FROM information_schema.columns
-            WHERE table_name='{0}'
-                AND table_schema='qiita'
-                AND column_name='{1}')""".format(self._dynamic_table,
-                                                 column))[0]
-        # try required_sample_info
-        exists_required = conn_handler.execute_fetchone("""
-        SELECT EXISTS (
-            SELECT column_name
-            FROM information_schema.columns
-            WHERE table_name='required_sample_info'
-                AND table_schema='qiita'
-                AND column_name='{0}')""".format(column))[0]
-
-        if exists_dynamic:
-            # catching error so we can check if the error is due to different
-            # column type or something else
-            try:
-                conn_handler.execute("""
-                    UPDATE qiita.{0}
-                    SET {1}=%s
-                    WHERE sample_id=%s""".format(self._dynamic_table,
-                                                 column), (value, self._id))
-            except Exception as e:
-                column_type = conn_handler.execute_fetchone("""
-                    SELECT data_type
-                    FROM information_schema.columns
-                    WHERE column_name=%s AND table_schema='qiita'
-                    """, (column,))[0]
-                value_type = type(value).__name__
-
-                if column_type != value_type:
-                    raise ValueError(
-                        'The new value being added to column: "{0}" is "{1}" '
-                        '(type: "{2}"). However, this column in the DB is of '
-                        'type "{3}". Please change the value in your updated '
-                        'template or reprocess your sample template.'.format(
-                            column, value, value_type, column_type))
-                else:
-                    raise e
-        elif exists_required:
-            # here is not required the type check as the required fields have
-            # an explicit type check
-            conn_handler.execute("""
-                UPDATE qiita.required_sample_info
-                SET {0}=%s
-                WHERE sample_id=%s
-                """.format(column), (value, self._id))
-        else:
-            raise QiitaDBColumnError("Column %s does not exist in %s" %
-                                     (column, self._dynamic_table))
-
 
 class SampleTemplate(MetadataTemplate):
     r"""Represent the SampleTemplate of a study. Provides access to the

qiita_db/metadata_template/test/test_prep_template.py

@@ -220,9 +220,15 @@ def test_get_none(self):
 class TestPrepSampleReadWrite(BaseTestPrepSample):
     """Tests the PrepSample class"""
     def test_setitem(self):
-        """setitem raises an error (currently not allowed)"""
-        with self.assertRaises(QiitaDBNotImplementedError):
-            self.tester['barcodesequence'] = 'GTCCGCAAGTTA'
+        with self.assertRaises(QiitaDBColumnError):
+            self.tester['column that does not exist'] = 0.3
+
+        with self.assertRaises(ValueError):
+            self.tester['emp_status_id'] = "Error!"
+
+        self.assertEqual(self.tester['center_name'], 'ANL')
+        self.tester['center_name'] = "FOO"
+        self.assertEqual(self.tester['center_name'], "FOO")
 
     def test_delitem(self):
         """delitem raises an error (currently not allowed)"""

qiita_db/metadata_template/test/test_sample_template.py

@@ -209,6 +209,10 @@ class TestSampleReadWrite(BaseTestSample):
     def test_setitem(self):
         with self.assertRaises(QiitaDBColumnError):
             self.tester['column that does not exist'] = 0.30
+
+        with self.assertRaises(ValueError):
+            self.tester['collection_timestamp'] = "Error!"
+
         self.assertEqual(self.tester['tot_nitro'], 1.41)
         self.tester['tot_nitro'] = '1234.5'
         self.assertEqual(self.tester['tot_nitro'], 1234.5)

qiita_db/test/test_data.py

@@ -478,6 +478,48 @@ def test_create_data_type_only(self):
         # preprocessed_data_id, filepath_id
         self.assertEqual(obs, [[3, obs_id - 1], [3, obs_id]])
 
+    def test_delete_basic(self):
+        """Correctly deletes a preprocessed data"""
+        # testing regular delete
+        ppd = PreprocessedData.create(
+            self.study, self.params_table,
+            self.params_id, self.filepaths, prep_template=self.prep_template,
+            ebi_submission_accession=self.ebi_submission_accession,
+            ebi_study_accession=self.ebi_study_accession)
+        PreprocessedData.delete(ppd.id)
+
+        # testing that the deleted preprocessed data can't be instantiated
+        with self.assertRaises(QiitaDBUnknownIDError):
+            PreprocessedData(ppd.id)
+        # and for completeness testing that it raises an error if ID
+        # doesn't exist
+        with self.assertRaises(QiitaDBUnknownIDError):
+            PreprocessedData.delete(ppd.id)
+
+        # testing that we can not remove cause the preprocessed data != sandbox
+        with self.assertRaises(QiitaDBStatusError):
+            PreprocessedData.delete(1)
+
+    def test_delete_advanced(self):
+        # testing that we can not remove cause preprocessed data has been
+        # submitted to EBI or VAMPS
+        ppd = PreprocessedData.create(
+            self.study, self.params_table,
+            self.params_id, self.filepaths, prep_template=self.prep_template,
+            ebi_submission_accession=self.ebi_submission_accession,
+            ebi_study_accession=self.ebi_study_accession)
+
+        # fails due to VAMPS submission
+        ppd.update_vamps_status('success')
+        with self.assertRaises(QiitaDBStatusError):
+            PreprocessedData.delete(ppd.id)
+        ppd.update_vamps_status('failed')
+
+        # fails due to EBI submission
+        ppd.update_insdc_status('success', 'AAAA', 'AAAA')
+        with self.assertRaises(QiitaDBStatusError):
+            PreprocessedData.delete(ppd.id)
+
     def test_create_error_dynamic_table(self):
         """Raises an error if the preprocessed_params_table does not exist"""
         with self.assertRaises(IncompetentQiitaDeveloperError):

qiita_pet/handlers/study_handlers/description_handlers.py

@@ -697,6 +697,33 @@ def delete_prep_template(self, study, user, callback):
 
         callback((msg, msg_level, 'raw_data_tab', prep_id, None))
 
+    def delete_preprocessed_data(self, study, user, callback):
+        """Delete the selected preprocessed 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
+        """
+        ppd_id = int(self.get_argument('preprocessed_data_id'))
+
+        try:
+            PreprocessedData.delete(ppd_id)
+            msg = ("Preprocessed data %d has been deleted" % ppd_id)
+            msg_level = "success"
+            ppd_id = None
+        except Exception as e:
+            msg = ("Couldn't remove preprocessed data %d: %s" %
+                   (ppd_id, str(e)))
+            msg_level = "danger"
+
+        callback((msg, msg_level, 'preprocessed_data_tab', ppd_id, None))
+
     def delete_processed_data(self, study, user, callback):
         """Delete the selected processed data
 
@@ -756,6 +783,7 @@ def post(self, study_id):
             update_investigation_type=self.update_investigation_type,
             delete_raw_data=self.delete_raw_data,
             delete_prep_template=self.delete_prep_template,
+            delete_preprocessed_data=self.delete_preprocessed_data,
             delete_processed_data=self.delete_processed_data)
 
         # Get the action that we need to perform