Changeset 1800

Timestamp:

May 2, 2011, 5:03:36 PM (12 years ago)

Author:

robert@…

Message:

Implemented searching in 'all fields'

Location:

trunk

Files:

• grails-app/controllers/dbnp/query/AdvancedQueryController.groovy (modified) (3 diffs)
• grails-app/views/advancedQuery/index.gsp (modified) (1 diff)
• src/groovy/dbnp/query/Criterion.groovy (modified) (1 diff)
• src/groovy/dbnp/query/SampleSearch.groovy (modified) (2 diffs)
• src/groovy/dbnp/query/Search.groovy (modified) (3 diffs)
• src/groovy/dbnp/query/StudySearch.groovy (modified) (1 diff)

trunk/grails-app/controllers/dbnp/query/AdvancedQueryController.groovy

@@ -265 +265 @@
          */
         protected def getSearchableFields() {
-                def fields = [:];
+                def fields = [ '*' : [ '*' ] ]; // Searches for all fields in all objects
 
                 // Retrieve all local search fields
@@ -308 +308 @@
                         }
                 }
-
+                
                 return fields;
         }
@@ -332 +332 @@
                 ArrayList list = [];
                 flash.error = "";
+                
                 // Loop through all keys of c and remove the non-numeric ones
                 for( c in formCriteria ) {

trunk/grails-app/views/advancedQuery/index.gsp

@@ -18 +18 @@
                                                         entity.key.toString() + '.' + field.toString() + ' ' +
                                                         entity.key.toString() + ' ' + field.toString() + ' ' + 
-                                                        (field == '*' ? 'any field' : '')
+                                                        (field == '*' ? 'any field' : '') + ' ' +
+                                                        (field == '*' && entity.key == '*' ? 'any field in any object' : '')
                                                         ).encodeAsJavaScript()}",
                                                 show: "${
                                                         (field == '*' ? 
-                                                                '[Any field in ' + entity.key.toString() + ']' : 
+                                                                ( entity.key == '*' ? '[Any field in any object]' : '[Any field in ' + entity.key.toString() + ']' ) : 
                                                                 (field?.size() > 1 ? 
                                                                         field[0].toUpperCase() + field[1..-1] : 

trunk/src/groovy/dbnp/query/Criterion.groovy

@@ -43 +43 @@
         public String humanReadableEntityField() {
                 if( field == '*' ) {
-                        return "any field in " + entity.toString();
+                        if( entity == '*' ) {
+                                return "any field in any object"
+                        } else {
+                                return "any field in " + entity.toString();
+                        }
                 } else {
                         return entityField();

trunk/src/groovy/dbnp/query/SampleSearch.groovy

@@ -112 +112 @@
                 samples = filterOnSamplingEventCriteria( samples );
                 samples = filterOnAssayCriteria( samples );
-
+                
+                // Filter on criteria for which the entity is unknown
+                samples = filterOnAllFieldsCriteria( samples );
+                
+                // Filter on module criteria
                 samples = filterOnModuleCriteria( samples );
 
@@ -186 +190 @@
                         case "Assay":
                                 return { sample, criterion ->
-                                        println "Find value for " + sample + " and " + criterion
                                         def sampleAssays = Assay.findByParent( sample.parent ).findAll { it.samples?.contains( sample ) };
                                         if( sampleAssays && sampleAssays.size() > 0 )

trunk/src/groovy/dbnp/query/Search.groovy

@@ -166 +166 @@
                 objects = filterOnAssayCriteria( objects );
 
+                // Filter on criteria for which the entity is unknown
+                objects = filterOnAllFieldsCriteria( objects );
+                
+                // Filter on module criteria
                 objects = filterOnModuleCriteria( objects );
 
@@ -197 +201 @@
                 objects = ( objects + filterOnSamplingEventCriteria( allObjects - objects ) ).unique();
                 objects = ( objects + filterOnAssayCriteria( allObjects - objects ) ).unique();
+                
+                // Filter on criteria for which the entity is unknown
+                objects = ( objects + filterOnAllFieldsCriteria( allObjects - objects ) ).unique();
                 
                 // All objects (including the ones already found by another criterion) are sent to
@@ -484 +491 @@
                 def entity = "Assay"
                 return filterOnTemplateEntityCriteria(studies, entity, valueCallback( entity ) )
+        }
+        
+        
+        /**
+         * Filters the given list of entities on criteria that mention all fields (e.g. search for studies with 'bacteria' in any field)
+         * @param objects       Original list of entities.
+         * @return                      List of all entities that match the given criteria
+         */
+        protected List filterOnAllFieldsCriteria( List objects ) {
+                def criteria = getEntityCriteria( "*" );
+                
+                // Find methods to determine a value for a criterion, based on all entities
+                def valueCallbacks = [:];
+                def entities = [ "Study", "Subject", "Sample", "Event", "SamplingEvent", "Assay" ];
+                entities.each {
+                        valueCallbacks[ it ] = valueCallback( it );
+                }
+                
+                // Create a closure that checks all entities
+                def checkCallback = { object, criterion ->
+                        def value = "";
+                        for( def entity in entities ) {
+                                value = valueCallbacks[ entity ]( object, criterion );
+                                
+                                if( value == null ) {
+                                        continue;
+                                }
+        
+                                if( value instanceof Collection ) {
+                                        if( criterion.matchAny( value ) )
+                                                return true;
+                                } else {
+                                        if( criterion.match( value ) )
+                                                return true;
+                                }
+                        }
+                        
+                        // If no match is found, return
+                        return false;
+                }
+
+                return filterEntityList( objects, criteria, checkCallback);
         }
         

trunk/src/groovy/dbnp/query/StudySearch.groovy

@@ -122 +122 @@
         * @return
         */
-   protected Closure valueCallback( String entity ) {
-           switch( entity ) {
-                   case "Study":
-                           return { study, criterion -> return criterion.getFieldValue( study ) }
-                   case "Subject":
-                           return { study, criterion -> return study.subjects?.collect { criterion.getFieldValue( it ); } }
-                   case "Sample":
-                           return { study, criterion -> return study.samples?.collect { criterion.getFieldValue( it ); } }
-                   case "Event":
-                           return { study, criterion -> return study.events?.collect { criterion.getFieldValue( it ); } }
-                   case "SamplingEvent":
-                           return { study, criterion -> return study.samplingEvents?.collect { criterion.getFieldValue( it ); } }
-                   case "Assay":
-                           return { study, criterion -> return study.assays?.collect { criterion.getFieldValue( it ); } }
-                   default:
-                           return super.valueCallback( entity );
-           }
-   }
+        protected Closure valueCallback( String entity ) {
+                switch( entity ) {
+                        case "Study":
+                                return { study, criterion -> return criterion.getFieldValue( study ) }
+                        case "Subject":
+                                return { study, criterion -> return study.subjects?.collect { criterion.getFieldValue( it ); } }
+                        case "Sample":
+                                return { study, criterion -> return study.samples?.collect { criterion.getFieldValue( it ); } }
+                        case "Event":
+                                return { study, criterion -> return study.events?.collect { criterion.getFieldValue( it ); } }
+                        case "SamplingEvent":
+                                return { study, criterion -> return study.samplingEvents?.collect { criterion.getFieldValue( it ); } }
+                        case "Assay":
+                                return { study, criterion -> return study.assays?.collect { criterion.getFieldValue( it ); } }
+                        default:
+                                return super.valueCallback( entity );
+                }
+        }
 
         /**