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

Revision 649, 7.7 KB (checked in by jahn, 4 years ago)

Added five controller actions (RestController?) and corresponding Rest Wrapper (CommunicationManager?) methods for Rest communication with DSP.
The contents of three actions still need to be completed.
Authentication is still in a dummy method. When Michael has figured out how to do the authentication, it will be added.

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