Changeset 1596

Show
Ignore:
Timestamp:
08-03-11 11:20:31 (3 years ago)
Author:
robert@…
Message:

Solved #344 - retrieving module data is now done using POST

Location:
trunk
Files:
3 modified

Legend:

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

    r1526 r1596  
    333333                        def callUrl = module.url + '/rest/getQueryableFields' 
    334334                        try { 
    335                                 def json = moduleCommunicationService.callModuleRestMethodJSON( module.url, callUrl ); 
     335                                def json = moduleCommunicationService.callModuleMethod( module.url, callUrl ); 
    336336                                def moduleFields = []; 
    337337                                entitiesToSearchFor.each { entity -> 
     
    636636                        } catch( Exception e ) { 
    637637                                // Exception is thrown when the call to the module fails. No problems though. 
    638                                 log.error "Error while fetching possible actions from " + module.name + ": " + e.getMessage() 
     638                                //log.error "Error while fetching possible actions from " + module.name + ": " + e.getMessage() 
     639                                e.printStackTrace() 
     640                                throw e 
    639641                        } 
    640642                } 
  • trunk/grails-app/services/dbnp/modules/ModuleCommunicationService.groovy

    r1577 r1596  
    8181         * @param restUrl       Full URL for the method to call 
    8282         * @return                      JSON    JSON object of the parsed text 
     83         * @deprecated          Use callModuleMethod instead 
    8384         */ 
    8485        def callModuleRestMethodJSON( consumer, restUrl ) throws Exception { 
     86                def parts = restUrl.split( /\?/ ); 
     87                def url = ""; 
     88                def query = ""; 
     89                 
     90                if( parts.size() > 1 ) { 
     91                        url = parts[ 0 ] 
     92                        query = parts[ 1 ] 
     93                } else if( parts.size() > 0 ) {  
     94                        url = parts[ 0 ]; 
     95                } 
     96                 
     97                return callModuleMethod( consumer, url, query ); 
     98        } 
     99         
     100        /** 
     101        * Calls a rest method on a module 
     102        * 
     103        * @param consumer       Consumer of that specific module 
     104        * @param restUrl        Full URL for the method to call, without query string 
     105        * @param args           Query string for the url to call (e.q. token=abc&field=xyz) 
     106        * @param requestMethod  GET or POST - HTTP request method to use 
     107        * @return                       JSON    JSON object of the parsed text 
     108        */ 
     109        def callModuleMethod( String consumer, String restUrl, String args = null, String requestMethod = "GET" ) { 
    85110                if (!authenticationService.isLoggedIn()) { 
    86111                        // should not happen because we can only get here when a user is 
     
    90115 
    91116                // Check whether the url is present in cache 
    92                 def cacheData = retrieveFromCache( restUrl ); 
     117                def cacheData = retrieveFromCache( restUrl, args ); 
    93118                if( cacheData && cacheData[ "success" ] ) 
    94119                        return cacheData[ "contents" ]; 
     
    104129                 
    105130                // Append the sessionToken to the URL 
    106                 def url = restUrl 
    107                 if( restUrl.indexOf( '?' ) > 0 ) { 
    108                         // The url itself also has parameters 
    109                         url += '&sessionToken=' + sessionToken 
    110                 } else { 
    111                         // The url itself doesn't have parameters 
    112                         url += '?sessionToken=' + sessionToken 
    113                 } 
     131                if( !args ) 
     132                        args = "" 
     133                 
     134                args += "&sessionToken=" + sessionToken 
    114135                 
    115136                // Perform a call to the url 
    116137                def restResponse 
    117138                try { 
    118                         def textResponse = url.toURL().getText() 
    119                         log.trace "GSCF call to " + consumer + " URL: " + url 
     139                        log.trace "GSCF call (" + requestMethod + ") to " + consumer + " URL: " + restUrl + " (args: " + args + ")" 
     140 
     141                        def textResponse 
     142                        switch( requestMethod.toUpperCase() ) { 
     143                                case "GET": 
     144                                        def url = restUrl + "?" + args; 
     145                                        def connection = url.toURL().openConnection(); 
     146                 
     147                                        textResponse = url.toURL().getText() 
     148                                 
     149                                        break 
     150                                case "POST": 
     151                                        def connection = restUrl.toURL().openConnection() 
     152                                        connection.setRequestMethod( "POST" ); 
     153                                        connection.doOutput = true 
     154                                         
     155                                        def writer = new OutputStreamWriter( connection.outputStream ) 
     156                                        writer.write( args ); 
     157                                        writer.flush() 
     158                                        writer.close() 
     159                                         
     160                                        connection.connect(); 
     161                                         
     162                                        textResponse = connection.content.text 
     163 
     164                                        break 
     165                                default: 
     166                                        throw new Exception( "Unknown request method given. Use GET or POST" ) 
     167                        } 
     168 
    120169                        log.trace "GSCF response: " + textResponse 
    121170                        restResponse = JSON.parse( textResponse ) 
    122171                } catch (Exception e) { 
    123                         storeErrorInCache( restUrl, e.getMessage() ); 
    124                         throw new Exception( "An error occurred while fetching " + url + ".", e ) 
     172                        storeErrorInCache( restUrl, e.getMessage(), args ); 
     173                        throw new Exception( "An error occurred while fetching " + restUrl + ".", e ) 
    125174                } finally { 
    126175                        // Dispose of the ephemeral session token 
    127                         //authenticationService.logOffRemotely(consumer, sessionToken) 
     176                        authenticationService.logOffRemotely(consumer, sessionToken) 
    128177                } 
    129178 
    130179                // Store the response in cache 
    131                 storeInCache( restUrl, restResponse ); 
     180                storeInCache( restUrl, restResponse, args ); 
    132181                 
    133182                return restResponse 
    134         } 
    135  
     183 
     184        } 
     185         
    136186        /** 
    137187         * Checks whether a specific url exists in cache 
     
    139189         * @return              true if the url is present in cache 
    140190         */ 
    141         def existsInCache( url ) { 
    142                 return retrieveFromCache( url ) == null; 
     191        def existsInCache( url, args = null ) { 
     192                return retrieveFromCache( url, args ) == null; 
    143193        } 
    144194 
     
    148198         * @return              JSON object with the contents of the URL or null if the url doesn't exist in cache 
    149199         */ 
    150         def retrieveFromCache( url ) { 
     200        def retrieveFromCache( url, args = null ) { 
    151201                def user = authenticationService.getLoggedInUser(); 
    152202                def userId = user ? user.id : -1; 
     203                 
     204                url = cacheUrl( url, args ) 
    153205                 
    154206                if( cache[ userId ] && cache[ userId ][ url ] && ( System.currentTimeMillis() - cache[ userId ][ url ][ "timestamp" ] ) < numberOfSecondsInCache * 1000 ) { 
     
    164216         * @param contents      Contents of the URL 
    165217         */ 
    166         def storeInCache( url, contents ) { 
     218        def storeInCache( url, contents, args = null ) { 
    167219                def user = authenticationService.getLoggedInUser(); 
    168220                def userId = user ? user.id : -1; 
     
    171223                        cache[ userId ] = [:] 
    172224 
    173                 cache[ userId ][ url ] = [ 
     225                cache[ userId ][ cacheUrl( url, args ) ] = [ 
    174226                        "timestamp": System.currentTimeMillis(), 
    175227                        "success": true, 
     
    183235        * @param contents       Contents of the URL 
    184236        */ 
    185    def storeErrorInCache( url, error ) { 
     237   def storeErrorInCache( url, error, args = null ) { 
    186238           def user = authenticationService.getLoggedInUser(); 
    187239           def userId = user ? user.id : -1; 
     
    190242                   cache[ userId ] = [:] 
    191243 
    192            cache[ userId ][ url ] = [ 
     244           cache[ userId ][ cacheUrl( url, args ) ] = [ 
    193245                   "timestamp": System.currentTimeMillis(), 
    194246                   "success": false, 
     
    196248           ]; 
    197249   } 
     250    
     251   /** 
     252    * Url used to save data in cache 
     253    */ 
     254   def cacheUrl( url, args = null ) { 
     255                if( args ) { 
     256                        // Remove sessionToken from args 
     257                        args = args; 
     258                        def sessionFound = ( args =~ /sessionToken=[^&]/ ); 
     259                        args = sessionFound.replaceAll( "sessionToken=" ); 
     260                         
     261                        url += '?' + args 
     262                } 
     263                         
     264                return url; 
     265   } 
    198266 
    199267} 
  • trunk/src/groovy/dbnp/query/Search.groovy

    r1590 r1596  
    517517                 
    518518                                        if( moduleCriteria && moduleCriteria.size() > 0 ) { 
    519                                                 def callUrl = moduleCriteriaUrl( module, entities, moduleCriteria ); 
     519                                                def callUrl = moduleCriteriaUrl( module ); 
     520                                                def callArgs = moduleCriteriaArguments( module, entities, moduleCriteria ); 
    520521                                                 
    521522                                                try { 
    522                                                         def json = moduleCommunicationService.callModuleRestMethodJSON( module.url, callUrl ); 
     523                                                        def json = moduleCommunicationService.callModuleMethod( module.url, callUrl, callArgs, "POST" ); 
    523524                                                        Closure checkClosure = moduleCriterionClosure( json ); 
    524525                                                        entities = filterEntityList( entities, moduleCriteria, checkClosure ); 
    525526                                                } catch( Exception e ) { 
    526                                                         log.error( "Error while retrieving data from " + module.name + ": " + e.getMessage() ) 
     527                                                        //log.error( "Error while retrieving data from " + module.name + ": " + e.getMessage() ) 
     528                                                        e.printStackTrace() 
     529                                                        throw e 
    527530                                                } 
    528531                                        } 
     
    541544                 
    542545                                        if( moduleCriteria && moduleCriteria.size() > 0 ) { 
    543                                                 def callUrl = moduleCriteriaUrl( module, entities, moduleCriteria ); 
     546                                                def callUrl = moduleCriteriaUrl( module ); 
     547                                                def callArgs = moduleCriteriaArguments( module, entities, moduleCriteria ); 
    544548                                                 
    545549                                                try { 
    546                                                         def json = moduleCommunicationService.callModuleRestMethodJSON( module.url, callUrl ); 
     550                                                        def json = moduleCommunicationService.callModuleMethod( module.url, callUrl, callArgs, "POST" ); 
    547551                                                        Closure checkClosure = moduleCriterionClosure( json ); 
    548552                                                         
     
    551555                                                         
    552556                                                } catch( Exception e ) { 
    553                                                         log.error( "Error while retrieving data from " + module.name + ": " + e.getMessage() ) 
     557                                                        //log.error( "Error while retrieving data from " + module.name + ": " + e.getMessage() ) 
     558                                                        e.printStackTrace() 
     559                                                        throw e 
    554560                                                } 
    555561                                        } 
     
    608614        } 
    609615         
    610         protected String moduleCriteriaUrl( module, entities, moduleCriteria ) { 
     616        protected String moduleCriteriaUrl( module ) { 
     617                def callUrl = module.url + '/rest/getQueryableFieldData' 
     618                return callUrl; 
     619        } 
     620         
     621        protected String moduleCriteriaArguments( module, entities, moduleCriteria ) { 
    611622                // Retrieve the data from the module 
    612623                def tokens = entities.collect { it.giveUUID() }.unique(); 
    613624                def fields = moduleCriteria.collect { it.field }.unique(); 
    614625         
    615                 def callUrl = module.url + '/rest/getQueryableFieldData?entity=' + this.entity 
     626                def callUrl = 'entity=' + this.entity 
    616627                tokens.sort().each { callUrl += "&tokens=" + it.encodeAsURL() } 
    617628                fields.sort().each { callUrl += "&fields=" + it.encodeAsURL() }