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

Revision 829, 8.4 KB (checked in by keesvb, 4 years ago)

started authentication implementation

Line 
1/**
2 * RestControler
3 *
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.
12 *
13 * @author      Jahn-Takeshi Saito
14 * @since       20100601
15 *
16 */
17
18import data.*
19import dbnp.studycapturing.Study
20import dbnp.studycapturing.Assay
21import grails.converters.*
22import org.codehaus.groovy.grails.web.json.*
23
24
25
26class RestController {
27
28
29
30       /**************************************************/
31      /** Rest resources for Simple Assay Module (SAM) **/
32     /**************************************************/
33
34        def beforeInterceptor = [action:this.&auth]
35        def credentials
36// defined as a regular method so its private
37
38        def auth() {
39            credentials = nl.metabolomicscentre.dsp.http.BasicAuthentication.credentialsFromRequest(request)
40                if(false) {
41                    response.sendError(403)
42                return false
43            }
44        }
45
46
47
48        /**
49        * REST resource for the Simple Assay Module.
50        * Provide a list of all studies.
51        *
52        *
53        * @return as JSON object list of members externalStudyID, and title for all studies
54        */
55        def getStudies = {
56                List studies = []
57                Study.list().each { study ->
58                        studies.push( [ 'externalStudyID': study.code, 'name':study.title ] )
59                }
60                render studies as JSON
61        }
62
63
64        /**
65        * REST resource for the Simple Assay Module.
66        * Provide a list of all subjects belonging to a study.
67        *
68        * @param  externalStudyID
69        * @return as JSON object list of subject names
70        */
71        def getSubjects = {
72                List subjects = []
73                if( params.externalStudyID ) {
74                        def id = params.externalStudyID
75                        def study = Study.find( "from Study as s where s.code=?", [id])
76                        if(study) study.subjects.each { subjects.push it.name }
77                }
78                render subjects as JSON
79        }
80
81
82        /**
83        * REST resource for the Simple Assay Module.
84        * Provide a list of all assays for a given study
85        *
86        * Example call of the getAssays REST resource: http://localhost:8080/gscf/rest/getAssays?externalStudyID=PPSH&moduleURL=http://localhost:8182/sam
87        *
88        * @param externalStudyID The external study id (code) of the target GSCF Study object
89        * @param moduleURL The base URL of the calling dbNP module
90        * @return list of assays in the study as JSON object, filtered to only contain assays for the specified module
91        */
92        def getAssays = {
93                List assays = []
94                if( params.externalStudyID ) {
95                        println params.moduleURL
96                        def study = Study.find( "from Study as s where s.code=?", [params.externalStudyID])
97                        if(study) study.assays.each{ assay ->
98                                println assay.module.url
99                                if (assay.module.url.equals(params.moduleURL)) {
100                                def map = ['name':assay.name, 'externalAssayID':assay.externalAssayID]
101                                        assays.push( map )
102                                }
103                        }
104                }
105                render assays as JSON
106        }
107
108
109        /**
110        * REST resource for the Simple Assay Module.
111        * Provide all samples of a given Assay. The result is an enriched list with additional informatin on a sample.
112        *
113        * @param  assayID (externalAssayID of some Assay in GSCF)
114        * @return list of element of  Sample.name x Sample.material x Sample.subject.name x Sample.Event.name x Sample.Event.time
115        */
116        def getSamples = {
117                def items = []
118                if( params.externalAssayID ) {
119                        def id = Long.parseLong(params.externalAssayID)
120                        def assay = Assay.find( "from Assay as a where externalAssayID=?",[id])
121                        assay.getSamples().each { sample ->
122                                def item = [
123                                        'name'                : sample.name,
124                                        'material'            : sample.material.name,
125                                        'subject'             : sample.parentSubject.name,
126                                        'event'               : sample.parentEvent.template.name,
127                                        'startTime'           : sample.parentEvent.getStartTimeString(),
128                                        'externalSampleId': sample.externalSampleId
129                                ]
130                                items.push item
131                        }
132                }
133                render items as JSON
134        }
135
136
137
138
139
140       /****************************/
141      /** Rest resources for DSP **/
142     /****************************/
143   
144       
145        /* still not complete!! */
146
147        /**
148        * REST resource for DSP.
149        * call: gscf/rest/isUser/?username=username&password=password
150        *
151        * @param  String username   
152        * @param  String password
153        * @return bool
154        */
155        def isUser= {
156                def isUser = isVerifiedUser( params )
157                render isUser as JSON
158        }
159
160
161        /* still not complete!! */
162        /**
163        * REST resource for DSP.
164        * call: gscf/rest/listStudies/?username=username&password=password
165        *
166        * @param  String username
167        * @param  String password
168        * @return list of studies
169        */
170        def listStudies = {
171
172                if( !isVerifiedUser( params ) ) {
173                        render [:] as JSON
174                        return
175                }
176
177                List studies = []
178
179                // add code for filtering studies that belong to given user
180                // (use Study.findAll( ... ) 
181                // ...
182                Study.list().each {
183                        def map = ["study_token":it.code, "name":it.name]
184                        studies.add( map )
185                }
186               
187                render studies as JSON
188        }
189
190
191
192        /* still not complete!! */
193        /**
194        * REST resource for DSP.
195        * call: gscf/rest/getStudy/?username=username&password=password&study_token=studytoken
196        *
197        * @param  String username
198        * @param  String password
199        * @param  String study_token
200        * @return list of studies
201        */
202        def getStudy = {
203
204                if( !isVerifiedUser( params ) ) {
205                        render [:] as JSON
206                        return
207                }
208
209                List studyResult = [:]
210                def code   = params.study_token
211
212                def query = "from Study as s where s.code = ?"
213                def study = Study.find( query, code )
214                studyResult = [ 'study_token' : study.code, 'name' : study.name ]
215                        /*  still not complete!!
216                                Add features
217                                        ... study_token:”GHyJeR#g”,
218                                        ... created: “20/06/2010 22:34:52”,
219                                        ... meta: [
220                                        ... greenhouse_id: “GH010938.AB.5”,
221                                        ... greenhouse_type: “lean-to, detached, and ridge and gutter connected” ]
222                        */
223               
224                render studyResult as JSON
225        }
226
227
228
229
230        /* still not complete!! */
231        /**
232        * REST resource for DSP.
233        * call: gscf/rest/listStudySamples/?username=username&password=password&study_token=studytoken
234        *
235        * @param  String user name
236        * @param  String password
237        * @param  String a valid GSCF Study.code
238        * @return List of pairs; each pair is a map with keys sample_token and name and values Study.code and Sample.name.
239        */
240        def listStudySamples = {
241
242                if( !isVerifiedUser( params ) ) {
243                        render [:] as JSON
244                        return
245                }
246
247                List samples = [:]
248                def code = params.study_token
249                def query = "from Samples as s where s.study = ?"
250                def study = Study.find( query, code )
251                if(study) study.samples.each { sample ->
252                        def map = [ sample_token:code, name:sample.name ]
253                        samples.add( map )
254                }
255               
256                render samples as JSON
257        }
258
259
260
261        /* still not complete!! */
262        /**
263        * REST resource for DSP.
264        * call: getStudySample/?username=me&password=123&study_token=GHyJeR#g&sample_name=”AHVJwR”)
265        *
266        * @param  String username
267        * @param  String password
268        * @param  String study_token
269        * @param  String sample_name
270        * @return list of studies
271        */
272        def getStudySample = {
273
274                if( !isVerifiedUser( params ) ) {
275                        render [:] as JSON
276                        return
277                }
278
279                List sample = [:]
280                def code = params.study_token
281                def name = params.sample_name
282
283                def query = "from Sample as s where s.name = ? AND s.parentStudy "
284                def study = Sample.find( query, name )
285                sample = [ 'study_token' : sample.code, 'name' : sample.name ]
286                // samples will have unique identifier strings
287                /*  still not complete!!
288                                Add features
289                                [
290                                        study_token:”GHyJeR#g”,
291                                        sample_token:”AHVJwR”,
292                                        name: “Sample SMPL002”,
293                                        created: “25/06/2010 09:14:32”,
294                                        meta: [ subject: “SUB000294-34942.A”, subject_bmi: “29.3”, ... study_token:”GHyJeR#g”,
295                                        ... created: “20/06/2010 22:34:52”, greenhouse_id: “GH010938.AB.5”,
296                                        greenhouse_type: “lean-to, detached, and ridge and gutter connected”
297                                ]
298                        */
299                render sample as JSON
300        }
301
302
303
304
305        /* still not complete!! */
306        /** Convenience method for isUser and listStudies.
307        *   Verify user and password.
308        *   @param  params object with two map keys: (1) 'username', (2) 'password'
309        *   @param  String password
310        *   @return bool
311        */
312        private isVerifiedUser( params ) {
313                def isVerified = false
314                def user = params?.username
315                def pass = params?.password
316
317                if( user && pass ) {
318                        // insert code for verification of user and
319                        // ...
320                        isVerified = true
321                }
322                return isVerified
323        }
324
325
326
327    /* this is just for testing! */
328    def test = {
329                render( dbnp.rest.common.CommunicationManager.getQueryResultWithOperator("Insulin",">",200) )
330    }
331}
Note: See TracBrowser for help on using the browser.