Changeset 1913


Ignore:
Timestamp:
Jun 6, 2011, 2:47:23 PM (8 years ago)
Author:
robert@…
Message:

Fixed a bug in wildcard searches: now the system also searches through domain fields, instead of only looking in template fields

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/grails-app/controllers/dbnp/query/AdvancedQueryController.groovy

    r1908 r1913  
    494494               
    495495                if( !s.url )
    496                         s.url = g.createLink( controller: "advancedQuery", action: "show", id: id );
     496                        s.url = g.createLink( controller: "advancedQuery", action: "show", id: id, absolute: true );
    497497               
    498498                session.queries[ id ] = s;
     
    656656                                                def paramString = s.filterResults(selectedTokens).collect { "tokens=" + it.giveUUID() }.join( "&" )
    657657                                               
    658                                                 if( baseUrl.find( /\?/ ) )
    659                                                         baseUrl += "&"
     658                                                def url = baseUrl;
     659
     660                                                if( url.find( /\?/ ) )
     661                                                        url += "&"
    660662                                                else
    661                                                         baseUrl += "?"
     663                                                        url += "?"
    662664                                               
    663                                                 baseUrl += "entity=" + s.entity
    664                                                
    665                                                 def url = baseUrl;
     665                                                paramString += "&entity=" + s.entity
    666666                                               
    667667                                                actions << [
  • trunk/src/groovy/dbnp/query/Criterion.groovy

    r1904 r1913  
    33import java.text.SimpleDateFormat
    44import org.dbnp.gdt.*
     5import dbnp.studycapturing.*
    56import org.apache.commons.logging.LogFactory;
    67
     
    386387                        }
    387388                }
     389               
     390                // Wildcard searches must also search the fixed domain fields of all entities.
     391                if( this.field == '*' ) {
     392                        def condition = wildcardDomainFields( prefix, objectToSearchIn )
     393                       
     394                        whereClause += condition[ "where" ];
     395                        condition[ "parameters" ].each {
     396                                parameters[ it.key ] = it.value;
     397                        }
     398                }
    388399
    389400                def where = whereClause?.findAll { it } ? "( " + whereClause.join( " OR " ) + " )" : ""
    390401               
    391402                return [ "join": joinClause, "where": where , "parameters": parameters ];
     403        }
     404       
     405        protected Map wildcardDomainFields( String prefix, String objectToSearchIn ) {
     406                def whereClause = [];
     407                def parameters = [:];
     408               
     409                // Determine all domain fields
     410                def domainFields
     411               
     412                switch( objectToSearchIn.toLowerCase() ) {
     413                        case "study":   domainFields = Study.giveDomainFields();        break;
     414                        case "subject": domainFields = Subject.giveDomainFields();      break;
     415                        case "event":   domainFields = Event.giveDomainFields();        break;
     416                        case "sample":  domainFields = Sample.giveDomainFields();       break;
     417                        case "assay":   domainFields = Assay.giveDomainFields();        break;
     418                        case "samplingevent":   domainFields = SamplingEvent.giveDomainFields();        break;
     419                }
     420               
     421                domainFields.each { field ->
     422                        def criterionType = field.type?.casedName;
     423                       
     424                        def fieldName = field.name;
     425                       
     426                        if(     ( objectToSearchIn.toLowerCase() == "subject" && fieldName.toLowerCase() == "species" ) ||
     427                                ( objectToSearchIn.toLowerCase() == "sample" && fieldName.toLowerCase() == "material" ) ||
     428                                ( objectToSearchIn.toLowerCase() == "assay" && fieldName.toLowerCase() == "module" ) ||
     429                                ( objectToSearchIn.toLowerCase() == "samplingevent" && fieldName.toLowerCase() == "sampletemplate" ) ) {
     430                                fieldName += ".name"
     431                        }
     432                       
     433                        // Search in template name
     434                        def condition = extendWhereClause( "( %s )", objectToSearchIn + "." + fieldName, prefix, criterionType, castValue( criterionType ) );
     435                        whereClause += condition[ "where" ];
     436       
     437                        condition[ "parameters" ].each {
     438                                parameters[ it.key ] = it.value;
     439                        }
     440                }
     441               
     442                // Also search in template name
     443                def condition = extendWhereClause( "( %s )", objectToSearchIn + ".template.name", prefix, "String", castValue( "String" ) );
     444                whereClause += condition[ "where" ];
     445
     446                condition[ "parameters" ].each {
     447                        parameters[ it.key ] = it.value;
     448                }
     449               
     450                return [ "where": whereClause, "parameters": parameters]
    392451        }
    393452
  • trunk/src/groovy/dbnp/query/Search.groovy

    r1908 r1913  
    170170                // Combine all parts to generate a full HQL query
    171171                def hqlQuery = selectClause + " " + fullHQL.from + ( fullHQL.where ? "  WHERE " + fullHQL.where.join( " " + searchMode.toString() + " "  ) : "" );
     172               
    172173               
    173174                // Find all objects
Note: See TracChangeset for help on using the changeset viewer.