Changeset 9 for trunk/grails-app/controllers/nl/tno/metagenomics/integration/RestController.groovy

Timestamp:

Jan 28, 2011, 12:30:39 PM (12 years ago)

Author:

robert@…

Message:

 

File:

• trunk/grails-app/controllers/nl/tno/metagenomics/integration/RestController.groovy (modified) (7 diffs)

trunk/grails-app/controllers/nl/tno/metagenomics/integration/RestController.groovy

@@ -38 +38 @@
         /****************************************************************/
         private getMeasurementTypes() {
-                return [ "# sequences", "average quality" ]
+                return [ "# sequences" ]
         }
 
@@ -274 +274 @@
         def notifyStudyChange = {
                 def studyToken = params.studyToken
-                
+
                 if( !studyToken ) {
                         response.sendError(400, "No studyToken given" )
                         return
                 }
-                
+
                 // Search for the changed study
                 def study = Study.findByStudyToken( studyToken );
-                
+
                 // If the study is not found, it is added in GSCF. Add a dummy (dirty) study, in order to
                 // update it immediately when asked for
@@ -288 +288 @@
                         log.info( "METAGENOMICS: GSCF notification for new study " + studyToken );
                         study = new Study(
-                                name: "",
-                                studyToken: studyToken,
-                                isDirty: true
-                        )
+                                        name: "",
+                                        studyToken: studyToken,
+                                        isDirty: true
+                                        )
                 } else {
                         log.info( "METAGENOMICS: GSCF notification for existing study " + studyToken );
@@ -297 +297 @@
                 }
                 study.save(flush:true);
-                
+
                 def jsonData = [ 'studyToken': studyToken, message: "Notify succesful" ];
-                
+
                 render jsonData as JSON
         }
-        
+
         /**
          * Return URL to view an assay.
@@ -322 +322 @@
                 // If the assay is not found, try synchronizing
                 synchronizationService.sessionToken = session.sessionToken
-                
+
                 if( !assay ) {
                         synchronizationService.synchronizeStudies()
                         assay = Assay.findByAssayToken( assayToken );
-                        
+
                         if( !assay ) {
                                 response.sendError(404, "Not Found" )
@@ -338 +338 @@
                                 return
                         }
-                        
+
                         def url = [ 'url' : ConfigurationHolder.config.grails.serverURL + '/assay/show/' + assay.id.toString() ]
 
@@ -344 +344 @@
                 }
         }
-        
+
         /***************************************************/
         /* REST resources related to the querying in GSCF  */
         /***************************************************/
+
+        /**
+         * Retrieves a list of fields that could be queried when searching for a specific entity.
+         * 
+         * The module is allowed to return different fields when the user searches for different entities
+         * 
+         * Example call:                [moduleurl]/rest/getQueryableFields?entity=Study&entity=Sample
+         * Example response:    { "Study": [ "# sequences" ], "Sample": [ "# sequences", "# bacteria" ] }
+         * 
+         * @param       params.entity   Entity that is searched for. Might be more than one. If no entity is given, 
+         *                                                      a list of searchable fields for all entities is given
+         * @return      JSON                    List with the names of the fields 
+         */
+        def getQueryableFields = {
+                // We don't really care about the entity. The only thing is that this module
+                // is only aware of studies, assays and samples, but doesn't know anything about
+                // subjects or events. If the user searches for those entities (maybe in the future)
+                // this module doesn't have anything to search for.
+
+                def entities = params.entity ?: []
+                
+                if( entities instanceof String )
+                        entities = [entities]
+                else
+                        entities = entities.toList()
+
+                if( !entities )
+                        entities = [ "Study", "Assay", "Sample" ]
+                        
+
+                def fields = [:];
+                entities.unique().each { entity -> 
+                        switch( entity ) {
+                                case "Study":
+                                case "Assay":
+                                case "Sample":
+                                        fields[ entity ] = [ "# sequences" ]
+                                        break;
+                                default:
+                                        // Do nothing
+                                        break;
+                        }
+                }
+                
+                render fields as JSON
+        }
+
+        /**
+         * Returns data for the given field and entities.
+         * 
+         * Example call:                [moduleurl]/rest/getQueryableFieldData?entity=Study&tokens=abc1&tokens=abc2&fields=# sequences&fields=# bacteria
+         * Example response:    { "abc1": { "# sequences": 141, "# bacteria": 0 }, "abc2": { "#sequences": 412 } }
+         * 
+         * @param       params.entity   Entity that is searched for
+         * @param       params.tokens   One or more tokens of the entities that the data should be returned for
+         * @param       params.fields   One or more field names of the data to be returned.
+         * @return      JSON                    Map with keys being the entity tokens and the values being maps with entries [field] = [value]. Not all
+         *                                                      fields and tokens that are asked for have to be returned by the module (e.g. when a specific entity can 
+         *                                                      not be found, or a value is not present for an entity)
+         */
+        def getQueryableFieldData = {
+                def entity = params.entity;
+                def tokens = params.tokens ?: []
+                def fields = params.fields ?: []
+
+                if( tokens instanceof String )
+                        tokens = [tokens]
+                else
+                        tokens = tokens.toList();
+
+                if( fields instanceof String )
+                        fields = [fields]
+                else
+                        fields = fields.toList();
+
+                // Only search for unique tokens and fields
+                tokens = tokens.unique()
+                fields = fields.unique()
+
+                // Without tokens or fields we can only return an empty list
+                def map = [:]
+                if( tokens.size() == 0 || fields.size() == 0 ) {
+                        log.trace "Return empty string for getQueryableFieldData: #tokens: " + tokens.size() + " #fields: " + fields.size()
+                        render map as JSON
+                        return;
+                }
+
+                tokens.each { token ->
+                        def object = getQueryableObject( entity, token );
+                        if( object ) {
+                                map[ token ] = [:]
+                                fields.each { field ->
+                                        def v = getQueryableFieldValue( entity, object, field );
+                                        if( v != null )
+                                                map[ token ][ field ] = v
+                                }
+                        } else {
+                                log.trace "No " + entity + " with token " + token + " found."
+                        }
+                }
+                
+                render map as JSON
+        }
+
+        /**
+         * Searches for a specific entity
+         *
+         * @param entity                Entity to search in
+         * @param token         Token of the entity to search in
+         * @return
+         */
+        protected def getQueryableObject( def entity, def token ) {
+                switch( entity ) {
+                        case "Study":
+                                return Study.findByStudyToken( token );
+                        case "Assay":
+                                return Assay.findByAssayToken( token );
+                        case "Sample":
+                                return Sample.findBySampleToken( token );
+                        default:
+                        // Other entities can't be handled
+                                return null;
+                }
+        }
+
+        /**
+         * Searches for the value of a specific field in a specific entity
+         * 
+         * @param entity        Entity of the given object
+         * @param object        Object to search in
+         * @param field         Field value to retrieve         
+         * @return
+         */
+        protected def getQueryableFieldValue( def entity, def object, def field ) {
+                if( !entity || !object || !field )
+                        return null;
+                        
+                switch( entity ) {
+                        case "Study":
+                                switch( field ) {
+                                        // Returns the total number of sequences in this study
+                                        case "# sequences":
+                                                def assaySamples = object.assays*.assaySamples;
+                                                if( assaySamples ) {
+                                                        assaySamples = assaySamples.flatten()
+                                                        return assaySamples.collect { it.numSequences() }.sum();
+                                                } else {
+                                                        return null;
+                                                }
+                                        // Other fields are not handled
+                                        default:
+                                                return null;
+                                }
+                        case "Assay":
+                                switch( field ) {
+                                        // Returns the total number of sequences in this study
+                                        case "# sequences":
+                                                def assaySamples = assay.assaySamples;
+                                                if( assaySamples ) {
+                                                        return assaySamples.collect { it.numSequences() }.sum();
+                                                } else {
+                                                        return null;
+                                                }
+                                        // Other fields are not handled
+                                        default:
+                                                return null;
+                                }
+                        case "Sample":
+                                switch( field ) {
+                                        // Returns the total number of sequences in this study
+                                        case "# sequences":
+                                                def assaySamples = sample.assaySamples;
+                                                if( assaySamples ) {
+                                                        return assaySamples.collect { it.numSequences() }.sum();
+                                                } else {
+                                                        return null;
+                                                }
+                                        // Other fields are not handled
+                                        default:
+                                                return null;
+                                }
+                        default:
+                        // Other entities can't be handled
+                                return null;
+                }
+        }
 
         /**