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

Last change on this file since 13 was 13, checked in by robert@…, 8 years ago

Improved user interface and implemented basic export functionality

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