source: trunk/grails-app/services/nl/tno/metagenomics/integration/GscfService.groovy @ 9

Last change on this file since 9 was 9, checked in by robert@…, 8 years ago
File size: 10.3 KB
RevLine 
[2]1package nl.tno.metagenomics.integration
2
3import grails.converters.JSON
4import org.codehaus.groovy.grails.commons.ConfigurationHolder
5
6/**
7 * EDP (External Data Provider) for GSCF
8 *
9 * @author Robert Horlings (robert@isdat.nl)
10 * @version 0.9
11 * @see nmcdsp.GscfService
12 */
13class GscfService {
14
15        def config = ConfigurationHolder.config
16
17        static transactional = true
18
19
20
21        /**
22         * Returns the URL to let the user login at GSCF
23         *
24         * @param params        Parameters of the action called
25         * @param token         Session token
26         * @return                      URL to redirect the user to
27         */
28        public String urlAuthRemote( def params, def token ) {
[3]29                def redirectURL = "${config.gscf.baseURL}/login/auth_remote?moduleURL=${this.moduleURL()}&consumer=${this.consumerID()}&token=${token}&returnUrl=${config.grails.serverURL}"
[2]30
31                if (params.controller != null){
32                        redirectURL += "/${params.controller}"
33                        if (params.action != null){
34                                redirectURL += "/${params.action}"
35                                if (params.id != null){
36                                        redirectURL += "/${params.id}"
37                                }
38                        }
39                }
40
41                return redirectURL
42        }
43
44        /**
45         * Returns the url to show details of a study in GSCF
46         *
47         * @param study         Study object to view in GSCF
48         * @return                      URL to redirect the user to
49         */
50        public String urlViewStudy( String studyToken ) {
51                return "${config.gscf.baseURL}/study/showByToken/" + studyToken
52        }
53       
54        /**
55        * Returns the url to add a new study in GSCF
56        *
57        * @return                       URL to redirect the user to
58        */
59   public String urlAddStudy( String studyToken ) {
60           return config.gscf.baseURL + config.gscf.addStudyPath
61   }
62
[9]63   /**
64   * Retrieves the currently logged in user from GSCF
65   *
66   * @param sessionToken String
67   *
68   * @return Map
69   */
70  public Map getUser(String sessionToken) {
71          def user = [:]
72          this.callGSCF(sessionToken, "getUser").each {
73                  user[ it.key ] = it.value;
74          }
75          return user
76  }
77   
[2]78        /**
79         * Retrieve a list of Studies from the GSCF
80         *
81         * @param sessionToken String
82         *
83         * @return ArrayList
84         */
85        public ArrayList getStudies(String sessionToken) {
86                return this.callGSCF(sessionToken, "getStudies")
87        }
88
89       
90        /**
91         * Retrieve a list of Studies from the GSCF
92         *
93         * @param sessionToken String
94         *
95         * @return ArrayList
96         */
97        public ArrayList getStudies(String sessionToken, ArrayList studyTokens ) {
98                return this.callGSCF(sessionToken, "getStudies", [ "studyToken": studyTokens ] );
99        }
100
101        /**
102         * Retrieve a single Study from the GSCF
103         *
104         * @param sessionToken String
105         * @param study Study
106         *
107         * @return ArrayList
108         */
109        public def getStudy(String sessionToken, String studyToken) throws NotAuthorizedException, ResourceNotFoundException {
110                def list
111
112                try {
113                        list = this.callGSCF(sessionToken, "getStudies", ["studyToken": studyToken])
114                } catch( NotAuthorizedException e ) {
115                        throw new NotAuthorizedException( "User is not authorized to access study with token " + studyToken )
116                } catch( ResourceNotFoundException e ) {
117                        throw new ResourceNotFoundException( "Study with token " + studyToken + " not found in GSCF" )
118                        throw e // Other exceptions are thrown as they appear
119                }
120
121                // Return only the first element of the list, since we are only interested in one study
122                if( list.size() == 0 ) {
123                        return []
124                } else {
125                        return list[0];
126                }
127        }
128
129        /**
130         * Retrieve a list of Assays from the GSCF
131         *
132         * @param sessionToken String
133         * @param study Study
134         *
135         * @return ArrayList
136         */
[6]137        public ArrayList getAssays(String sessionToken, String studyToken) throws NotAuthorizedException, ResourceNotFoundException {
[2]138                try {
139                        return this.callGSCF(sessionToken, "getAssays", ["studyToken": studyToken])
140                } catch( NotAuthorizedException e ) {
141                        throw new NotAuthorizedException( "User is not authorized to access study with token " + studyToken )
142                } catch( ResourceNotFoundException e ) {
143                        throw new ResourceNotFoundException( "Study with token " + studyToken + " not found in GSCF" )
144                } // Other exceptions are thrown as they appear
145        }
146
147        /**
148         * Retrieve a single Assay from the GSCF
149         *
150         * @param sessionToken String
151         * @param study Study
152         * @param assay Assay
153         *
154         * @return ArrayList
155         */     
[6]156        public def getAssay(String sessionToken, String studyToken, String assayToken ) throws NotAuthorizedException, ResourceNotFoundException {
[2]157                def list
158                try {
159                        list = this.callGSCF(sessionToken, "getAssays", ["studyToken": studyToken, "assayToken": assayToken])
160                } catch( NotAuthorizedException e ) {
161                        throw new NotAuthorizedException( "User is not authorized to access study with token " + studyToken )
162                } catch( ResourceNotFoundException e ) {
163                        throw new ResourceNotFoundException( "Assay with token " + assayToken + " not found in GSCF" )
164                } // Other exceptions are thrown as they appear
165
166                // Return only the first element of the list, since we are only interested in one assay
167                if( list.size() == 0 ) {
168                        return []
169                } else {
170                        return list[0];
171                }
172        }
173
174        /**
175         * Retrieve a list of Samples from the GSCF
176         *
177         * @param sessionToken String
178         * @param assay Assay (parameter assay is optional, only used when you want to limit the list of samples of an Assay within a Study)
179         *
180         * @return ArrayList
181         */
[6]182        public ArrayList getSamples(String sessionToken, String assayToken) throws NotAuthorizedException, ResourceNotFoundException {
[2]183                // Samples of a Study limited to a single Assay
184                try {
185                        return this.callGSCF(sessionToken, "getSamples", ["assayToken":assayToken])
186                } catch( NotAuthorizedException e ) {
187                        throw new NotAuthorizedException( "User is not authorized to access study for assay with token " + assayToken )
188                } catch( ResourceNotFoundException e ) {1
189                        throw new ResourceNotFoundException( "Assay with token " + assayToken + " not found in GSCF" )
190                } // Other exceptions are thrown as they appear
191
192        }
193
194        /**
195         * Retrieve a single Sample from the GSCF
196         *
197         * @param sessionToken String
198         * @param assay Assay
199         * @param sample Sample 
200         *
201         * @return ArrayList
202         */
[6]203        public def getSample(String sessionToken, String assayToken, String sampleToken) throws NotAuthorizedException, ResourceNotFoundException {
[2]204                def list
205
206                try {
207                        list = this.callGSCF(sessionToken, "getSamples", ["assayToken": assayToken , "sampleToken": sampleToken])
208                } catch( NotAuthorizedException e ) {
209                        throw new NotAuthorizedException( "User is not authorized to access study for assay with token " + assayToken )
210                } catch( ResourceNotFoundException e ) {1
211                        throw new ResourceNotFoundException( "Assay with token " + assayToken + " not found in GSCF" )
212                } // Other exceptions are thrown as they appear
213
214                // Return only the first element of the list, since we are only interested in one sample
215                if( list.size() == 0 )
216                        return []
217                else
218                        return list[ 0 ];
219
220        }
221
222        /**
223         * Retrieve study access
224         *
225         * @param sessionToken String
226         * @param study Study
227         *
228         * @return ArrayList
229         */
[4]230        public HashMap getAuthorizationLevel(String sessionToken, String studyToken) throws ResourceNotFoundException {
[2]231                ArrayList list
232
233                try {
234                        list = this.callGSCF(sessionToken, "getAuthorizationLevel", ["studyToken":studyToken])
235                } catch( ResourceNotFoundException e ) {
236                        throw new ResourceNotFoundException( "Study with token " + studyToken + " not found in GSCF")
237                } // Other exceptions are thrown as they appear
238
239                HashMap map = [:]
240
241                // Convert the list back to a hashmap
242                list.each { entry ->
243                        map[ entry.key ] = entry.value
244                }
245
246                return map
247        }
248
249        /**
250         * Base URL of GSCF Rest Controller/API
251         *
252         * @return      url String
253         */
254        private String restURL() {
255                return "${config.gscf.baseURL}/rest"
256        }
257
258        /**
259         * Call GSCF Service via a secure call
260         *
261         * @param       sessionToken Session token for connection to GSCF
262         * @param       restMethod Method to call on GSCF rest controller
263         * @param       restParams Parameters to provide to the GSCF rest method
264         *
265         * @return      ArrayList
266         */
267        private ArrayList callGSCF(String sessionToken, String restMethod, HashMap restParams = [:]) throws BadRequestException, NotAuthenticatedException, NotAuthorizedException, ResourceNotFoundException, Exception {
268
269                def gscfResponse = []
270
271                //construct addr
272                def addr = "${this.restURL()}/${restMethod}?moduleURL=${this.moduleURL()}&consumer=${this.consumerID()}&token=${sessionToken}"
273
274                // concat all Rest Call specific arguments behind addr
275                restParams.each {parameter -> 
276                        // If a list is given as value, the parameter should show up multiple times
277                        if( parameter.value instanceof Collection ) {
278                                parameter.value.each { value ->
[6]279                                        addr += "&${parameter.key}=" + value.toString().encodeAsURL()
[2]280                                }
281                        } else {
[6]282                                addr += "&${parameter.key}=" + parameter.value.toString().encodeAsURL()
[2]283                        } 
284                }
285
286                // Open the connection
287                def connection;
288
289                try {
290                        log.info("GSCF REST-CALL: ${addr}")
291                        connection = addr.toURL().openConnection()
292                } catch( Exception e ) {
293                        log.error("GSCF Call failed when calling service: ${addr}",e)
294                        throw new Exception( "Calling GSCF Rest method ${restMethod} failed. Please check log for more information.", e )
295                }
296
297                switch( connection.responseCode ) {
298                        case 400:       // Bad request
299                                throw new BadRequestException( "Bad request made to GSCF server: " + addr );
300                                break;
301                        case 401:       // Not allowed to access this resource
302                                throw new NotAuthorizedException( "User is not authorized to access the resource " + addr );
303                                break;
304                        case 403:       // Incorrect authentication
305                                throw new NotAuthenticatedException( "User is not authenticated with GSCF." );
306                                break;
307                        case 404:       // Resource not found
308                                throw new ResourceNotFoundException( "Specified resource could not be found: "  + addr );
309                                break;
310                        case 500:       // Internal server error
311                                throw new Exception( "An unknown error occured when calling service: " + addr + " - " + connection.responseMessage )
312                                break;
313                        default:
314                                try {
315                                        def jsonResponse = JSON.parse(connection.content.text)
316                                        jsonResponse.each { jsonProperty ->
317                                                gscfResponse << jsonProperty
318                                        }
319
320                                        log.info("GSCF REST-RESP: ${jsonResponse}")
321                                } catch(Exception e) {
322                                        log.error("Parsing GSCF JSON response failed at ${addr}. Reponse was " + connection.content.text,e)
323                                        throw new Exception( "Parsing GSCF JSON response failed at ${addr}.  Please check log for more information.", e )
324                                }
325                                break;
326                }
327
328                return gscfResponse
329        }
330
331
332        /**
333         * Consumer ID for connection to of GSCF Rest Controller/API
334         *
335         * @return      consumerID      String
336         */
337        private String consumerID() {
338                return config.metagenomics.consumerID
339        }
340
341        /**
342         * Module URL for connection to of GSCF Rest Controller/API
343         *
344         * @return      moduleURL       String
345         */
346        private String moduleURL() {
[3]347                return config.grails.serverURL
[2]348        }
349
350}
Note: See TracBrowser for help on using the repository browser.