root/trunk/grails-app/controllers/RestController.groovy @ 2095

Revision 2095, 22.5 KB (checked in by s.h.sikkema@…, 2 years ago)

- Merged assay export and galaxy assay fetch code - now possible to select fetched data in galaxy
- removed unused assay methods and gsps generated by grails
- getUser now returns displayName instead of username in case of shibboleth users

  • Property svn:keywords set to Rev Author Date
RevLine 
[480]1/**
[904]2 * RestController
[480]3 *
[515]4 * This controler provides a REST service.
5 * The names of the RESET resources are the same as the names of this
6 * controller's actions. E.g., the resources called getStudies simply
7 * corresponds to the action getStudies. Some of the resources are parameterized.
8 * The parameters are passed as parameters in the url and are available in the
9 * params respecting Grails' conventions. In this file, we adher to the javadoc 
10 * convention for describing parameters ("@param"), but actually we mean
11 * key-value pairs in the params object of each Grails action we comment on.
[480]12 *
[649]13 * @author      Jahn-Takeshi Saito
[515]14 * @since       20100601
[480]15 *
16 */
17
[515]18import dbnp.studycapturing.Study
19import dbnp.studycapturing.Assay
[976]20import dbnp.authentication.SecUser
[515]21import grails.converters.*
[831]22import nl.metabolomicscentre.dsp.http.BasicAuthentication
[1010]23import dbnp.rest.common.CommunicationManager
[1036]24import org.springframework.security.core.context.SecurityContextHolder;
[480]25
26class RestController {
27
[1813]28        /**************************************************/
29        /** Rest resources for Simple Assay Module (SAM) **/
30        /**************************************************/
[480]31
[1588]32        def authenticationService
[1974]33        //def beforeInterceptor = [action:this.&auth,except:["isUser"]]
[829]34        def credentials
[1094]35        def requestUser
[649]36
[831]37        /**
38         * Authorization closure, which is run before executing any of the REST resource actions
[983]39         * It fetches a consumer/token combination from the url and checks whether
40         * that is a correct and known combination
41         *
42         * @param       consumer        consumer name of the calling module
43         * @param       token           token for the authenticated user (e.g. session_id)
[1094]44         * @return  true if the user is remotely logged in, false otherwise
[831]45         */
[835]46        private def auth() {
[1588]47                if( !authenticationService.isRemotelyLoggedIn( params.consumer, params.token ) ) {
[983]48                        response.sendError(403)
49                        return false
50                } else {
[831]51                        return true
52                }
[829]53        }
54
[835]55        /**
[983]56         * REST resource for data modules.
57         * Consumer and token should be supplied via URL parameters.
58         * Determines whether the given user/password combination is a valid GSCF account.
59         *
60         * @param       consumer        consumer name of the calling module
61         * @param       token           token for the authenticated user (e.g. session_id)
62         * @return bool {"authenticated":true} when user/password is a valid GSCF account, {"authenticated":false} otherwise.
63         */
64        def isUser = {
[1588]65                boolean isUser = authenticationService.isRemotelyLoggedIn( params.consumer, params.token )
[843]66                def reply = ['authenticated':isUser]
[1655]67
68                // set output header to json
69                response.contentType = 'application/json'
70
[843]71                render reply as JSON
[835]72        }
[829]73
[996]74        /**
75         * REST resource for data modules.
76         * Consumer and token should be supplied via URL parameters.
77         * Provides the details of the user that has logged in
78         *
79         * @param       consumer        consumer name of the calling module
80         * @param       token           token for the authenticated user (e.g. session_id)
81         * @return bool {"username": "...", "id": ... } when user/password is logged in.
82         */
83        def getUser = {
[1968]84                if( !auth() )
85                        return;
86               
[1588]87                SecUser user = authenticationService.getRemotelyLoggedInUser( params.consumer, params.token )
[1655]88
[2095]89                def username = user.shibbolethUser ? user.displayName : user.username
90
91                def reply = [username: username, id: user.id, isAdministrator: user.hasAdminRights() ]
92
[1655]93                // set output header to json
94                response.contentType = 'application/json'
95
[996]96                render reply as JSON
97        }
[945]98
[515]99        /**
[1813]100         * REST resource for data modules.
101         * Consumer and token should be supplied via URL parameters.
102         * Provide a list of all studies owned by the supplied user.
[983]103         *
[1011]104         * @param       studyToken  optional parameter. If no studyToken is given, all studies available to user are returned.
105         *                      Otherwise, the studies for which the studyTokens are given are be returned.
[983]106         * @param       consumer        consumer name of the calling module
107         * @param       token           token for the authenticated user (e.g. session_id)
[1011]108         * @return  JSON object list containing 'studyToken', and 'name' (title) for each study
109         *
[1328]110         * If one study is requested, a 404 error might occur if the study doesn't exist, and a 401 error if the user is not
111         * authorized to access this study. If multiple studies are requrested, non-existing studies or studies for which the
112         * user is not authorized are not returned in the list (so the list might be empty).
[1011]113         *
114         * Example 1. REST call without studyToken.
115         *
116         * Call: http://localhost:8080/gscf/rest/getStudies/query
117         *
118         * Result: [{"title":"NuGO PPS3 mouse study leptin module","studyToken":"PPS3_leptin_module",
119         *                      "startDate":"2008-01-01T23:00:00Z","published":false,"Description":"C57Bl/6 mice were fed a high fat (45 en%)
120         *                      or low fat (10 en%) diet after a four week run-in on low fat diet.","Objectives":null,"Consortium":null,
121         *                      "Cohort name":null,"Lab id":null,"Institute":null,"Study protocol":null},
122         *                      {"title":"NuGO PPS human study","studyToken":"PPSH","startDate":"2008-01-13T23:00:00Z","published":false,
123         *                      "Description":"Human study performed at RRI; centres involved: RRI, IFR, TUM, Maastricht U.","Objectives":null,
124         *                      "Consortium":null,"Cohort name":null,"Lab id":null,"Institute":null,"Study protocol":null}]
125         *
126         *
127         * Example 2. REST call with one studyToken.
128         *
129         * Call: http://localhost:8080/gscf/rest/getStudies/query?studyToken=PPSH
130         *
131         * Result: [{"title":"NuGO PPS human study","studyToken":"PPSH","startDate":"2008-01-13T23:00:00Z",
132         *              "published":false,"Description":"Human study performed at RRI; centres involved: RRI, IFR, TUM, Maastricht U.",
133         *              "Objectives":null,"Consortium":null,"Cohort name":null,"Lab id":null,"Institute":null,"Study protocol":null}]
134         *
135         *
136         *
137         * Example 2. REST call with two studyTokens.
138         *
139         * http://localhost:8080/gscf/rest/getStudies/query?studyToken=PPSH&studyToken=PPS3_leptin_module
140         *
141         * Result: same as result of Example 1.
[983]142         */
[515]143        def getStudies = {
[1941]144                def user = authenticationService.getRemotelyLoggedInUser( params.consumer, params.token )
145               
[1813]146                List returnStudies = []
147                List studies = []
[1011]148
149                if( !params.studyToken ) {
150                        studies = Study.findAll()
[600]151                }
[1011]152                else if( params.studyToken instanceof String ) {
[1813]153                        def study = Study.findByStudyUUID( params.studyToken )
[1328]154                        if( study ) {
[1968]155                                if( !study.canRead(user) ) {
[1328]156                                        response.sendError(401)
157                                        return false
158                                }
[1813]159
160                                studies.push study
[1328]161                        } else {
162                                response.sendError(404)
163                                return false
164                        }
[1813]165
[1011]166                }
[1813]167                else {
[1011]168                        params.studyToken.each{ studyToken ->
[1440]169                                def study = Study.findByStudyUUID( studyToken );
[1328]170                                if( study )
[1813]171                                        studies.push study
[1011]172                        }
173                }
174
[1813]175
[1011]176                studies.each { study ->
177                        if(study) {
178                                // Check whether the person is allowed to read the data of this study
[1968]179                                if( study.canRead(user)) {
[1100]180
[1967]181                                        def items = [studyToken:study.giveUUID(), 'public': study.publicstudy]
[1813]182                                        study.giveFields().each { field ->
183                                                def name = field.name
184                                                def value = study.getFieldValue( name )
185                                                items[name] = value
186                                        }
187
188                                        // Add study version number
[1357]189                                        items['version'] = study.version;
[1813]190
191                                        returnStudies.push items
192                                }
[1011]193                        }
194                }
195
[1655]196                // set output header to json
197                response.contentType = 'application/json'
198
199                render returnStudies as JSON
[515]200        }
[480]201
[1357]202        /**
203         * REST resource for data modules.
204         * Consumer and token should be supplied via URL parameters.
205         * Provides the version number of the specified study
206         *
207         * @param       studyToken  optional parameter. If no studyToken is given, a 400 error is given
208         * @param       consumer        consumer name of the calling module
209         * @param       token           token for the authenticated user (e.g. session_id)
210         * @return  JSON object list containing 'studyToken', and 'version'
211         *
212         * A 404 error might occur if the study doesn't exist, and a 401 error if the user is not
213         * authorized to access this study.
214         *
215         * Example. REST call with one studyToken.
216         *
217         * Call: http://localhost:8080/gscf/rest/getStudyVersion?studyToken=PPSH
218         *
219         * Result: {"studyToken":"PPSH","version":31}
220         */
221        def getStudyVersion = {
[1968]222                def user = authenticationService.getRemotelyLoggedInUser( params.consumer, params.token )
223               
[1357]224                def versionInfo = [:];
225                def study
[1813]226
[1357]227                if( !params.studyToken || !(params.studyToken instanceof String)) {
228                        response.sendError(400)
229                        return false
230                } else {
[1440]231                        study = Study.findByStudyUUID( params.studyToken )
[1357]232                        if( study ) {
[1968]233                                if( !study.canRead(user) ) {
[1357]234                                        response.sendError(401)
235                                        return false
236                                }
237                        } else {
238                                response.sendError(404)
239                                return false
240                        }
241                }
242
243                versionInfo[ 'studyToken' ] = params.studyToken;
244                versionInfo[ 'version' ] = study.version;
245
[1655]246                // set output header to json
247                response.contentType = 'application/json'
248
[1357]249                render versionInfo as JSON
250        }
251
[515]252        /**
[1941]253        * REST resource for data modules.
254        * Consumer and token should be supplied via URL parameters.
255        * Provides the version number of all studies readable by this user
256        *
257        * @param        consumer        consumer name of the calling module
258        * @param        token           token for the authenticated user (e.g. session_id)
259        * @return  JSON object list containing studies with 'studyToken', and 'version'
260        *
261        * A 404 error might occur if the study doesn't exist, and a 401 error if the user is not
262        * authorized to access this study.
263        *
264        * Example. REST call with one studyToken.
265        *
266        * Call: http://localhost:8080/gscf/rest/getStudyVersions
267        *
268        * Result: [{"studyToken":"PPSH","version":31},{"studyToken":"Other study", "version":3}]
269        */
270   def getStudyVersions = {
271           // Check which user has been logged in
272           def user = authenticationService.getRemotelyLoggedInUser( params.consumer, params.token )
273           
274           def jsonList = []
275           
276                Study.giveReadableStudies( user ).each { study ->
277                        if(study) {
278                                jsonList << [studyToken:study.giveUUID(), version: study.version]
279                        }
280                }
281
282                // set output header to json
283                response.contentType = 'application/json'
284
285                render jsonList as JSON
286   }
287
288       
289        /**
[983]290         * REST resource for data modules.
291         * Consumer and token should be supplied via URL parameters.
292         * Provide a list of all subjects belonging to a study.
293         *
[1328]294         * If the user is not allowed to read the study contents, a 401 error is given. If the study doesn't exist, a 404 error is given
[983]295         *
296         * @param       studyToken      String The external study id (code) of the target GSCF Study object
297         * @param       consumer        consumer name of the calling module
298         * @param       token           token for the authenticated user (e.g. session_id)
299         * @return JSON object list of subject names
300         */
[523]301        def getSubjects = {
[1968]302                // Check which user has been logged in
303                def user = authenticationService.getRemotelyLoggedInUser( params.consumer, params.token )
304 
[1813]305                List subjects = []
[904]306                if( params.studyToken ) {
[1813]307                        def study = Study.findByStudyUUID( params.studyToken)
[983]308
309                        if(study) {
310                                // Check whether the person is allowed to read the data of this study
[1968]311                                if( !study.canRead(user) ) {
[983]312                                        response.sendError(401)
313                                        return false
314                                }
315
316                                study.subjects.each { subjects.push it.name }
[1328]317                        } else {
318                                response.sendError(404)
319                                return false
[983]320                        }
[600]321                }
[1655]322
323                // set output header to json
324                response.contentType = 'application/json'
325
326                render subjects as JSON
[523]327        }
328
329
330        /**
[983]331         * REST resource for data modules.
332         * Consumer and token should be supplied via URL parameters.
333         * Provide a list of all assays for a given study.
334         *
[1328]335         * If the user is not allowed to read the study contents, a 401 error is given. If the study doesn't exist, a 404 error is given
[983]336         *
337         * @param       studyToken      String The external study id (code) of the target GSCF Study object
338         * @param       consumer        consumer name of the calling module
[1994]339         * @param   moduleURL   URL of the calling module - NOTE: this is used as identifier for the module!
340         * The moduleURL that is passed on from the module should match exactly with the module URL that is specified in GSCF.
341         * Otherwise the module assays will not be visible.
342         *
[983]343         * @return list of assays in the study as JSON object list, filtered to only contain assays
344         *         for the specified module, with 'assayToken' and 'name' for each assay
[1813]345         *
346         *
347         * Example 1. REST call without assayToken
348         *            http://localhost:8080/gscf/rest/getAssays/aas?studyToken=PPSH
[1014]349         *                              &consumer=http://localhost:8182/sam
[1813]350         *
351         * Result: [{"name":"Glucose assay after",
[1010]352         *                      "module":{"class":"dbnp.studycapturing.AssayModule","id":1,"name":"SAM module for clinical data",
353         *                              "platform":"clinical measurements","url":"http://localhost:8182/sam"},
354         *                      "externalAssayID":"PPSH-Glu-A", "Description":null,"parentStudyToken":"PPSH"},
355         *                      {"name":"Glucose assay before",
356         *                              "module":{"class":"dbnp.studycapturing.AssayModule","id":1,"name":"SAM module for clinical data",
357         *                              "platform":"clinical measurements","url":"http://localhost:8182/sam"},
358         *                              "externalAssayID":"PPSH-Glu-B","Description":null,"parentStudyToken":"PPSH"}]
[1813]359         *
360         *
361         * Example 2. REST call with one assayToken
362         *                        http://localhost:8080/gscf/rest/getAssays/queryOneTokenz?studyToken=PPSH
[1014]363         *                              &consumer=http://localhost:8182/sam&assayToken=PPSH-Glu-A
[1813]364         *
[1010]365         * Result: [{"name":"Glucose assay after","module":{"class":"dbnp.studycapturing.AssayModule","id":1,
366         *                      "name":"SAM module for clinical data","platform":"clinical measurements","url":"http://localhost:8182/sam"},
367         *                      "externalAssayID":"PPSH-Glu-A","Description":null,"parentStudyToken":"PPSH"}]
368         *
369         *
[1813]370         * Example 3. REST call with two assayTokens.
371         *
372         * Result: Same as result in Example 1.
[983]373         */
[515]374        def getAssays = {
[1968]375                // Check which user has been logged in
376                def user = authenticationService.getRemotelyLoggedInUser( params.consumer, params.token )
377 
[1655]378                // set output header to json
379                response.contentType = 'application/json'
[1010]380
[1813]381                List returnList = []    // return list of hashes each containing fields and values belonging to an assay
[1010]382
[1813]383                // Check if required parameters are present
384                def validCall = CommunicationManager.hasValidParams( params, "consumer" )
385                if( !validCall ) {
[1821]386                        response.status = 500;
[1655]387                        render "Error. Wrong or insufficient parameters." as JSON
[1010]388                        return
389                }
[1994]390               
[1813]391                def assays = []
392               
[904]393                if( params.studyToken ) {
[1994]394
[1813]395                        def study = Study.findByStudyUUID(params.studyToken)
[983]396
397                        if(study) {
398                                // Check whether the person is allowed to read the data of this study
[1968]399                                if( !study.canRead(user)) {
[983]400                                        response.sendError(401)
401                                        return false
[935]402                                }
[983]403
[1010]404                                if(params.assayToken==null) {
405                                        assays = study.assays
406                                }
[1813]407                                else if( params.assayToken instanceof String ) {
[1440]408                                        def assay = study.assays.find{ it.giveUUID() == params.assayToken }
[1010]409                                        if( assay ) {
[1813]410                                                assays.push assay
[1010]411                                        }
412                                }
413                                else {                                                                                                  // there are multiple assayTokens instances
414                                        params.assayToken.each { assayToken ->
[1440]415                                                def assay = study.assays.find{ it.giveUUID() == assayToken }
[1010]416                                                if(assay) {
417                                                        assays.push assay
418                                                }
419                                        }
420                                }
421
[1813]422                        } else {
[1328]423                                response.sendError(404)
424                                return false
425                        }
[1010]426
[1813]427                } else {
428                        // Return all assays for the given module
[1968]429                        assays = Assay.list().findAll{ it.parent.canRead( user ) }
[1813]430                }
431
432                // Create data for all assays
433                assays.each{ assay ->
[1994]434                        if (assay.module?.url && assay.module.url.equals(params.moduleURL)) {
435                                if(assay) {
436                                        def map = [assayToken : assay.giveUUID()]
437                                        assay.giveFields().each { field ->
438                                                def name = field.name
439                                                def value = assay.getFieldValue( name )
440                                                map[name] = value
441                                        }
442                                        map["parentStudyToken"] = assay.parent.giveUUID()
443                                        returnList.push( map )
[1990]444                                }
[1813]445                        }
446                }
447
[1655]448                render returnList as JSON
[515]449        }
450
451        /**
[983]452         * REST resource for data modules.
453         * Provide all samples of a given Assay. The result is an enriched list with additional information for each sample.
454         *
[1328]455         * If the user is not allowed to read the study contents, a 401 error is given. If the assay doesn't exist, a 404 error is given
456         *
[983]457         * @param       assayToken      String (assayToken of some Assay in GSCF)
[1001]458         * @param       sampleToken Optional parameter. One or more sampleTokens to specify what sample to give exectly.
459         *                      If not given, return all samples for specified assay.
[983]460         * @param       consumer        consumer name of the calling module
461         * @param       token           token for the authenticated user (e.g. session_id)
462         * @return As a JSON object list, for each sample in that assay:
463         * @return 'name' (Sample name, which is unique)
464         * @return 'material' (Sample material)
465         * @return 'subject' (The name of the subject from which the sample was taken)
466         * @return 'event' (the name of the template of the SamplingEvent describing the sampling)
467         * @return 'startTime' (the time the sample was taken relative to the start of the study, as a string)
[1094]468         * @return additional template fields are returned
[1813]469         *
470         *
471         *
472         * Example 1: no sampleTokens given.
[1001]473         * Query:
[1813]474         * http://localhost:8080/gscf/rest/getSamples/query?assayToken=PPSH-Glu-A
475         *
[1001]476         * Result:
[1813]477         * [{"sampleToken":"5_A","material":"blood plasma","subject":"5","event":"Blood extraction","startTime":"4 days, 6 hours"},
[1968]478         * {"sampleToken":"6_A","mateauthenticationService.getRemotelyLoggedInUser( params.consumer, params.token )rial":"blood plasma","subject":"6","event":"Blood extraction","startTime":"4 days, 6 hours"},
[1001]479         * {"sampleToken":"10_A","material":"blood plasma","subject":"10","event":"Blood extraction","startTime":"4 days, 6 hours"},
480         * {"sampleToken":"2_A","material":"blood plasma","subject":"2","event":"Blood extraction","startTime":"4 days, 6 hours"},
481         * {"sampleToken":"11_A","material":"blood plasma","subject":"11","event":"Blood extraction","startTime":"4 days, 6 hours"},
482         * {"sampleToken":"1_A","material":"blood plasma","subject":"1","event":"Blood extraction","startTime":"4 days, 6 hours"},
483         * {"sampleToken":"9_A","material":"blood plasma","subject":"9","event":"Blood extraction","startTime":"4 days, 6 hours"},
484         * {"sampleToken":"4_A","material":"blood plasma","subject":"4","event":"Blood extraction","startTime":"4 days, 6 hours"},
485         * {"sampleToken":"8_A","material":"blood plasma","subject":"8","event":"Blood extraction","startTime":"4 days, 6 hours"},
486         * {"sampleToken":"7_A","material":"blood plasma","subject":"7","event":"Blood extraction","startTime":"4 days, 6 hours"},
487         * {"sampleToken":"3_A","material":"blood plasma","subject":"3","event":"Blood extraction","startTime":"4 days, 6 hours"}]
[1813]488         *
489         *
490         *
491         * Example 2: one sampleToken given.
[1001]492         * Query:
493         * http://localhost:8080/gscf/rest/getSamples/query?assayToken=PPSH-Glu-A&sampleToken=5_A
[1813]494         *
495         * Result:
[1001]496         * [{"sampleToken":"5_A","material":"blood plasma","subject":"5","event":"Blood extraction","startTime":"4 days, 6 hours"}]
[1813]497         *
498         *
499         *
500         * Example 3: two sampleTokens given.
[1001]501         * Query:
[1512]502         * http://localhost:8080/gscf/rest/getSamples/query?assayToken=PPSH-Glu-A&sampleToken=5_A&sampleToken=6_A
[1813]503         *
504         * Result:
[1001]505         * [{"sampleToken":"5_A","material":"blood plasma","subject":"5","event":"Blood extraction","startTime":"4 days, 6 hours"},
506         *  {"sampleToken":"6_A","material":"blood plasma","subject":"6","event":"Blood extraction","startTime":"4 days, 6 hours"}]
[1512]507         *
508         *
[1813]509         * Example 4: no assaytoken given
[1512]510         * Query:
511         * http://localhost:8080/gscf/rest/getSamples/query?sampleToken=5_A&sampleToken=6_A
[1813]512         *
513         * Result:
[1512]514         * [{"sampleToken":"5_A","material":"blood plasma","subject":"5","event":"Blood extraction","startTime":"4 days, 6 hours"},
515         *  {"sampleToken":"6_A","material":"blood plasma","subject":"6","event":"Blood extraction","startTime":"4 days, 6 hours"}]
516         *
[983]517         */
[515]518        def getSamples = {
[1968]519                // Check which user has been logged in
520                def user = authenticationService.getRemotelyLoggedInUser( params.consumer, params.token )
521
[600]522                def items = []
[1512]523                def samples
[904]524                if( params.assayToken ) {
[1813]525                        def assay = Assay.findByAssayUUID( params.assayToken );
[1101]526
[945]527                        if( assay )  {
[1328]528                                // Check whether the person is allowed to read the data of this study
[1968]529                                if( !assay.parent.canRead( user )) {
[1328]530                                        response.sendError(401)
531                                        return false
532                                }
[1813]533
[1512]534                                samples = assay.getSamples() // on all samples
535                        } else {
536                                // Assay not found
537                                response.sendError(404)
538                                return false
539                        }
540                } else {
541                        // Find all samples from studies the user can read
[1968]542                        def studies = Study.list().findAll { it.canRead( user ) };
[1512]543                        samples = studies*.getSamples().flatten();
544                }
[1813]545
[1512]546                // Check whether only a subset of samples should be returned
547                if( params.sampleToken ) {
548                        def sampleTokens = params.list( "sampleToken" );
[1813]549                        samples = samples.findAll { sampleTokens.contains( it.giveUUID() ) }
[1512]550                }
[1094]551
[1512]552                samples.each { sample ->
[1094]553
[1813]554                        def item = [
555                                                'sampleToken' : sample.giveUUID(),
556                                                'material'        : sample.material?.name,
557                                                'subject'         : sample.parentSubject?.name,
558                                                'event'           : sample.parentEvent?.template?.name,
559                                                'startTime'       : sample.parentEvent?.getStartTimeString()
560                                        ]
[1094]561
[1512]562                        sample.giveFields().each { field ->
563                                def name = field.name
564                                def value = sample.getFieldValue( name )
565                                if(name!='material')
566                                {
567                                        item[name]=value
568                                }
569                        }
[1094]570
[1512]571                        if(sample.parentEvent) {
572                                def parentEvent = sample.parentEvent
573                                def eventHash = [:]
574                                parentEvent.giveFields().each { field ->
575                                        def name = field.name
576                                        if( name !='sampleTemplate' && name != 'fields') {
577                                                def value = parentEvent.getFieldValue( name )
578                                                eventHash[name]=value
[1001]579                                        }
[1512]580                                }
[1813]581                                item['eventObject'] = eventHash
[1512]582                        }
[1095]583
[1512]584                        if(sample.parentSubject) {
585                                def parentSubject = sample.parentSubject
586                                def subject = [:]
587                                parentSubject.giveFields().each { field ->
588                                        def name = field.name
589                                        if( name!='fields') {
590                                                def value = parentSubject.getFieldValue( name )
591                                                subject[name]=value
[1095]592                                        }
[1512]593                                }
[1813]594                                item['subjectObject'] = subject
[1512]595                        }
[1095]596
[1813]597                        items.push item
[1512]598                }
[1095]599
[1655]600                // set output header to json
601                response.contentType = 'application/json'
602
[600]603                render items as JSON
[515]604        }
605
[901]606        /**
[1884]607         * Returns the authorization level the user has for a given study or assay.
[983]608         *
[1884]609         * If no studyToken or assayToken is given, a 400 (Bad Request) error is given.
610         * If both a studyToken and assayToken are given, the studyToken is used and the assayToken is ignored.
611         * If the given assay or study doesn't exist, a 404 (Not found) error is given.
[983]612         *
613         * @param       consumer        consumer name of the calling module
614         * @param       token           token for the authenticated user (e.g. session_id)
[1884]615         * @param       studyToken      token of the study for which the authorization is asked
616         * @param       assayToken      token of the study for which the authorization is asked
[983]617         * @return      JSON Object
618         * @return  { isOwner: true/false, 'canRead': true/false, 'canWrite': true/false }
619         */
[908]620        def getAuthorizationLevel = {
[1884]621                def study
622               
[935]623                if( params.studyToken ) {
[1884]624                        study = Study.findByStudyUUID(params.studyToken);
625                } else if( params.assayToken ) {
626                        study = Assay.findByAssayUUID(params.assayToken)?.parent;
627                } else {
628                        response.sendError(400)
629                        return false
630                }
[983]631
[1884]632                if( !study ) {
633                        response.sendError(404)
634                        return false
635                }
[983]636
[1884]637                def user = authenticationService.getRemotelyLoggedInUser( params.consumer, params.token );
638                def auth = ['isOwner': study.isOwner(user), 'canRead': study.canRead(user), 'canWrite': study.canWrite(user)];
[1968]639                log.trace "Authorization for study " + study.title + " and user " + user?.username + ": " + auth
[1655]640
[1884]641                // set output header to json
642                response.contentType = 'application/json'
[1655]643
[1884]644                render auth as JSON;
[1813]645        }
[1655]646}
Note: See TracBrowser for help on using the browser.