Changeset 1196


Ignore:
Timestamp:
Nov 24, 2010, 11:47:41 AM (6 years ago)
Author:
j.saito@…
Message:

Streamlined CommunicationManager? and adjusted it to suit CommunicationManager? in SAM.
Removed horrible debugoutputs from SimpleQueryController?. (Is this used any longer at all??)

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/grails-app/conf/BootStrap.groovy

    r1195 r1196  
    4949                        CommunicationManager.SAMServerURL = config.modules.sam.url
    5050                        CommunicationManager.DSPServerURL = config.modules.metabolomics.url
    51                         CommunicationManager.registerRestWrapperMethodsSAMtoGSCF()
     51                        CommunicationManager.ServerURL = config.grails.serverURL
     52                        CommunicationManager.registerRestWrapperMethodsFromSAM()
    5253                }
    5354
  • trunk/grails-app/controllers/dbnp/query/SimpleQueryController.groovy

    r959 r1196  
    3535        // Starting simpleQuery flow, initialize variables
    3636        onStart {
    37             println "Starting webflow simpleQuery"
    3837            flow.search_term            = null
    3938            flow.search_sa_compounds    = []
     
    5150                        render(view: "/simpleQuery/mainPage")
    5251
     52
    5353            onRender {
    54               println "Rendering mainPage"
    5554              flow.operators              = ['>', '=', '<']
    5655
    5756              if (!flow.search_sa_compounds) {
    5857                flow.showFirstRowCompounds  = true
    59                 println "showRow true"
    6058              } else {
    6159                flow.showFirstRowCompounds  = false
    62                 println "showRow false"
    6360              }
    6461
     
    6865
    6966            on("search") {
    70               println "Search!"
    7167              if (!params.search_term.trim()) {
    7268                return [:]
     
    8177        searching {
    8278           action {
    83               println "Starting simpleQuery search..."
    8479              def searchResult
    8580              def searchGscfResult
    8681              def searchSamResult   = []
    8782
    88               // TODO: walk parameters, remove empty entries
    89 
    9083              // Map GSCF parameters
    9184              flow.search_term            = params.search_term        // String
     
    9386              // Map SAM parameters
    9487              if (params.sa_compound instanceof String) {
    95                 println "Compounds as String"
    96                 //flow.search_sam = [:]
    9788                flow.search_sa_compounds = []
    9889                flow.search_sa_operators = []
     
    10596                }
    10697              } else {
    107                 println "Compounds as List"
    10898                flow.search_sa_compounds  = params.sa_compound as List
    10999                flow.search_sa_operators  = params.sa_operator as List
     
    114104              try {
    115105                searchGscfResult = searchableService.search(flow.search_term)
    116                 println "RESULT: " + searchGscfResult
    117106              } catch (SearchEngineQueryParseException ex) {
    118107                println ex
     
    124113
    125114              // Search in the SAM module when a compound is entered
    126               // Todo: check whether the module is active and to be used
    127               // ...
    128115              def listSamStudies = []
    129116              def listGscfStudies = []
     
    133120                def resultSAM = [:]
    134121                resultSAM = this.searchSAM(flow.search_sa_compounds, flow.search_sa_operators, flow.search_sa_values)
    135                 println "Sam result: " + resultSAM
    136122                listSamStudies = resultSAM.get('studies')
    137123              }
    138124
    139125             for (i in searchGscfResult.results) {
    140                //def x = i.id
    141126               def objStudy = Study.get(i.id)
    142                println objStudy
    143127               listGscfStudies.add(objStudy.id)
    144128             }
    145129
    146130
    147              println "GSCF studies: " + listGscfStudies
    148              println "Sam studies " + listSamStudies
    149131                                         
    150132             // Merge the results of all searches
    151133             if (listSamStudies.size() > 0) {
    152134               listStudies = listGscfStudies.intersect(listSamStudies)
    153                println "Combined: " + listStudies
    154135             } else {
    155136               if (!flow.search_sa_compounds) {
     
    168149             // Save the results in the flow
    169150             flow.listStudies = listObjStudies
    170              println flow.listStudies
    171151
    172152           }
     
    182162
    183163            onRender {
    184               println "Rendering resultPage"
    185164              flow.page = 2
    186165
     
    196175              flow.search_tt_genepaths    = null
    197176              flow.search_tt_regulations  = null
    198               println "Resetting query flow"
    199177            }.to "query"
    200178
     
    207185 
    208186   static Map searchSAM (List compounds, List operators, List values) {
     187
     188
    209189     if (compounds.size() == 1) {
    210        println "Single SAM call"
    211        def mapSamResult = [:]
    212 
    213        //def listAssays = [3, 1]
    214        //mapSamResult.put("assays", listAssays)
    215        //println "CommMngr result: " + mapSamResult
    216 
    217        CommunicationManager.addRestWrapper( 'http://localhost:8182/sam/rest', 'getQueryResult', ['query'] )
    218        mapSamResult = CommunicationManager.getQueryResult( compounds.get(0) )
    219        println "SAM REST query: " + compounds.get(0)
    220        println "SAM REST result: " + mapSamResult
    221 
    222        // mapSamResult = CommunicationManager.getQueryResult(compounds.get(0), operators.get(0), values.get(0))
    223 
    224        //objAssay = objAssay.get(i)
    225        //println "Assay: " + objAssay
    226 
    227        /*
    228        for (i in mapSamResult.assays) {
    229          //def listStudies = Study.findAll("from Study as s where s.assays.id = " + i)
    230          def listStudies = Study.findAll("from Study as s where exists (from Assay as a where a.id = s.assays and a.id = ${i})")
    231          println "Studies found: " + listStudies
    232        }
    233        */
     190       def tmpResult = CommunicationManager.getQueryResult( compounds.get(0) )
     191       def studies = tmpResult.studiesIds.collect{ Study.findByCode(it) }
     192       def assays  = tmpResult.assays.collect { [it, Assay.findByExternalAssayID( it.externalAssayID ) ] }
     193           def mapSamResult = [studies:studies, assays:assays]
     194
    234195
    235196       def listStudies = []
     
    245206
    246207     } else {
    247        println "Multiple SAM calls"
    248        def tmpSamResult = [:]
    249        def mapSamResult = [assays:[]]
     208       def tmpResult = CommunicationManager.getQueryResult( compounds.get(0) )
     209       def studies = tmpResult.studiesIds.collect{ Study.findByCode(it) }
     210           def mapSamResult = [studies:studies, assays:[]]
     211
    250212       def i = 0
    251 
    252213       compounds.each { compound ->
    253          println "SAM Search with " + compound
    254          CommunicationManager.addRestWrapper( 'http://localhost:8182/sam/rest', 'getQueryResult', ['query'] )
    255214         tmpSamResult = CommunicationManager.getQueryResult(compound)
    256          println "tmpsamres: " + tmpSamResult
    257215
    258216         if (i == 0) {
     
    263221           }
    264222         }
    265 
    266223         i++
    267224       }
  • trunk/src/groovy/dbnp/rest/common/CommunicationManager.groovy

    r1010 r1196  
    2626class CommunicationManager {
    2727
     28
     29    /* this should moved somewhere else */
     30    /* The static URLs are set in grails-app/conf/Config.groovy */
    2831    def        static Encoding      = "UTF-8"
     32    def public static ServerURL     = "http://localhost:8182/sam"
    2933    def public static SAMServerURL  = "http://localhost:8182/sam"
    3034    def public static GSCFServerURL = "http://localhost:8080/gscf"
    31     def public static DSPServerURL  = "http://localhost:8080/gscf"
     35    def public static DSPServerURL  = "http://localhost:8080/ncdsp"
    3236
    3337
     
    5862        def url = RestServerURL + '/' + resource
    5963                def first = true
     64                params['consumer']=ServerURL
    6065                params.each { name, value ->
    6166                        if(first) {
     
    107112
    108113    public static addRestWrapper( serverURL, restName, params = [], closure = { return it } ) {
    109                 CommunicationManager.metaClass.registerStaticMethod( restName ) { Object [] strangeGroovyArgs ->
    110                         def map = [:]
    111                     def args = strangeGroovyArgs[0]        // groovy nests the parameters of the methods in some other array
     114                if(!serverURL) { throw new Exception("addRestWrapper: REST serverURL is null") }
     115                def result
     116                try {
     117                        CommunicationManager.metaClass.registerStaticMethod( restName ) { Object [] strangeGroovyArgs ->
     118                                def map = [:]
     119                            def args = strangeGroovyArgs[0]        // groovy nests the parameters of the methods in some other array
     120                                if(params.size > 0 )
     121                                {
     122                                        for( i in 0..(params.size-1) ) {
     123                                                def param = params[i]
     124                                                map[param] = args[i]
     125                                        }
     126                                }
     127                                result = closure( getRestResource( serverURL, restName, map ) )
     128                        }
     129                } catch ( Exception e ) {
     130                        throw new Exception("addRestWrapper: error. Could not retrieve data from RESTFful service. ")
     131                }
    112132
    113                         if(params.size > 0 )
    114                         {
    115                                 for( i in 0..(params.size-1) ) {
    116                                         def param = params[i]
    117                                         map[param] = args[i]
    118                                 }
    119                         }
    120 
    121                         return closure( getRestResource( serverURL, restName, map ) )
    122                 }
    123         }
    124 
    125 
    126 
    127 
    128 
    129     /**
    130      * This method dynamically registers a static method to the CommunicationManager. The new method
    131      * gives url for a Grails view on some server and takes as arguments the arguments required
    132      * as params by the view.
    133      * 
    134      * @params String methodname        The name for method to be registered.
    135      * @params String serverURL         The server's URL.
    136      * @params String viewName          The view's name, e.g., '/Assay/show'
    137      * @params Map params               The parameter list required by this view.
    138      * @return String URL
    139      * 
    140      */ 
    141     public static addViewWrapper( methodName, serverURL, viewName, params = [] ) {
    142 
    143                 CommunicationManager.metaClass.registerStaticMethod( methodName ) { Object [] strangeGroovyArgs ->
    144                         def map = [:]
    145                     def args = strangeGroovyArgs[0]        // groovy nests the parameters of the methods in some other array
    146                         for( i in 0..(params.size-1) ) {
    147                                 def param = params[i]
    148                             map[param] = args[i]
    149                         }
    150                         return getRestURL( serverURL, viewName, map )
    151                 }
    152     }
    153 
    154 
    155     /**
    156      *  This creates on run time new methods for accessing Rest resources that GSCF provides for SAM.
    157      *  This method should be called in grails-app/conf/BootStrap.groovy in the SAM module.
    158      */
    159     public static registerRestWrapperMethodsGSCFtoSAM() {
    160         def url = GSCFServerURL + '/rest'
    161                 addRestWrapper( url , 'getStudies' )
    162         addRestWrapper( url , 'getSubjects', ['studyToken'] )
    163                 addRestWrapper( url , 'getAssays',   ['studyToken','moduleURL'] )
    164                 addRestWrapper( url , 'getSamples',  ['assayToken'] )
     133                return result
    165134        }
    166135
     
    169138     *  This method creates on run time new methods for accessing Grails views that SAM provides for GSCF.
    170139     *  This method should be called in grails-app/conf/BootStrap.groovy in the GSCF module.
    171      */
    172     public static registerRestWrapperMethodsSAMtoGSCF() {
     140     */          
     141    public static registerRestWrapperMethodsFromSAM() {
    173142                def url = SAMServerURL
    174 
    175                 // register method that links to the SAM view for importing a SimpleAssay.
    176         // parameters: externalAssayID, an externalAssayID
    177                 addViewWrapper( 'getAssayImportURL', url, 'importer/pages', ['externalAssayID', 'externalStudyID'] )
    178 
    179                 // register method that links to the SAM view for showing a SimpleAssay
    180         // parameters: externalAssayID
    181                 addViewWrapper( 'getAssayShowURL', url, 'simpleAssay/show', ['externalAssayID'] )
    182 
    183                 // register method that links to the SAM view for editing a SimpleAssay
    184         // parameters: externalAssayID
    185                 addViewWrapper( 'getAssayEditURL', url, 'simpleAssay/show', ['externalAssayID'] )
    186 
    187                 // register method that links to the SAM view for editing a SimpleAssay
    188         // parameters: externalAssayID
    189                 addViewWrapper( 'getMeasurementTypesURL', url, 'simpleAssayMeasurementType/list', ['externalStudyID'] )
    190 
    191                 // register rest resource that returns the results of a full text query on SAM
    192         // parameters:   query. A string for fulltext search on SAM
    193         // return value: results map. It contains two keys 'studyIds', and 'samples'. 'studyIds'
    194                 //               key maps to a list of Study domain objects of GSCF. 'samples' maps to a
    195                 //               list of pairs. Each pair consists of a Sample domain object of GSCF and
    196                 //               additional sample information from SAM provided as a map.
    197                 // Example of a returned map:
    198                 //                               ["studies":[NuGO PPS human study],
    199                 //               "samples":[[ [...], dbnp.studycapturing.Sample: 1]]]
    200                 def closure = { map ->
    201                     def studies = []   
    202                     def assays  = []   
    203                         def studiesHQ = "from dbnp.studycapturing.Study as s where s.code=?"
    204                         map['studyIds'].each { studies.add( dbnp.studycapturing.Study.find(studiesHQ,[it]) ) }
    205                         map['assays'].each { samAssay ->
    206                                 def assayID = samAssay['externalAssayID']
    207                             def assayHQ = "from dbnp.studycapturing.Assay as a where a.externalAssayID='${assayID}'"
    208                                 def assay = dbnp.studycapturing.Assay.find(assayHQ)
    209                                 assays.add( [samAssay,assay] )
    210                         }
    211                         return [studies:studies, assays:assays]
    212                 }
    213 
    214                 addRestWrapper( url+'/rest', 'getQueryResult',  ['query'], closure )
    215 
    216 
    217                 // Rest resource: getQueryResultWithOperator
    218                 //
    219                 // register rest resource that returns the results of a simple query with measurement value on SAM
    220         // parameters:   query. A keyword to match a measurement type on SAM.
    221         //               operator. One of '=','<', or '>' that serves for selecting measurements.
    222         //               value. A double value for the measurement.
    223                 //
    224         // return value: results list of maps. each map contains an assay, a sample, the value found,
    225         //               a unit (as String), and a type (as String).
    226                 //
    227                 // Example of a returned list of maps:
    228                 //                               [["type":"Glucose", "unit":"g", "value":"201.0", "assay":Lipid profiling,
    229                 //                                 "sample":A10_B], ["type":"Glucose", "unit":"g", "value":"101.0",
    230                 //                                 "assay":Lipid profiling, "sample":A1_B], ["type":"Insulin", "unit":"g", "value":"202.0",
    231                 //                                 "assay":Lipid profiling, "sample":A10_B], ["type":"Insulin", "unit":"g", "value":"102.0",
    232                 //                                 "assay":Lipid profiling, "sample":A1_B]]
    233                 //             
    234                 def closure2 = { listOfMaps ->
    235                         def results = []
    236                         listOfMaps.each{ map ->
    237                                 def result = [ type:map['type'], unit:map['unit'], value:map['value'] ]
    238                                 def assayId = map['externalAssayId'].toLong()
    239                                 def assay  = dbnp.studycapturing.Assay.find( "from dbnp.studycapturing.Assay as a where a.externalAssayID= ?", [assayId] )
    240                                 def sample = dbnp.studycapturing.Sample.find( "from dbnp.studycapturing.Sample as s where s.name = ?", [map['externalSampleId']] )
    241                                 result['assay']=assay
    242                                 result['sample']=sample
    243                                 results.add( result )
    244                         }
    245                         return results
    246                 }
    247 
    248                 addRestWrapper( url+'/rest', 'getQueryResultWithOperator',  ['query','operator','value'], closure2 )
     143                addRestWrapper( url+'/rest', 'getQueryResult',  ['query'] )
    249144    }
    250145
    251 
    252     /**
    253      *  This method creates on run time new methods for accessing Grails views that SAM provides for GSCF.
    254      *  This method should be called in grails-app/conf/BootStrap.groovy in the GSCF module.
    255      */
    256     public static registerRestWrapperMethodsGSCFtoDSP() {
    257                 def url = DSPServerURL
    258                 addRestWrapper( url, 'isUser',  ['username','password'] )
    259                 addRestWrapper( url, 'listStudies',  ['username','password'] )
    260                 addRestWrapper( url, 'listStudySamples',  ['username','password','study_token'] )
    261                 addRestWrapper( url, 'getStudy',  ['username','password','study_token'] )
    262                 addRestWrapper( url, 'getStudySample',  ['username','password','study_token','sample_token'] )
    263                 addRestWrapper( url, 'isUser',  ['username','password'] )
    264     }
    265146
    266147
     
    273154     */ 
    274155        static String hasValidParams( params, Object [] requiredParams ) {
    275                 def list = []
    276                 requiredParams.each { p ->
    277                         if( !params[p] ) list.push p
    278                 }
    279                 if(list.size()>0) { return true }
    280                 return false
     156                requiredParams.every { params[it] }
    281157        }
    282158
    283159
    284 
    285160}
Note: See TracChangeset for help on using the changeset viewer.