reducing code duplication

josenavas · josenavas · commit 47aac336ad1d · 2015-03-31T10:18:08.000-07:00
diff --git a/qiita_db/metadata_template/base_metadata_template.py b/qiita_db/metadata_template/base_metadata_template.py
@@ -22,8 +22,8 @@
                                  QiitaDBDuplicateHeaderError)
 from qiita_db.base import QiitaObject
 from qiita_db.sql_connection import SQLConnectionHandler
-from qiita_db.util import (exists_table, get_table_cols, convert_to_id,
-                           get_mountpoint, insert_filepaths)
+from qiita_db.util import (exists_table, get_table_cols, get_mountpoint,
+                           insert_filepaths)
 from qiita_db.logger import LogEntry
 from .util import get_invalid_sample_names, prefix_sample_names_with_id
 
@@ -425,6 +425,7 @@ class MetadataTemplate(QiitaObject):
     _id_column = None
     _sample_cls = None
     _filepath_table = None
+    _filepath_type = None
 
     def _check_id(self, id_, conn_handler=None):
         r"""Checks that the MetadataTemplate id_ exists on the database"""
@@ -839,28 +840,19 @@ def add_filepath(self, filepath, conn_handler=None):
         # one if not.
         conn_handler = conn_handler if conn_handler else SQLConnectionHandler()
 
-        if self._table == 'required_sample_info':
-            fp_id = convert_to_id("sample_template", "filepath_type",
-                                  conn_handler)
-            table = 'sample_template_filepath'
-            column = 'study_id'
-        elif self._table == 'common_prep_info':
-            fp_id = convert_to_id("prep_template", "filepath_type",
-                                  conn_handler)
-            table = 'prep_template_filepath'
-            column = 'prep_template_id'
-        else:
-            raise QiitaDBNotImplementedError(
-                'add_filepath for %s' % self._table)
-
         try:
-            fpp_id = insert_filepaths([(filepath, fp_id)], None, "templates",
-                                      "filepath", conn_handler,
+            fpp_id = insert_filepaths([(filepath, self._filepath_type)], None,
+                                      "templates", "filepath", conn_handler,
                                       move_files=False)[0]
             values = (self._id, fpp_id)
-            conn_handler.execute(
-                "INSERT INTO qiita.{0} ({1}, filepath_id) "
-                "VALUES (%s, %s)".format(table, column), values)
+            sql = """INSERT INTO qiita.{0} ({1}, filepath_id)
+                     VALUES (%s, %s)""".format(self._filepath_table,
+                                               self._id_column)
+            # If this call fails, filepaths will have been added to the DB,
+            # but they're not linked to anything. However, this is not a
+            # problem, as any subsequent call to purge_filepaths will remove
+            # those filepaths
+            conn_handler.execute(sql, values)
         except Exception as e:
             LogEntry.create('Runtime', str(e),
                             info={self.__class__.__name__: self.id})
@@ -875,22 +867,16 @@ def get_filepaths(self, conn_handler=None):
         # one if not.
         conn_handler = conn_handler if conn_handler else SQLConnectionHandler()
 
-        if self._table == 'required_sample_info':
-            table = 'sample_template_filepath'
-            column = 'study_id'
-        elif self._table == 'common_prep_info':
-            table = 'prep_template_filepath'
-            column = 'prep_template_id'
-        else:
-            raise QiitaDBNotImplementedError(
-                'get_filepath for %s' % self._table)
-
+        sql = """SELECT filepath_id, filepath
+                 FROM qiita.filepath
+                 WHERE filepath_id IN (
+                    SELECT filepath_id
+                    FROM qiita.{0}
+                    WHERE {1}=%s)
+                ORDER BY filepath_id DESC""".format(self._filepath_table,
+                                                    self._id_column)
         try:
-            filepath_ids = conn_handler.execute_fetchall(
-                "SELECT filepath_id, filepath FROM qiita.filepath WHERE "
-                "filepath_id IN (SELECT filepath_id FROM qiita.{0} WHERE "
-                "{1}=%s) ORDER BY filepath_id DESC".format(table, column),
-                (self.id, ))
+            filepath_ids = conn_handler.execute_fetchall(sql, (self.id, ))
         except Exception as e:
             LogEntry.create('Runtime', str(e),
                             info={self.__class__.__name__: self.id})
diff --git a/qiita_db/metadata_template/prep_template.py b/qiita_db/metadata_template/prep_template.py
@@ -73,6 +73,7 @@ class PrepTemplate(MetadataTemplate):
     _id_column = "prep_template_id"
     _sample_cls = PrepSample
     _filepath_table = "prep_template_filepath"
+    _filepath_type = convert_to_id("sample_template", "filepath_type")
 
     @classmethod
     def create(cls, md_template, raw_data, study, data_type,
diff --git a/qiita_db/metadata_template/sample_template.py b/qiita_db/metadata_template/sample_template.py
@@ -21,7 +21,7 @@
                                  QiitaDBUnknownIDError, QiitaDBError,
                                  QiitaDBWarning, QiitaDBExecutionError)
 from qiita_db.sql_connection import SQLConnectionHandler
-from qiita_db.util import get_mountpoint, scrub_data
+from qiita_db.util import get_mountpoint, scrub_data, convert_to_id
 from qiita_db.study import Study
 from qiita_db.data import RawData
 from .base_metadata_template import BaseSample, MetadataTemplate
@@ -75,49 +75,7 @@ class SampleTemplate(MetadataTemplate):
     _id_column = "study_id"
     _sample_cls = Sample
     _filepath_table = "sample_template_filepath"
-
-    @classmethod
-    def _delete_checks(cls, id_, conn_handler=None):
-        r"""Performs the checks to know if a SampleTemplate can be deleted
-
-        A sample template cannot be removed if there is a prep template
-        referencing it.
-
-        Parameters
-        ----------
-        id_ : int
-            The sample template identifier
-        conn_handler : SQLConnectionHandler, optional
-            The connection handler connected to the DB
-
-        Raises
-        ------
-        QiitaDBExecutionError
-            If the sample template cannot be removed
-        """
-        sql = """SELECT EXISTS(
-                    SELECT *
-                    FROM qiita.prep_template
-                        JOIN qiita.study_raw_data USING (raw_data_id)
-                    WHERE study_id=%s)"""
-        exists = conn_handler.execute_fetchone(sql, (id_,))[0]
-        if exists:
-            raise QiitaDBExecutionError(
-                "Cannot remove sample template %d because a prep template "
-                "referencing to it has been already added." % id_)
-
-    @classmethod
-    def _check_template_special_columns(cls, md_template, study_id):
-        r"""Checks for special columns based on obj type
-
-        Parameters
-        ----------
-        md_template : DataFrame
-            The metadata template file contents indexed by sample ids
-        study_id : int
-            The study to which the sample template belongs to.
-        """
-        return set()
+    _filepath_type = convert_to_id("sample_template", "filepath_type")
 
     @classmethod
     def create(cls, md_template, study):
@@ -196,6 +154,49 @@ def create(cls, md_template, study):
 
         return st
 
+    @classmethod
+    def _delete_checks(cls, id_, conn_handler=None):
+        r"""Performs the checks to know if a SampleTemplate can be deleted
+
+        A sample template cannot be removed if there is a prep template
+        referencing it.
+
+        Parameters
+        ----------
+        id_ : int
+            The sample template identifier
+        conn_handler : SQLConnectionHandler, optional
+            The connection handler connected to the DB
+
+        Raises
+        ------
+        QiitaDBExecutionError
+            If the sample template cannot be removed
+        """
+        sql = """SELECT EXISTS(
+                    SELECT *
+                    FROM qiita.prep_template
+                        JOIN qiita.study_raw_data USING (raw_data_id)
+                    WHERE study_id=%s)"""
+        exists = conn_handler.execute_fetchone(sql, (id_,))[0]
+        if exists:
+            raise QiitaDBExecutionError(
+                "Cannot remove sample template %d because a prep template "
+                "referencing to it has been already added." % id_)
+
+    @classmethod
+    def _check_template_special_columns(cls, md_template, study_id):
+        r"""Checks for special columns based on obj type
+
+        Parameters
+        ----------
+        md_template : DataFrame
+            The metadata template file contents indexed by sample ids
+        study_id : int
+            The study to which the sample template belongs to.
+        """
+        return set()
+
     @property
     def study_id(self):
         """Gets the study id with which this sample template is associated
