Initial classification commit

Author: nagem

api/api.py

@@ -7,6 +7,7 @@
 from .handlers.confighandler      import Config, Version
 from .handlers.containerhandler   import ContainerHandler
 from .handlers.devicehandler      import DeviceHandler
+from .handlers.modalityhandler    import ModalityHandler
 from .handlers.grouphandler       import GroupHandler
 from .handlers.listhandler        import AnalysesHandler, ListHandler, FileListHandler, NotesListHandler, PermissionsListHandler, TagsListHandler
 from .handlers.reporthandler      import ReportHandler
@@ -167,6 +168,14 @@ def prefix(path, routes):
             route('/<device_id:[^/]+>', DeviceHandler,                 m=['GET']),
         ]),
 
+        # Modalities
+
+        route( '/modalities',               ModalityHandler, h='get_all',    m=['GET']),
+        route( '/modalities',               ModalityHandler,                 m=['POST']),
+        prefix('/modalities', [
+            route('/<modality_name:[^/]+>', ModalityHandler,                 m=['GET', 'PUT', 'DELETE']),
+        ]),
+
 
         # Groups
 
@@ -244,7 +253,7 @@ def prefix(path, routes):
                 route('/packfile',                              FileListHandler, h='packfile',       m=['POST']),
                 route('/packfile-end',                          FileListHandler, h='packfile_end'),
                 route('/<list_name:files>',                     FileListHandler,                     m=['POST']),
-                route('/<list_name:files>/<name:{fname}>',      FileListHandler,                     m=['GET', 'DELETE']),
+                route('/<list_name:files>/<name:{fname}>',      FileListHandler,                     m=['GET', 'DELETE', 'PUT']),
                 route('/<list_name:files>/<name:{fname}>/info', FileListHandler, h='get_info',       m=['GET']),
 
 

api/auth/listauth.py

@@ -20,6 +20,7 @@ def default_sublist(handler, container):
     access = _get_access(handler.uid, handler.user_site, container)
     def g(exec_op):
         def f(method, _id, query_params=None, payload=None, exclude_params=None):
+            log.debug('Im actually in here')
             if method == 'GET' and container.get('public', False):
                 min_access = -1
             elif method == 'GET':

api/dao/liststorage.py

@@ -46,7 +46,7 @@ def get_container(self, _id, query_params=None):
         log.debug('query {}'.format(query))
         return self.dbc.find_one(query, projection)
 
-    def exec_op(self, action, _id=None, query_params=None, payload=None, exclude_params=None):
+    def exec_op(self, action, _id=None, query_params=None, payload=None, exclude_params=None, replace_classification=False):
         """
         Generic method to exec an operation.
         The request is dispatched to the corresponding private methods.
@@ -63,7 +63,7 @@ def exec_op(self, action, _id=None, query_params=None, payload=None, exclude_par
         if action == 'DELETE':
             return self._delete_el(_id, query_params)
         if action == 'PUT':
-            return self._update_el(_id, query_params, payload, exclude_params)
+            return self._update_el(_id, query_params, payload, exclude_params, replace_classification=replace_classification)
         if action == 'POST':
             return self._create_el(_id, payload, exclude_params)
         raise ValueError('action should be one of GET, POST, PUT, DELETE')
@@ -342,3 +342,31 @@ def inflate_job_info(analysis):
 
         analysis['job'] = job
         return analysis
+
+
+class FileStorage(ListStorage):
+
+    def _update_el(self, _id, query_params, payload, exclude_params, replace_classification=False):
+        mod_elem = {}
+        update = {}
+
+        # If we want to add to the classification lists rather than replace
+        # the entirity of the classification map, use $addToSet.
+        # This allows some endpoints to only make additive changes
+        if not replace_classification:
+            classification = payload.get('classification')
+            if classification:
+                add_to_set = {}
+                for k,array in classification.items():
+                    add_to_set[self.list_name + '.$.classification.' + k] = array
+                update['$addToSet'] = add_to_set
+
+        for k,v in payload.items():
+            mod_elem[self.list_name + '.$.' + k] = v
+        query = {
+            '_id': _id,
+            self.list_name: {'$elemMatch': query_params}
+        }
+        update['$set'] = mod_elem
+
+        return self.dbc.update_one(query, update)

api/handlers/listhandler.py

@@ -18,6 +18,7 @@
 from ..dao import liststorage
 from ..dao import APIStorageException
 from ..dao import hierarchy
+from .modalityhandler import ModalityHandler
 from ..web.request import log_access, AccessType
 
 
@@ -38,7 +39,7 @@ def initialize_list_configurations():
             'input_schema_file': 'tag.json'
         },
         'files': {
-            'storage': liststorage.ListStorage,
+            'storage': liststorage.FileStorage,
             'permchecker': listauth.default_sublist,
             'use_object_id': True,
             'storage_schema_file': 'file.json',
@@ -484,6 +485,37 @@ def post(self, cont_name, list_name, **kwargs):
 
         return upload.process_upload(self.request, upload.Strategy.targeted, container_type=cont_name, id_=_id, origin=self.origin)
 
+    def put(self, cont_name, list_name, **kwargs):
+        _id = kwargs.pop('cid')
+        permchecker, storage, mongo_validator, payload_validator, keycheck = self._initialize_request(cont_name, list_name, _id, query_params=kwargs)
+
+        payload = self.request.json_body
+        payload_validator(payload, 'PUT')
+        if not set(payload.keys()).issubset({'info', 'modality', 'classification'}):
+            self.abort(400, 'Can only update info, modality an classification keys on file.')
+
+        classification = payload.get('classification')
+        if classification:
+            modality = payload.get('modality')
+            if not modality:
+                file_obj = storage.exec_op('GET', _id, query_params=kwargs)
+                modality = file_obj.get('modality')
+
+            if not ModalityHandler.check_classification(modality, classification):
+                self.abort(400, 'Classification does not match allowable values for modality {}.'.format(modality))
+
+        rc = self.is_true('replace_classification')
+
+        try:
+            result = keycheck(mongo_validator(permchecker(storage.exec_op)))('PUT', _id=_id, query_params=kwargs, payload=payload)
+        except APIStorageException as e:
+            self.abort(400, e.message)
+        # abort if the query of the update wasn't able to find any matching documents
+        if result.matched_count == 0:
+            self.abort(404, 'Element not updated in list {} of container {} {}'.format(storage.list_name, storage.cont_name, _id))
+        else:
+            return {'modified':result.modified_count}
+
     def delete(self, cont_name, list_name, **kwargs):
         # Overriding base class delete to audit action before completion
         _id = kwargs.pop('cid')

api/handlers/modalityhandler.py

@@ -0,0 +1,115 @@
+import datetime as dt
+
+from ..web import base
+from .. import config
+from .. import util
+from ..auth import require_drone, require_login, require_superuser
+from ..dao import containerstorage, APINotFoundException
+from ..validators import validate_data
+
+log = config.log
+
+
+class ModalityHandler(base.RequestHandler):
+
+    def __init__(self, request=None, response=None):
+        super(ModalityHandler, self).__init__(request, response)
+        self.storage = containerstorage.ContainerStorage('modalities', use_object_id=False)
+
+    @require_login
+    def get(self, modality_name):
+        return self.storage.get_container(modality_name)
+
+    @require_login
+    def get_all(self):
+        return self.storage.get_all_el(None, None, None)
+
+    @require_superuser
+    def post(self):
+        payload = self.request.json_body
+        # Clean this up when validate_data method is fixed to use new schemas
+        # POST unnecessary, used to avoid run-time modification of schema
+        #validate_data(payload, 'modality.json', 'input', 'POST', optional=True)
+
+        result = self.storage.create_el(payload)
+        if result.acknowledged:
+            return {'_id': result.inserted_id}
+        else:
+            self.abort(400, 'Modality not inserted')
+
+    @require_superuser
+    def put(self, modality_name):
+        payload = self.request.json_body
+        # Clean this up when validate_data method is fixed to use new schemas
+        # POST unnecessary, used to avoid run-time modification of schema
+        #validate_data(payload, 'modality.json', 'input', 'POST', optional=True)
+
+        result = self.storage.update_el(modality_name, payload)
+        if result.matched_count == 1:
+            return {'modified': result.modified_count}
+        else:
+            raise APINotFoundException('Modality with name {} not found, modality not updated'.format(modality_name))
+
+    @require_superuser
+    def delete(self, modality_name):
+        result = self.storage.delete_el(modality_name)
+        if result.deleted_count == 1:
+            return {'deleted': result.deleted_count}
+        else:
+            raise APINotFoundException('Modality with name {} not found, modality not deleted'.format(modality_name))
+
+    @staticmethod
+    def check_classification(modality_name, classification_map):
+        """
+        Given a modality name and a proposed classification map,
+        ensure:
+          - that a modality exists with that name and has a classification
+            map
+          - all keys in the classification_map exist in the
+            `classifications` map on the modality object
+          - all the values in the arrays in the classification_map
+            exist in the modality's classifications map
+
+        For example:
+            Modality = {
+                "_id" = "Example_modality",
+                "classifications": {
+                    "Example1": ["Blue", "Green"]
+                    "Example2": ["one", "two"]
+                }
+            }
+
+        Returns True:
+            classification_map = {
+                "Example1": ["Blue"],
+                "custom":   ["anything"]
+            }
+
+        Returns False:
+            classification_map = {
+                "Example1": ["Red"], # "Red" is not allowed
+                "Example2": ["one", "two"]
+            }
+        """
+        try:
+            modality = containerstorage.ContainerStorage('modalities', use_object_id=False).get_container(modality_name)
+        except APINotFoundException:
+            if classification_map.keys() == ['custom']:
+                # for unknown modalities allow only list of custom values
+                return True
+            else:
+                return False
+
+        classifications = modality.get('classifications')
+        if not classifications:
+            return False
+
+        for k,array in classification_map.iteritems():
+            if k == 'custom':
+                # any unique value is allowed in custom list
+                continue
+            possible_values = classifications.get(k, [])
+            if not set(array).issubset(set(possible_values)):
+                return False
+
+        return True