Changeset 1196 for trunk/src


Ignore:
Timestamp:
Nov 24, 2010, 11:47:41 AM (9 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??)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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.