source: trunk/grails-app/controllers/api/ApiController.groovy @ 2186

Last change on this file since 2186 was 2186, checked in by work@…, 9 years ago
  • api methods should not use authentication, only the authenticate method
File size: 7.9 KB
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//    @Secured(['ROLE_CLIENT', 'ROLE_ADMIN'])
75    def getStudies = {
76        println "api::getStudies: ${params}"
77
78        String deviceID = (params.containsKey('deviceID')) ? params.deviceID : ''
79        String validation = (params.containsKey('validation')) ? params.validation : ''
80
81        // check
82        if (!apiService.validateRequest(deviceID,validation)) {
83            response.sendError(401, 'Unauthorized')
84        } else {
85//            def user = authenticationService.getLoggedInUser()
86            def user = Token.findByDeviceID(deviceID).user
87            def readableStudies = Study.giveReadableStudies(user)
88            def studies = []
89           
90            // iterate through studies and define resultset
91            readableStudies.each { study ->
92                // get result data
93                studies[ studies.size() ] = [
94                        'token'                 : study.getToken(),
95                        'title'                 : study.title,
96                        'description'           : study.description,
97                        'subjects'              : study.subjects.size(),
98                        'species'               : study.subjects.species.collect { it.name }.unique(),
99                        'assays'                : study.assays.collect { it.module.name }.unique(),
100                        'events'                : study.events.size(),
101                        'uniqueEvents'          : study.events.collect { it.toString() }.unique(),
102                        'samplingEvents'        : study.samplingEvents.size(),
103                        'uniqueSamplingEvents'  : study.samplingEvents.collect { it.toString() }.unique(),
104                        'eventGroups'           : study.eventGroups.size(),
105                        'uniqueEventGroups'     : study.eventGroups.collect { it.name }.unique(),
106                        'samples'               : study.samples.size()
107                ]
108            }
109           
110
111            def result = [
112                    'count'     : studies.size(),
113                    'studies'   : studies
114            ]
115
116            // set output headers
117            response.status = 200
118            response.contentType = 'application/json;charset=UTF-8'
119
120            if (params.containsKey('callback')) {
121                render "${params.callback}(${result as JSON})"
122            } else {
123                render result as JSON
124            }
125        }
126    }
127
128//    @Secured(['ROLE_CLIENT', 'ROLE_ADMIN'])
129    def getSubjectsForStudy = {
130        println "api::getSubjectsForStudy: ${params}"
131
132        String deviceID     = (params.containsKey('deviceID')) ? params.deviceID : ''
133        String validation   = (params.containsKey('validation')) ? params.validation : ''
134        String studyToken   = (params.containsKey('studyToken')) ? params.studyToken : ''
135
136        // fetch user and study
137//        def user    = authenticationService.getLoggedInUser()
138        def user    = Token.findByDeviceID(deviceID).user
139        def study   = Study.findByStudyUUID(studyToken)
140       
141        // check
142        if (!apiService.validateRequest(deviceID,validation)) {
143            response.sendError(401, 'Unauthorized')
144        } else if (!study) {
145            response.sendError(400, 'No such study')
146        } else if (!study.canRead(user)) {
147            response.sendError(401, 'Unauthorized')
148        } else {
149            def subjects = []
150           
151            // iterate through subjects
152            study.subjects.each {
153                def fields  = it.giveFields()
154                def subject = [:]
155
156                // add subject id
157                subject['id'] = it.id
158
159                // add subject field values
160                fields.each { field ->
161                    def value = it.getFieldValue( field.name )
162
163                    if (value.hasProperty('name')) {
164                        subject[ field.name ] = value.name
165                    } else {
166                        subject[ field.name ] = value
167                    }
168                }
169
170                subjects[ subjects.size() ] = subject
171            }
172           
173            // define result
174            def result = [
175                    'count'     : study.subjects.size(),
176                    'subjects'  : subjects
177            ]
178
179            // set output headers
180            response.status = 200
181            response.contentType = 'application/json;charset=UTF-8'
182
183            if (params.containsKey('callback')) {
184                render "${params.callback}(${result as JSON})"
185            } else {
186                render result as JSON
187            }
188        }
189    }
190
191
192//    @Secured(['ROLE_CLIENT', 'ROLE_ADMIN'])
193    def getAssaysForStudy = {
194        println "api::getAssaysForStudy: ${params}"
195
196        String deviceID     = (params.containsKey('deviceID')) ? params.deviceID : ''
197        String validation   = (params.containsKey('validation')) ? params.validation : ''
198        String studyToken   = (params.containsKey('studyToken')) ? params.studyToken : ''
199
200        // fetch user and study
201//        def user    = authenticationService.getLoggedInUser()
202        def user    = Token.findByDeviceID(deviceID).user
203        def study   = Study.findByStudyUUID(studyToken)
204
205        // check
206        if (!apiService.validateRequest(deviceID,validation)) {
207            println "1"
208            response.sendError(401, 'Unauthorized')
209        } else if (!study) {
210            println "2"
211            response.sendError(400, 'No such study')
212        } else if (!study.canRead(user)) {
213            println "3"
214            response.sendError(401, 'Unauthorized')
215        } else {
216            // define result
217            def result = [
218//                    'count'     : study.subjects.size(),
219//                    'subjects'  : subjects
220            ]
221
222            // set output headers
223            response.status = 200
224            response.contentType = 'application/json;charset=UTF-8'
225
226            if (params.containsKey('callback')) {
227                render "${params.callback}(${result as JSON})"
228            } else {
229                render result as JSON
230            }
231        }
232    }
233}
Note: See TracBrowser for help on using the repository browser.