Admin actions

qiita_pet/handlers/api_proxy/__init__.py

@@ -24,7 +24,8 @@
     ena_ontology_get_req, prep_template_samples_get_req)
 from .studies import (
     data_types_get_req, study_get_req, study_prep_get_req, study_delete_req)
-from .artifact import artifact_graph_get_req
+from .artifact import (artifact_graph_get_req, artifact_get_req,
+                       artifact_status_put_req, artifact_delete_req)
 
 __all__ = ['prep_template_summary_get_req', 'sample_template_post_req',
            'sample_template_put_req', 'data_types_get_req',
@@ -33,7 +34,8 @@
            'prep_template_summary_get_req', 'prep_template_post_req',
            'prep_template_put_req', 'prep_template_delete_req',
            'prep_template_graph_get_req', 'prep_template_filepaths_get_req',
-           'artifact_get_graph', 'prep_template_get_req', 'study_delete_req',
+           'artifact_get_req', 'artifact_status_put_req',
+           'artifact_delete_req', 'prep_template_get_req', 'study_delete_req',
            'study_prep_get_req', 'sample_template_get_req',
            'artifact_graph_get_req', 'ena_ontology_get_req',
            'sample_template_meta_cats_get_req',

qiita_pet/handlers/api_proxy/artifact.py

@@ -6,6 +6,10 @@
 # The full license is in the file LICENSE, distributed with this software.
 # -----------------------------------------------------------------------------
 from qiita_db.artifact import Artifact
+from qiita_db.user import User
+from qiita_db.exceptions import (QiitaDBOperationNotPermittedError,
+                                 QiitaDBArtifactDeletionError)
+from qiita_core.qiita_settings import qiita_config
 from qiita_pet.handlers.api_proxy.util import check_access
 
 
@@ -53,3 +57,136 @@ def artifact_graph_get_req(artifact_id, direction, user_id):
             'node_labels': node_labels,
             'status': 'success',
             'message': ''}
+
+
+def artifact_get_req(artifact_id, user_id):
+    """Get information about the artifact
+
+    Parameters
+    ----------
+    artifact_id : int
+        Artifact being acted on
+    user_id : str
+        The user requesting the action
+
+    Returns
+    -------
+    dict
+        information about the artifact
+    """
+    pd = Artifact(int(artifact_id))
+    access_error = check_access(pd.study.id, user_id)
+    if access_error:
+        return access_error
+
+    try:
+        can_be_submitted_to_ebi = pd.can_be_submitted_to_ebi
+        ebi_run_accessions = pd.ebi_run_accessions
+    except QiitaDBOperationNotPermittedError:
+        can_be_submitted_to_ebi = False
+        ebi_run_accessions = None
+
+    try:
+        can_be_submitted_to_vamps = pd.can_be_submitted_to_vamps
+        is_submitted_to_vamps = pd.is_submitted_to_vamps
+    except QiitaDBOperationNotPermittedError:
+        can_be_submitted_to_vamps = False
+        is_submitted_to_vamps = False
+
+    return {
+        'timestamp': pd.timestamp,
+        'processing_parameters': pd.processing_parameters,
+        'visibility': pd.visibility,
+        'artifact_type': pd.artifact_type,
+        'data_type': pd.data_type,
+        'can_be_submitted_to_ebi': can_be_submitted_to_ebi,
+        'can_be_submitted_to_vamps': can_be_submitted_to_vamps,
+        'is_submitted_to_vamps': is_submitted_to_vamps,
+        'filepaths': pd.filepaths,
+        'parents': [a.id for a in pd.parents],
+        'prep_templates': [p.id for p in pd.prep_templates],
+        'ebi_run_accessions': ebi_run_accessions,
+        'study': pd.study.id}
+
+
+def artifact_delete_req(artifact_id, user_id):
+    """Deletes the artifact
+
+    Parameters
+    ----------
+    artifact_id : int
+        Artifact being acted on
+    user_id : str
+        The user requesting the action
+
+    Returns
+    -------
+    dict
+        Status of action, in the form {'status': status, 'message': msg}
+        status: status of the action, either success or error
+        message: Human readable message for status
+    """
+    pd = Artifact(int(artifact_id))
+    access_error = check_access(pd.study.id, user_id)
+    if access_error:
+        return access_error
+    try:
+        Artifact.delete(int(artifact_id))
+    except QiitaDBArtifactDeletionError as e:
+        return {'status': 'error',
+                'message': str(e)}
+    return {'status': 'success',
+            'message': ''}
+
+
+def artifact_status_put_req(artifact_id, user_id, visibility):
+    """Set the status of the artifact given
+
+    Parameters
+    ----------
+    artifact_id : int
+        Artifact being acted on
+    user_id : str
+        The user requesting the action
+    visibility : {'sandbox', 'awaiting_approval', 'private', 'public'}
+        What to change the visibility to
+
+    Returns
+    -------
+    dict
+        Status of action, in the form {'status': status, 'message': msg}
+        status: status of the action, either success or error
+        message: Human readable message for status
+    """
+    if visibility not in {'sandbox', 'awaiting_approval', 'private', 'public'}:
+        return {'status': 'error',
+                'message': 'Unknown visiblity value: %s' % visibility}
+
+    pd = Artifact(int(artifact_id))
+    access_error = check_access(pd.study.id, user_id)
+    if access_error:
+        return access_error
+    user = User(str(user_id))
+    # Set the approval to private if needs approval and admin
+    if all([qiita_config.require_approval, visibility == 'private',
+            user.level == 'admin']):
+        pd.visibility = 'private'
+        status = 'success'
+        msg = 'Artifact visibility changed to private'
+    # Set the approval to private if approval not required
+    elif all([not qiita_config.require_approval,
+              visibility == 'private']):
+        pd.visibility = 'private'
+        status = 'success'
+        msg = 'Artifact visibility changed to private'
+    # Trying to set approval without admin privileges
+    elif visibility == 'private':
+        status = 'error'
+        msg = 'User does not have permissions to approve change'
+    else:
+        pd.visibility = visibility
+        status = 'success'
+        msg = 'Artifact visibility changed to %s' % visibility
+
+    return {'status': status,
+            'message': msg}

qiita_pet/handlers/api_proxy/tests/test_artifact.py

@@ -6,11 +6,103 @@
 # The full license is in the file LICENSE, distributed with this software.
 # -----------------------------------------------------------------------------
 from unittest import TestCase, main
+from datetime import datetime
+from os.path import join
 
-from qiita_pet.handlers.api_proxy.artifact import artifact_graph_get_req
+from qiita_core.util import qiita_test_checker
+from qiita_core.qiita_settings import qiita_config
+from qiita_db.artifact import Artifact
+from qiita_db.exceptions import QiitaDBUnknownIDError
+from qiita_pet.handlers.api_proxy.artifact import (
+    artifact_get_req, artifact_status_put_req, artifact_graph_get_req,
+    artifact_delete_req)
 
 
+@qiita_test_checker()
 class TestArtifactAPI(TestCase):
+    def tearDown(self):
+        Artifact(1).visibility = 'private'
+
+    def test_artifact_get_req(self):
+        obs = artifact_get_req(1, 'test@foo.bar')
+        exp = {'is_submitted_to_vamps': False,
+               'data_type': '18S',
+               'can_be_submitted_to_vamps': False,
+               'can_be_submitted_to_ebi': False,
+               'timestamp': datetime(2012, 10, 1, 9, 30, 27),
+               'prep_templates': [1],
+               'visibility': 'private',
+               'study': 1,
+               'processing_parameters': None,
+               'ebi_run_accessions': None,
+               'parents': [],
+               'filepaths': [
+                   (1, join(qiita_config.base_data_dir,
+                            'raw_data/1_s_G1_L001_sequences.fastq.gz'),
+                    'raw_forward_seqs'),
+                   (2, join(qiita_config.base_data_dir,
+                            'raw_data/1_s_G1_L001_sequences_barcodes.'
+                            'fastq.gz'),
+                    'raw_barcodes')],
+               'artifact_type': 'FASTQ'}
+        self.assertEqual(obs, exp)
+
+    def test_artifact_get_req_no_access(self):
+        obs = artifact_get_req(1, 'demo@microbio.me')
+        exp = {'status': 'error',
+               'message': 'User does not have access to study'}
+        self.assertEqual(obs, exp)
+
+    def test_artifact_delete_req(self):
+        obs = artifact_delete_req(3, 'test@foo.bar')
+        exp = {'status': 'success', 'message': ''}
+        self.assertEqual(obs, exp)
+
+        with self.assertRaises(QiitaDBUnknownIDError):
+            Artifact(3)
+
+    def test_artifact_delete_req_error(self):
+        obs = artifact_delete_req(1, 'test@foo.bar')
+        exp = {'status': 'error',
+               'message': 'Cannot delete artifact 1: it has children: 2, 3'}
+        self.assertEqual(obs, exp)
+
+    def test_artifact_delete_req_no_access(self):
+        obs = artifact_delete_req(3, 'demo@microbio.me')
+        exp = {'status': 'error',
+               'message': 'User does not have access to study'}
+        self.assertEqual(obs, exp)
+
+    def test_artifact_status_put_req(self):
+        obs = artifact_status_put_req(1, 'test@foo.bar', 'sandbox')
+        exp = {'status': 'success',
+               'message': 'Artifact visibility changed to sandbox'}
+        self.assertEqual(obs, exp)
+
+    def test_artifact_status_put_req_private(self):
+        obs = artifact_status_put_req(1, 'admin@foo.bar', 'private')
+        exp = {'status': 'success',
+               'message': 'Artifact visibility changed to private'}
+        self.assertEqual(obs, exp)
+
+    def test_artifact_status_put_req_private_bad_permissions(self):
+        obs = artifact_status_put_req(1, 'test@foo.bar', 'private')
+        exp = {'status': 'error',
+               'message': 'User does not have permissions to approve change'}
+        self.assertEqual(obs, exp)
+
+    def test_artifact_status_put_req_no_access(self):
+        obs = artifact_status_put_req(1, 'demo@microbio.me', 'sandbox')
+        exp = {'status': 'error',
+               'message': 'User does not have access to study'}
+        self.assertEqual(obs, exp)
+
+    def test_artifact_status_put_req_unknown_status(self):
+        obs = artifact_status_put_req(1, 'test@foo.bar', 'BADSTAT')
+        exp = {'status': 'error',
+               'message': 'Unknown visiblity value: BADSTAT'}
+        self.assertEqual(obs, exp)
+
     def test_artifact_graph_get_req_ancestors(self):
         obs = artifact_graph_get_req(1, 'ancestors', 'test@foo.bar')
         exp = {'status': 'success',
@@ -23,25 +115,24 @@ def test_artifact_graph_get_req_descendants(self):
         obs = artifact_graph_get_req(1, 'descendants', 'test@foo.bar')
         exp = {'status': 'success',
                'message': '',
-               'edge_list': [(1, 3), (1, 2), (2, 4)],
                'node_labels': [(1, 'Raw data 1 - FASTQ'),
                                (3, 'Demultiplexed 2 - Demultiplexed'),
                                (2, 'Demultiplexed 1 - Demultiplexed'),
-                               (4, 'BIOM - BIOM')]}
-        self.assertEqual(obs, exp)
-
-    def test_artifact_graph_get_req_bad(self):
-        obs = artifact_graph_get_req(1, 'UNKNOWN', 'test@foo.bar')
-        exp = {'status': 'error',
-               'message': 'Unknown directon UNKNOWN'}
+                               (4, 'BIOM - BIOM')],
+               'edge_list': [(1, 3), (1, 2), (2, 4)]}
         self.assertEqual(obs, exp)
 
     def test_artifact_graph_get_req_no_access(self):
-        obs = artifact_graph_get_req(1, 'descendants', 'demo@microbio.me')
+        obs = artifact_graph_get_req(1, 'ancestors', 'demo@microbio.me')
         exp = {'status': 'error',
                'message': 'User does not have access to study'}
         self.assertEqual(obs, exp)
 
+    def test_artifact_graph_get_req_bad_direction(self):
+        obs = artifact_graph_get_req(1, 'WRONG', 'test@foo.bar')
+        exp = {'status': 'error', 'message': 'Unknown directon WRONG'}
+        self.assertEqual(obs, exp)
+
 
 if __name__ == "__main__":
     main()

qiita_pet/handlers/api_proxy/tests/test_sample_template.py

@@ -9,7 +9,6 @@
 from os.path import join, exists
 
 from qiita_core.util import qiita_test_checker
-from qiita_core.qiita_settings import qiita_config
 import qiita_db as qdb
 from qiita_pet.handlers.api_proxy.sample_template import (
     sample_template_summary_get_req, sample_template_post_req,
@@ -21,34 +20,34 @@
 
 @qiita_test_checker()
 class TestSampleAPI(TestCase):
-    info = {
-        "timeseries_type_id": 1,
-        "metadata_complete": True,
-        "mixs_compliant": True,
-        "number_samples_collected": 25,
-        "number_samples_promised": 28,
-        "study_alias": "FCM",
-        "study_description": "DESC",
-        "study_abstract": "ABS",
-        "emp_person_id": qdb.study.StudyPerson(2),
-        "principal_investigator_id": qdb.study.StudyPerson(3),
-        "lab_person_id": qdb.study.StudyPerson(1)
+    def setUp(self):
+        info = {
+            "timeseries_type_id": 1,
+            "metadata_complete": True,
+            "mixs_compliant": True,
+            "number_samples_collected": 25,
+            "number_samples_promised": 28,
+            "study_alias": "FCM",
+            "study_description": "DESC",
+            "study_abstract": "ABS",
+            "emp_person_id": qdb.study.StudyPerson(2),
+            "principal_investigator_id": qdb.study.StudyPerson(3),
+            "lab_person_id": qdb.study.StudyPerson(1)
         }
 
-    new_study = qdb.study.Study.create(
-        qdb.user.User('test@foo.bar'), "Some New Study", [1],
-        info)
+        self.new_study = qdb.study.Study.create(
+            qdb.user.User('test@foo.bar'), "Some New Study", [1],
+            info)
 
-    def setUp(self):
-        fp = join(qiita_config.base_data_dir, 'uploads',
-                  str(self.new_study.id), 'uploaded_file.txt')
+        base_dir = qdb.util.get_mountpoint('uploads')[0][1]
+        fp = join(base_dir, str(self.new_study.id), 'uploaded_file.txt')
         if not exists(fp):
             with open(fp, 'w') as f:
                 f.write('')
 
     def tearDown(self):
-        fp = join(qiita_config.base_data_dir, 'uploads', '1',
-                  'uploaded_file.txt')
+        base_dir = qdb.util.get_mountpoint('uploads')[0][1]
+        fp = join(base_dir, '1', 'uploaded_file.txt')
         if not exists(fp):
             with open(fp, 'w') as f:
                 f.write('')

qiita_pet/handlers/api_proxy/tests/test_studies.py

@@ -14,7 +14,7 @@
     data_types_get_req, study_get_req, study_prep_get_req, study_delete_req)
 
 
-@qiita_test_checker
+@qiita_test_checker()
 class TestStudyAPI(TestCase):
     def test_data_types_get_req(self):
         obs = data_types_get_req()

qiita_pet/handlers/study_handlers/__init__.py

@@ -15,13 +15,13 @@
 from .vamps_handlers import VAMPSHandler
 from .base import StudyIndexHandler, StudyBaseInfoAJAX, StudyDeleteAjax
 from .prep_template import PrepTemplateGraphAJAX, PrepTemplateAJAX
-from .artifact import ArtifactGraphAJAX
+from .artifact import ArtifactGraphAJAX, ArtifactAdminAJAX, ArtifactAJAX
 from .sample_template import SampleTemplateAJAX, SampleAJAX
 
 __all__ = ['ListStudiesHandler', 'StudyApprovalList', 'ShareStudyAJAX',
            'StudyEditHandler', 'CreateStudyAJAX', 'StudyDescriptionHandler',
            'PreprocessingSummaryHandler', 'EBISubmitHandler',
            'MetadataSummaryHandler', 'VAMPSHandler', 'SearchStudiesAJAX',
-           'PrepTemplateGraphAJAX', 'ArtifactGraphAJAX',
+           'PrepTemplateGraphAJAX', 'ArtifactGraphAJAX', 'ArtifactAdminAJAX',
            'StudyIndexHandler', 'StudyBaseInfoAJAX', 'SampleTemplateAJAX',
-           'PrepTemplateAJAX', 'SampleAJAX', 'StudyDeleteAjax']
+           'PrepTemplateAJAX', 'SampleAJAX', 'StudyDeleteAjax', 'ArtifactAJAX']