root/trunk/grails-app/controllers/api/ApiController.groovy @ 2188

Revision 2188, 7.0 KB (checked in by work@…, 2 years ago)

- added / improved api documentation
- added getAssaysForStudy api method
- simplified and centralized simplication method for flattening domain data

Line 
1/**
2 * Api Controler
3 *
4 * API for third party applications to interact
5 * with GSCF
6 *
7 * @author  your email (+name?)
8 * @since       20120328ma
9 *
10 * Revision information:
11 * $Rev$
12 * $Author$
13 * $Date$
14 */
15package api
16
17import grails.plugins.springsecurity.Secured
18import grails.converters.JSON
19import dbnp.studycapturing.Study
20import dbnp.authentication.SecUser
21import org.dbnp.gdt.TemplateFieldType
22
23class ApiController {
24    def authenticationService
25    def ApiService
26
27        /**
28         * index closure
29         */
30    def index = {
31        render(view:'index')
32    }
33
34    @Secured(['ROLE_CLIENT', 'ROLE_ADMIN'])
35    def authenticate = {
36        println "api::authenticate: ${params}"
37
38        // see if we already have a token on file for this device id
39        def token = Token.findByDeviceID(params?.deviceID)
40       
41        // generate a new token if we don't have a token on file
42        def result = [:]
43        try {
44            // TODO - check if token belongs to current user?
45            if (!token) {
46                // generate a token for this device
47                token = new Token(
48                        deviceID    : params.deviceID,
49                        deviceToken : UUID.randomUUID().toString(),
50                        user        : authenticationService.getLoggedInUser(),
51                        sequence    : 0
52                ).save(failOnError: true)
53            }
54           
55            result = ['token':token.deviceToken,'sequence':token.sequence]
56
57            // set output headers
58            response.status = 200
59        } catch (Exception e) {
60            // caught an error
61            response.status = 500
62            result = ['error':e.getMessage()]
63        }
64
65        response.contentType = 'application/json;charset=UTF-8'
66
67        if (params.containsKey('callback')) {
68            render "${params.callback}(${result as JSON})"
69        } else {
70            render result as JSON
71        }
72    }
73
74    def getStudies = {
75        println "api::getStudies: ${params}"
76
77        String deviceID = (params.containsKey('deviceID')) ? params.deviceID : ''
78        String validation = (params.containsKey('validation')) ? params.validation : ''
79
80        // check
81        if (!apiService.validateRequest(deviceID,validation)) {
82            response.sendError(401, 'Unauthorized')
83        } else {
84            def user = Token.findByDeviceID(deviceID)?.user
85            def readableStudies = Study.giveReadableStudies(user)
86            def studies = []
87           
88            // iterate through studies and define resultset
89            readableStudies.each { study ->
90                // get result data
91                studies[ studies.size() ] = [
92                        'token'                 : study.getToken(),
93                        'title'                 : study.title,
94                        'description'           : study.description,
95                        'subjects'              : study.subjects.size(),
96                        'species'               : study.subjects.species.collect { it.name }.unique(),
97                        'assays'                : study.assays.collect { it.name }.unique(),
98                        'modules'               : study.assays.collect { it.module.name }.unique(),
99                        'events'                : study.events.size(),
100                        'uniqueEvents'          : study.events.collect { it.toString() }.unique(),
101                        'samplingEvents'        : study.samplingEvents.size(),
102                        'uniqueSamplingEvents'  : study.samplingEvents.collect { it.toString() }.unique(),
103                        'eventGroups'           : study.eventGroups.size(),
104                        'uniqueEventGroups'     : study.eventGroups.collect { it.name }.unique(),
105                        'samples'               : study.samples.size()
106                ]
107            }
108
109            def result = [
110                    'count'     : studies.size(),
111                    'studies'   : studies
112            ]
113
114            // set output headers
115            response.status = 200
116            response.contentType = 'application/json;charset=UTF-8'
117
118            if (params.containsKey('callback')) {
119                render "${params.callback}(${result as JSON})"
120            } else {
121                render result as JSON
122            }
123        }
124    }
125
126    def getSubjectsForStudy = {
127        println "api::getSubjectsForStudy: ${params}"
128
129        String deviceID     = (params.containsKey('deviceID')) ? params.deviceID : ''
130        String validation   = (params.containsKey('validation')) ? params.validation : ''
131        String studyToken   = (params.containsKey('studyToken')) ? params.studyToken : ''
132
133        // fetch user and study
134        def user    = Token.findByDeviceID(deviceID)?.user
135        def study   = Study.findByStudyUUID(studyToken)
136       
137        // check
138        if (!apiService.validateRequest(deviceID,validation)) {
139            response.sendError(401, 'Unauthorized')
140        } else if (!study) {
141            response.sendError(400, 'No such study')
142        } else if (!study.canRead(user)) {
143            response.sendError(401, 'Unauthorized')
144        } else {
145            def subjects = apiService.flattenDomainData( study.subjects )
146
147            // define result
148            def result = [
149                    'count'     : subjects.size(),
150                    'subjects'  : subjects
151            ]
152
153            // set output headers
154            response.status = 200
155            response.contentType = 'application/json;charset=UTF-8'
156
157            if (params.containsKey('callback')) {
158                render "${params.callback}(${result as JSON})"
159            } else {
160                render result as JSON
161            }
162        }
163    }
164
165    def getAssaysForStudy = {
166        println "api::getAssaysForStudy: ${params}"
167
168        String deviceID     = (params.containsKey('deviceID')) ? params.deviceID : ''
169        String validation   = (params.containsKey('validation')) ? params.validation : ''
170        String studyToken   = (params.containsKey('studyToken')) ? params.studyToken : ''
171
172        // fetch user and study
173        def user    = Token.findByDeviceID(deviceID)?.user
174        def study   = Study.findByStudyUUID(studyToken)
175
176        // check
177        if (!apiService.validateRequest(deviceID,validation)) {
178            response.sendError(401, 'Unauthorized')
179        } else if (!study) {
180            response.sendError(400, 'No such study')
181        } else if (!study.canRead(user)) {
182            response.sendError(401, 'Unauthorized')
183        } else {
184            def assays = apiService.flattenDomainData( study.assays )
185           
186            // define result
187            def result = [
188                    'count'     : assays.size(),
189                    'assays'    : assays
190            ]
191
192            // set output headers
193            response.status = 200
194            response.contentType = 'application/json;charset=UTF-8'
195
196            if (params.containsKey('callback')) {
197                render "${params.callback}(${result as JSON})"
198            } else {
199                render result as JSON
200            }
201        }
202    }
203}
Note: See TracBrowser for help on using the browser.