Merge pull request #412 from wasade/issue_246

Issue 246

Author: charles-cowart

.travis.yml

@@ -31,7 +31,7 @@ install:
   - travis_retry conda create -q --yes -n qiita python=3.6 pip libgfortran numpy nginx
   - source activate qiita
   - pip install sphinx sphinx-bootstrap-theme coveralls
-  - pip install https://github.com/antgonza/qiita/archive/conditional-labman.zip --no-binary redbiom
+  - pip install https://github.com/biocore/qiita/archive/dev.zip --no-binary redbiom
   # as we don't need redbiom we are going to use the default redis port
   - sed 's/PORT = 7777/PORT = 6379/g' $HOME/miniconda3/envs/qiita/lib/python3.6/site-packages/qiita_core/support_files/config_test.cfg > config_test.cfg
   - export QIITA_CONFIG_FP=${PWD}/config_test.cfg
@@ -71,6 +71,7 @@ install:
   # Verify db population
   # TODO: extend to labman schema
   - psql -d qiita_test -c 'select * from qiita.study;'
+  - labman patch
 script:
   - nosetests --with-doctest --with-coverage -v --cover-package=labman
   - flake8 labman setup.py scripts/*

labman/db/environment.py

@@ -0,0 +1,73 @@
+# ----------------------------------------------------------------------------
+# Copyright (c) 2017-, labman development team.
+#
+# Distributed under the terms of the Modified BSD License.
+#
+# The full license is in the file LICENSE, distributed with this software.
+# ----------------------------------------------------------------------------
+from os.path import join, dirname, abspath, basename, splitext, exists
+from glob import glob
+from functools import partial
+
+from natsort import natsorted
+
+from labman.db import sql_connection
+
+
+def patch_database(verbose):
+    """Apply patches, if necessary, to the database"""
+    get_support_file = partial(join, join(dirname(abspath(__file__)),
+                                          'support_files'))
+    patches_dir = get_support_file('patches')
+
+    with sql_connection.TRN:
+        sql_connection.TRN.add("SELECT current_patch FROM labman.settings")
+        try:
+            current_patch = sql_connection.TRN.execute_fetchlast()
+        except ValueError:
+            # the system doesn't have the settings table so is unpatched
+            current_patch = 'unpatched'
+
+        current_sql_patch_fp = join(patches_dir, current_patch)
+        corresponding_py_patch = partial(join, patches_dir, 'python_patches')
+
+        sql_glob = join(patches_dir, '*.sql')
+        sql_patch_files = natsorted(glob(sql_glob))
+
+        if current_patch == 'unpatched':
+            next_patch_index = 0
+            sql_connection.TRN.add("""CREATE TABLE labman.settings
+                                      (current_patch varchar not null)""")
+            sql_connection.TRN.add("""INSERT INTO labman.settings
+                                      (current_patch) VALUES ('unpatched')""")
+            sql_connection.TRN.execute()
+        elif current_sql_patch_fp not in sql_patch_files:
+            raise RuntimeError("Cannot find patch file %s" % current_patch)
+        else:
+            next_patch_index = sql_patch_files.index(current_sql_patch_fp) + 1
+
+    patch_update_sql = "UPDATE labman.settings SET current_patch = %s"
+
+    for sql_patch_fp in sql_patch_files[next_patch_index:]:
+        sql_patch_filename = basename(sql_patch_fp)
+
+        py_patch_fp = corresponding_py_patch(
+            splitext(basename(sql_patch_fp))[0] + '.py')
+        py_patch_filename = basename(py_patch_fp)
+
+        with sql_connection.TRN:
+            with open(sql_patch_fp, newline=None) as patch_file:
+                if verbose:
+                    print('\tApplying patch %s...' % sql_patch_filename)
+                sql_connection.TRN.add(patch_file.read())
+                sql_connection.TRN.add(
+                    patch_update_sql, [sql_patch_filename])
+
+            sql_connection.TRN.execute()
+
+            if exists(py_patch_fp):
+                if verbose:
+                    print('\t\tApplying python patch %s...'
+                          % py_patch_filename)
+                with open(py_patch_fp) as py_patch:
+                    exec(py_patch.read(), globals())

labman/db/plate.py

@@ -198,7 +198,8 @@ def list_plates(plate_types=None, only_quantified=False,
         -------
         list of dicts
             The list of plate information with the structure:
-            [{'plate_id': int, 'external_id': string}]
+            [{'plate_id': int, 'external_id': string,
+              'creation_timestamp': datetime}]
         """
         with sql_connection.TRN as TRN:
             sql_where, sql_discard, sql_plate_types = '', '', ''
@@ -232,8 +233,9 @@ def list_plates(plate_types=None, only_quantified=False,
                 sql_studies = (', labman.get_plate_studies(p.plate_id) '
                                'AS studies')
 
-            sql = """SELECT p.plate_id, p.external_id {}
-                        FROM (SELECT DISTINCT plate_id, external_id
+            sql = """SELECT p.plate_id, p.external_id, p.creation_timestamp {}
+                        FROM (SELECT DISTINCT plate_id, external_id,
+                                              creation_timestamp
                               FROM labman.plate
                                 JOIN labman.well USING (plate_id)
                                 JOIN labman.composition USING (container_id)
@@ -244,7 +246,13 @@ def list_plates(plate_types=None, only_quantified=False,
                      ORDER BY plate_id""".format(sql_studies, sql_join,
                                                  sql_where)
             TRN.add(sql, sql_args)
-            return [dict(r) for r in TRN.execute_fetchindex()]
+
+            results = []
+            for r in TRN.execute_fetchindex():
+                r = dict(r)
+                r['creation_timestamp'] = str(r['creation_timestamp'])
+                results.append(r)
+            return results
 
     @staticmethod
     def external_id_exists(external_id):
@@ -290,6 +298,10 @@ def create(cls, external_id, plate_configuration):
             TRN.add(sql, [external_id, plate_configuration.id])
             return cls(TRN.execute_fetchlast())
 
+    @property
+    def creation_timestamp(self):
+        return self._get_attr('creation_timestamp')
+
     @property
     def external_id(self):
         """The plate external identifier"""

labman/db/support_files/patches/1.sql

@@ -0,0 +1,3 @@
+-- April 2, 2019
+-- Implicitly track the date and time of plate creation
+ALTER TABLE labman.plate ADD COLUMN creation_timestamp timestamp NOT NULL default now();

labman/db/testing.py

@@ -13,6 +13,7 @@
 from qiita_client import QiitaClient
 
 import labman
+from labman.db.environment import patch_database
 
 
 def reset_test_db():
@@ -52,8 +53,18 @@ def reset_test_db():
             TRN.add(f.read())
         TRN.execute()
 
+    patch_database(verbose=False)
+
 
 class LabmanTestCase(TestCase):
+    _perform_reset = True
+
+    def do_not_reset_at_teardown(self):
+        self.__class__._perform_reset = False
+
     @classmethod
     def tearDownClass(cls):
-        reset_test_db()
+        if cls._perform_reset:
+            reset_test_db()
+        else:
+            cls._perform_reset = True

labman/db/tests/test_plate.py

@@ -8,6 +8,7 @@
 
 from unittest import main
 from types import GeneratorType
+import datetime
 
 from labman.db.testing import LabmanTestCase
 from labman.db.plate import PlateConfiguration, Plate
@@ -92,9 +93,20 @@ def test_search(self):
             Plate.search(plate_notes='interesting', well_notes='write',
                          query_type='UNION'), [plate22, plate23])
 
+    def strip_out_creation_timestamp(self, plates):
+        """Kludge to remove creation_timestamp from plate list results"""
+        obs_ = []
+        for o in plates:
+            o = o.copy()
+            self.assertIn('creation_timestamp', o)
+            o.pop('creation_timestamp')
+            obs_.append(o)
+        return obs_
+
     def test_list_plates(self):
         # Test returning all plates
-        obs = Plate.list_plates()
+        obs = self.strip_out_creation_timestamp(Plate.list_plates())
+
         # We are creating plates below, but at least we know there are 35
         # plates in the test database
         self.assertGreaterEqual(len(obs), 35)
@@ -107,11 +119,12 @@ def test_list_plates(self):
                                    'external_id': 'Test plate 1'})
 
         # Test returning sample plates
-        obs = Plate.list_plates(['sample'])
+        obs = self.strip_out_creation_timestamp(Plate.list_plates(['sample']))
         self.assertGreaterEqual(len(obs), 4)
         self.assertEqual(obs[0], {'plate_id': 21,
                                   'external_id': 'Test plate 1'})
-        obs = Plate.list_plates(['sample'], include_study_titles=True)
+        obs = self.strip_out_creation_timestamp(Plate.list_plates(['sample'],
+                                                include_study_titles=True))
         self.assertGreaterEqual(len(obs), 4)
         self.assertEqual(
             obs[0], {'plate_id': 21,
@@ -120,21 +133,22 @@ def test_list_plates(self):
                                  'for Cannabis Soils']})
 
         # Test returning gDNA plates
-        obs = Plate.list_plates(['gDNA'])
+        obs = self.strip_out_creation_timestamp(Plate.list_plates(['gDNA']))
         self.assertEqual(
             obs, [{'plate_id': 22,
                    'external_id': 'Test gDNA plate 1'},
                   {'external_id': 'Test gDNA plate 2', 'plate_id': 28},
                   {'external_id': 'Test gDNA plate 3', 'plate_id': 31},
                   {'external_id': 'Test gDNA plate 4', 'plate_id': 34}])
 
-        obs = Plate.list_plates(['compressed gDNA'])
+        obs = self.strip_out_creation_timestamp(
+            Plate.list_plates(['compressed gDNA']))
         self.assertEqual(
             obs, [{'plate_id': 24,
                    'external_id': 'Test compressed gDNA plates 1-4'}])
 
         # Test returning primer plates
-        obs = Plate.list_plates(['primer'])
+        obs = self.strip_out_creation_timestamp(Plate.list_plates(['primer']))
         exp = [
             {'plate_id': 11,
              'external_id': 'EMP 16S V4 primer plate 1 10/23/2017'},
@@ -157,7 +171,8 @@ def test_list_plates(self):
         self.assertEqual(obs, exp)
 
         # Test returning gDNA and compressed gDNA plates
-        obs = Plate.list_plates(['gDNA', 'compressed gDNA'])
+        obs = self.strip_out_creation_timestamp(
+            Plate.list_plates(['gDNA', 'compressed gDNA']))
         self.assertEqual(
             obs, [{'plate_id': 22,
                    'external_id': 'Test gDNA plate 1'},
@@ -168,25 +183,38 @@ def test_list_plates(self):
                   {'external_id': 'Test gDNA plate 4', 'plate_id': 34}
                   ])
 
-        obs = Plate.list_plates(['compressed gDNA', 'normalized gDNA'])
+        obs = self.strip_out_creation_timestamp(
+            Plate.list_plates(['compressed gDNA', 'normalized gDNA']))
         self.assertEqual(
             obs, [{'plate_id': 24,
                    'external_id': 'Test compressed gDNA plates 1-4'},
                   {'plate_id': 25,
                    'external_id': 'Test normalized gDNA plates 1-4'}])
 
-        obs = Plate.list_plates(['compressed gDNA', 'normalized gDNA'],
-                                only_quantified=True,
-                                include_study_titles=True)
+        obs = self.strip_out_creation_timestamp(
+            Plate.list_plates(['compressed gDNA', 'normalized gDNA'],
+                              only_quantified=True,
+                              include_study_titles=True))
         self.assertEqual(
             obs, [{'plate_id': 24,
                    'external_id': 'Test compressed gDNA plates 1-4',
                    'studies': ['Identification of the Microbiomes '
                                'for Cannabis Soils']}])
 
+    def test_plate_list_include_timestamp(self):
+        # ...limit pathological failures by testing within an hour of creation
+        exp = datetime.datetime.now()
+        exp = str(datetime.datetime(exp.year,
+                                    exp.month,
+                                    exp.day)).split(None, 1)[0]
+
+        for i in Plate.list_plates():
+            obs = i['creation_timestamp'].split(None, 1)[0]
+            self.assertEqual(obs, exp)
+
     def test_plate_list_discarded_functionality(self):
         # test case based on the test_list_plates
-        obs = Plate.list_plates()
+        obs = self.strip_out_creation_timestamp(Plate.list_plates())
         Plate(21).discard = True
         self.assertGreaterEqual(len(obs), 25)
         self.assertEqual(obs[0], {'plate_id': 1,
@@ -202,7 +230,8 @@ def test_plate_list_discarded_functionality(self):
         Plate(11).discarded = True
         Plate(12).discarded = True
         Plate(13).discarded = True
-        obs = Plate.list_plates(['primer'], include_discarded=False)
+        obs = self.strip_out_creation_timestamp(Plate.list_plates(['primer'],
+                                                include_discarded=False))
 
         exp = [
             {'plate_id': 14,
@@ -220,7 +249,8 @@ def test_plate_list_discarded_functionality(self):
         self.assertEqual(obs, exp)
 
         # Test returning discarded primer plates
-        obs = Plate.list_plates(['primer'], include_discarded=True)
+        obs = self.strip_out_creation_timestamp(Plate.list_plates(['primer'],
+                                                include_discarded=True))
         exp = [
             {'plate_id': 11,
              'external_id': 'EMP 16S V4 primer plate 1 10/23/2017'},
@@ -268,6 +298,14 @@ def test_create(self):
     def test_properties(self):
         # Plate 21 - Defined in the test DB
         tester = Plate(21)
+
+        obs = tester.creation_timestamp
+        obs = str(datetime.datetime(obs.year,
+                                    obs.month,
+                                    obs.day))
+        exp = datetime.datetime.now()
+        exp = str(datetime.datetime(exp.year, exp.month, exp.day))
+        self.assertEqual(obs, exp)
         self.assertEqual(tester.external_id, 'Test plate 1')
         self.assertEqual(tester.plate_configuration, PlateConfiguration(1))
         self.assertFalse(tester.discarded)

labman/gui/handlers/plate.py

@@ -81,7 +81,9 @@ def get(self):
                       if plate_type is not None else None)
         only_quantified = True if only_quantified == 'true' else False
 
-        rows_list = [[p['plate_id'], p['external_id'],
+        rows_list = [[p['plate_id'],
+                      p['external_id'],
+                      p['creation_timestamp'],
                       p['studies'] if p['studies'] is not None else []]
                      for p in Plate.list_plates(
                             plate_type, only_quantified=only_quantified,

labman/gui/templates/plate_list.html

@@ -105,9 +105,10 @@
           var deleteButton = '<button onclick="discardPlate(' + row[0] + ', this)" class="btn btn-danger">Discard Plate ' +
                                '<span class="glyphicon glyphicon-remove" data-toggle="tooltip" title="Discard plate"></span>' +
                              '</button> ';
-          // row[0] = plate id, row[1] = external id, row[2] = list of names of
-          // studies associated with any sample on plate (may be empty list)
-          newData.push([chBox, row[0], row[1], row[2].join('<br />'), deleteButton]);
+          // row[0] = plate id, row[1] = external id, row[2] = creation 
+          // timestamprow[3] = list of names of studies associated with any 
+          // sample on plate (may be empty list)
+          newData.push([chBox, row[0], row[1], row[2], row[3].join('<br />'), deleteButton]);
         }
         datatable.clear();
         datatable.rows.add(newData);
@@ -159,6 +160,7 @@
       <th></th>
       <th>Plate id</th>
       <th>Plate name</th>
+      <th>Creation timestamp</th>
       <th>Studies</th>
       <th></th>
     </tr>