A minimal REST API for Qiita

qiita_db/study.py

@@ -1213,6 +1213,33 @@ def exists(cls, name, affiliation):
             qdb.sql_connection.TRN.add(sql, [name, affiliation])
             return qdb.sql_connection.TRN.execute_fetchlast()
 
+    @classmethod
+    def from_name_and_affiliation(cls, name, affiliation):
+        """Gets a StudyPerson object based on the name and affiliation
+
+        Parameters
+        ----------
+        name: str
+            Name of the person
+        affiliation : str
+            institution with which the person is affiliated
+
+        Returns
+        -------
+        StudyPerson
+            The StudyPerson for the name and affiliation
+        """
+        with qdb.sql_connection.TRN:
+            if not cls.exists(name, affiliation):
+                raise qdb.exceptions.QiitaDBLookupError(
+                        'Study person does not exist')
+
+            sql = """SELECT study_person_id FROM qiita.{0}
+                        WHERE name = %s
+                     AND affiliation = %s""".format(cls._table)
+            qdb.sql_connection.TRN.add(sql, [name, affiliation])
+            return cls(int(qdb.sql_connection.TRN.execute_fetchlast()))
+
     @classmethod
     def create(cls, name, email, affiliation, address=None, phone=None):
         """Create a StudyPerson object, checking if person already exists.

qiita_db/test/test_study.py

@@ -46,6 +46,19 @@ def test_delete(self):
         self.assertFalse(
             qdb.study.StudyPerson.exists('SomeDude', 'affil'))
 
+    def test_retrieve_non_existant_people(self):
+        with self.assertRaises(qdb.exceptions.QiitaDBLookupError):
+            qdb.study.StudyPerson.from_name_and_affiliation('Boaty McBoatFace',
+                                                            'UCSD')
+
+        p = qdb.study.StudyPerson.from_name_and_affiliation('LabDude',
+                                                            'knight lab')
+        self.assertEqual(p.name, 'LabDude')
+        self.assertEqual(p.affiliation, 'knight lab')
+        self.assertEqual(p.address, '123 lab street')
+        self.assertEqual(p.phone, '121-222-3333')
+        self.assertEqual(p.email, 'lab_dude@foo.bar')
+
     def test_iter(self):
         """Make sure that each and every StudyPerson is retrieved"""
         expected = [

qiita_pet/handlers/rest/__init__.py

@@ -0,0 +1,20 @@
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014--, The Qiita Development Team.
+#
+# Distributed under the terms of the BSD 3-clause License.
+#
+# The full license is in the file LICENSE, distributed with this software.
+# -----------------------------------------------------------------------------
+
+from .study import StudyHandler, StudyCreatorHandler, StudyStatusHandler
+from .study_samples import (StudySamplesHandler, StudySamplesInfoHandler,
+                            StudySamplesCategoriesHandler)
+from .study_person import StudyPersonHandler
+from .study_preparation import (StudyPrepCreatorHandler,
+                                StudyPrepArtifactCreatorHandler)
+
+
+__all__ = ['StudyHandler', 'StudySamplesHandler', 'StudySamplesInfoHandler',
+           'StudySamplesCategoriesHandler', 'StudyPersonHandler',
+           'StudyCreatorHandler', 'StudyPrepCreatorHandler',
+           'StudyPrepArtifactCreatorHandler', 'StudyStatusHandler']

qiita_pet/handlers/rest/rest_handler.py

@@ -0,0 +1,28 @@
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014--, The Qiita Development Team.
+#
+# Distributed under the terms of the BSD 3-clause License.
+#
+# The full license is in the file LICENSE, distributed with this software.
+# -----------------------------------------------------------------------------
+from qiita_db.study import Study
+from qiita_db.exceptions import QiitaDBUnknownIDError
+from qiita_pet.handlers.util import to_int
+from qiita_pet.handlers.base_handlers import BaseHandler
+
+
+class RESTHandler(BaseHandler):
+    def fail(self, msg, status):
+        self.write({'message': msg})
+        self.set_status(status)
+        self.finish()
+
+    def study_boilerplate(self, study_id):
+        study_id = to_int(study_id)
+        s = None
+        try:
+            s = Study(study_id)
+        except QiitaDBUnknownIDError:
+            self.fail('Study not found', 404)
+        finally:
+            return s

qiita_pet/handlers/rest/study.py

@@ -0,0 +1,155 @@
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014--, The Qiita Development Team.
+#
+# Distributed under the terms of the BSD 3-clause License.
+#
+# The full license is in the file LICENSE, distributed with this software.
+# -----------------------------------------------------------------------------
+import warnings
+
+from tornado.escape import json_decode
+
+from qiita_db.handlers.oauth2 import authenticate_oauth
+from qiita_db.study import StudyPerson, Study
+from qiita_db.user import User
+from .rest_handler import RESTHandler
+from qiita_db.metadata_template.constants import SAMPLE_TEMPLATE_COLUMNS
+
+
+class StudyHandler(RESTHandler):
+
+    @authenticate_oauth
+    def get(self, study_id):
+        study = self.study_boilerplate(study_id)
+        if study is None:
+            return
+
+        info = study.info
+        pi = info['principal_investigator']
+        lp = info['lab_person']
+        self.write({'title': study.title,
+                    'contacts': {'principal_investigator': [
+                                     pi.name,
+                                     pi.affiliation,
+                                     pi.email],
+                                 'lab_person': [
+                                     lp.name,
+                                     lp.affiliation,
+                                     lp.email]},
+                    'study_abstract': info['study_abstract'],
+                    'study_description': info['study_description'],
+                    'study_alias': info['study_alias'],
+                    'efo': study.efo})
+        self.finish()
+
+
+class StudyCreatorHandler(RESTHandler):
+
+    @authenticate_oauth
+    def post(self, *args, **kwargs):
+        try:
+            payload = json_decode(self.request.body)
+        except ValueError:
+            self.fail('Could not parse body', 400)
+            return
+
+        required = {'title', 'study_abstract', 'study_description',
+                    'study_alias', 'owner', 'efo', 'contacts'}
+
+        if not required.issubset(payload):
+            self.fail('Not all required arguments provided', 400)
+            return
+
+        title = payload['title']
+        study_abstract = payload['study_abstract']
+        study_desc = payload['study_description']
+        study_alias = payload['study_alias']
+
+        owner = payload['owner']
+        if not User.exists(owner):
+            self.fail('Unknown user', 403)
+            return
+        else:
+            owner = User(owner)
+
+        efo = payload['efo']
+        contacts = payload['contacts']
+
+        if Study.exists(title):
+            self.fail('Study title already exists', 409)
+            return
+
+        pi_name = contacts['principal_investigator'][0]
+        pi_aff = contacts['principal_investigator'][1]
+        if not StudyPerson.exists(pi_name, pi_aff):
+            self.fail('Unknown principal investigator', 403)
+            return
+        else:
+            pi = StudyPerson.from_name_and_affiliation(pi_name, pi_aff)
+
+        lp_name = contacts['lab_person'][0]
+        lp_aff = contacts['lab_person'][1]
+        if not StudyPerson.exists(lp_name, lp_aff):
+            self.fail('Unknown lab person', 403)
+            return
+        else:
+            lp = StudyPerson.from_name_and_affiliation(lp_name, lp_aff)
+
+        info = {'lab_person_id': lp,
+                'principal_investigator_id': pi,
+                'study_abstract': study_abstract,
+                'study_description': study_desc,
+                'study_alias': study_alias,
+
+                # TODO: we believe it is accurate that mixs is false and
+                # metadata completion is false as these cannot be known
+                # at study creation here no matter what.
+                # we do not know what should be done with the timeseries.
+                'mixs_compliant': False,
+                'metadata_complete': False,
+                'timeseries_type_id': 1}
+        study = Study.create(owner, title, efo, info)
+
+        self.set_status(201)
+        self.write({'id': study.id})
+        self.finish()
+
+
+class StudyStatusHandler(RESTHandler):
+    @authenticate_oauth
+    def get(self, study_id):
+        study = self.study_boilerplate(study_id)
+        if study is None:
+            return
+
+        public = study.status == 'public'
+        st = study.sample_template
+        sample_information = st is not None
+        if sample_information:
+            with warnings.catch_warnings():
+                try:
+                    st.validate(SAMPLE_TEMPLATE_COLUMNS)
+                except Warning:
+                    sample_information_warnings = True
+                else:
+                    sample_information_warnings = False
+        else:
+            sample_information_warnings = False
+
+        preparations = []
+        for prep in study.prep_templates():
+            pid = prep.id
+            art = prep.artifact is not None
+            # TODO: unclear how to test for warnings on the preparations as
+            # it requires knowledge of the preparation type. It is possible
+            # to tease this out, but it replicates code present in
+            # PrepTemplate.create
+            preparations.append({'id': pid, 'has_artifact': art})
+
+        self.write({'is_public': public,
+                    'has_sample_information': sample_information,
+                    'sample_information_has_warnings':
+                        sample_information_warnings,
+                    'preparations': preparations})
+        self.set_status(200)
+        self.finish()

qiita_pet/handlers/rest/study_person.py

@@ -0,0 +1,49 @@
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014--, The Qiita Development Team.
+#
+# Distributed under the terms of the BSD 3-clause License.
+#
+# The full license is in the file LICENSE, distributed with this software.
+# -----------------------------------------------------------------------------
+
+from qiita_db.handlers.oauth2 import authenticate_oauth
+from qiita_db.study import StudyPerson
+from qiita_db.exceptions import QiitaDBLookupError
+from .rest_handler import RESTHandler
+
+
+class StudyPersonHandler(RESTHandler):
+    @authenticate_oauth
+    def get(self, *args, **kwargs):
+        name = self.get_argument('name')
+        affiliation = self.get_argument('affiliation')
+
+        try:
+            p = StudyPerson.from_name_and_affiliation(name, affiliation)
+        except QiitaDBLookupError:
+            self.fail('Person not found', 404)
+            return
+
+        self.write({'address': p.address, 'phone': p.phone, 'email': p.email,
+                    'id': p.id})
+        self.finish()
+
+    @authenticate_oauth
+    def post(self, *args, **kwargs):
+        name = self.get_argument('name')
+        affiliation = self.get_argument('affiliation')
+        email = self.get_argument('email')
+
+        phone = self.get_argument('phone', None)
+        address = self.get_argument('address', None)
+
+        if StudyPerson.exists(name, affiliation):
+            self.fail('Person already exists', 409)
+            return
+
+        p = StudyPerson.create(name=name, affiliation=affiliation, email=email,
+                               phone=phone, address=address)
+
+        self.set_status(201)
+        self.write({'id': p.id})
+        self.finish()

qiita_pet/handlers/rest/study_preparation.py

@@ -0,0 +1,87 @@
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014--, The Qiita Development Team.
+#
+# Distributed under the terms of the BSD 3-clause License.
+#
+# The full license is in the file LICENSE, distributed with this software.
+# -----------------------------------------------------------------------------
+
+import os
+
+import pandas as pd
+from tornado.escape import json_decode
+
+from qiita_db.util import get_mountpoint
+from qiita_db.artifact import Artifact
+from qiita_pet.handlers.util import to_int
+from qiita_db.exceptions import QiitaDBUnknownIDError, QiitaError
+from qiita_db.metadata_template.prep_template import PrepTemplate
+from qiita_db.handlers.oauth2 import authenticate_oauth
+from .rest_handler import RESTHandler
+
+
+class StudyPrepCreatorHandler(RESTHandler):
+    # TODO: do something smart about warnings, perhaps this should go in its
+    # own endpoint i.e. /api/v1/study/<int>/preparation/validate
+
+    @authenticate_oauth
+    def post(self, study_id, *args, **kwargs):
+        data_type = self.get_argument('data_type')
+        investigation_type = self.get_argument('investigation_type', None)
+
+        study_id = self.study_boilerplate(study_id)
+        if study_id is None:
+            return
+
+        data = pd.DataFrame.from_dict(json_decode(self.request.body),
+                                      orient='index')
+
+        try:
+            p = PrepTemplate.create(data, study_id, data_type,
+                                    investigation_type)
+        except QiitaError as e:
+            self.fail(e.message, 406)
+            return
+
+        self.write({'id': p.id})
+        self.set_status(201)
+        self.finish()
+
+
+class StudyPrepArtifactCreatorHandler(RESTHandler):
+
+    @authenticate_oauth
+    def post(self, study_id, prep_id):
+        study = self.study_boilerplate(study_id)
+        if study is None:
+            return
+
+        prep_id = to_int(prep_id)
+        try:
+            p = PrepTemplate(prep_id)
+        except QiitaDBUnknownIDError:
+            self.fail('Preparation not found', 404)
+            return
+
+        if p.study_id != study.id:
+            self.fail('Preparation ID not associated with the study', 409)
+            return
+
+        artifact_deets = json_decode(self.request.body)
+        _, upload = get_mountpoint('uploads')[0]
+        base = os.path.join(upload, study_id)
+        filepaths = [(os.path.join(base, fp), fp_type)
+                     for fp, fp_type in artifact_deets['filepaths']]
+
+        try:
+            art = Artifact.create(filepaths,
+                                  artifact_deets['artifact_type'],
+                                  artifact_deets['artifact_name'],
+                                  p)
+        except QiitaError as e:
+            self.fail(e.message, 406)
+            return
+
+        self.write({'id': art.id})
+        self.set_status(201)
+        self.finish()