root/trunk/grails-app/controllers/dbnp/studycapturing/StudyController.groovy @ 1203

Revision 1203, 9.5 KB (checked in by robert@…, 3 years ago)

Updated the events timeline in the study view, according to ticket #72

  • Property svn:keywords set to Author Date Rev
Line 
1package dbnp.studycapturing
2
3import grails.converters.*
4import grails.plugins.springsecurity.Secured
5
6
7/**
8 * Controller class for studies
9 */
10class StudyController {
11    def AuthenticationService
12   
13    //static allowedMethods = [save: "POST", update: "POST", delete: "POST"]
14
15    def index = {
16        redirect(action: "list", params: params)
17    }
18
19    /**
20     * Shows all studies where the user has access to
21     */
22    def list = {
23
24        def user = AuthenticationService.getLoggedInUser()
25        def max = Math.min(params.max ? params.int('max') : 10, 100)
26
27        def c = Study.createCriteria()
28
29        def studies
30        if( user == null ) {
31            studies = c.list {
32                maxResults(max)
33                and {
34                    eq( "published", true )
35                    eq( "publicstudy", true )
36                }
37            }
38        } else {
39            studies = c.list {
40                maxResults(max)
41                or {
42                    eq( "owner", user )
43                    writers {
44                        eq( "id", user.id )
45                    }
46                    and {
47                        readers {
48                            eq( "id", user.id )
49                        }
50                        eq( "published", true )
51                    }
52                }
53            }
54        }
55       
56        [studyInstanceList: studies, studyInstanceTotal: studies.count(), loggedInUser: user]
57    }
58
59    /**
60     * Shows studies for which the logged in user is the owner
61     */
62    @Secured(['IS_AUTHENTICATED_REMEMBERED'])
63    def myStudies = {
64        def user = AuthenticationService.getLoggedInUser()
65        def max = Math.min(params.max ? params.int('max') : 10, 100)
66
67        def studies = Study.findAllByOwner(user);
68        render( view: "list", model: [studyInstanceList: studies, studyInstanceTotal: studies.count(), loggedInUser: user] )
69    }
70
71    /**
72     * Shows a comparison of multiple studies using the show view
73     *
74     */
75    def list_extended = {
76                // If nothing has been selected, redirect the user
77                if( !params.id )
78                        redirect( action: 'list' )
79
80                // Check whether one id has been selected or multiple.
81                def ids = params.id
82                if( ids instanceof String )
83                        redirect( action: 'show', id: ids )
84
85                // Parse strings to a long
86                def long_ids = []
87                ids.each { long_ids.add( Long.parseLong( it ) ) }
88
89                println( long_ids )
90
91        def startTime = System.currentTimeMillis()
92                def c = Study.createCriteria()
93
94        def studyList = c {
95                        maxResults( Math.min(params.max ? params.int('max') : 10, 100) )
96                        'in'( "id", long_ids )
97                }
98        render(view:'show',model:[studyList: studyList, studyInstanceTotal: Study.count(), multipleStudies: ( studyList.size() > 1 ) ] )
99    }
100
101    /**
102     * Shows one or more studies
103     */
104    def show = {
105        def startTime = System.currentTimeMillis()
106
107        def studyInstance = Study.get( params.long( "id" ) )
108        if (!studyInstance) {
109            flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'study.label', default: 'Study'), params.id])}"
110            redirect(action: "list")
111        }
112        else {
113            // Check whether the user may see this study
114            def loggedInUser = AuthenticationService.getLoggedInUser()
115            if( !studyInstance.canRead(loggedInUser) ) {
116                flash.message = "You have no access to this study"
117                redirect(action: "list")
118            }
119
120            // The study instance is packed into an array, to be able to
121            // use the same view for showing the study and comparing multiple
122            // studies
123            [studyList: [ studyInstance ], multipleStudies: false, loggedInUser: loggedInUser ]
124        }
125    }
126
127    def showByToken = {
128        def studyInstance = Study.findByCode(params.id)
129        if (!studyInstance) {
130            flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'study.label', default: 'Study'), params.id])}"
131            redirect(action: "list")
132        }
133        else {
134            // Check whether the user may see this study
135            def loggedInUser = AuthenticationService.getLoggedInUser()
136            if( !studyInstance.canRead(loggedInUser) ) {
137                flash.message = "You have no access to this study"
138                redirect(action: "list")
139            }
140
141            redirect(action: "show", id: studyInstance.id)
142        }
143    }
144
145    /**
146     * Gives the events for one eventgroup in JSON format
147     *
148     */
149    def events = {
150        def eventGroupId = Integer.parseInt( params.id );
151        def studyId      = Integer.parseInt( params.study );
152        def eventGroup;
153
154        // eventGroupId == -1 means that the orphaned events should be given
155        if( eventGroupId == -1 ) {
156            def studyInstance = Study.get( studyId )
157           
158            if (studyInstance == null) {
159                flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'study.label', default: 'Study'), studyId])}"
160                redirect(action: "list");
161                return;
162            }
163
164            events = studyInstance.getOrphanEvents();
165        } else {
166            eventGroup = EventGroup.get(params.id)
167
168            if (eventGroup == null) {
169                flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'eventgroup.label', default: 'Eventgroup'), params.id])}"
170                redirect(action: "list");
171                return;
172            }
173            events = eventGroup?.events + eventGroup?.samplingEvents;
174        }
175
176        // This parameter should give the startdate of the study in milliseconds
177        // since 1-1-1970
178        long startDate  = Long.parseLong( params.startDate )
179
180        // Create JSON object
181        def json = [ 'dateTimeFormat': 'iso8601', events: [] ];
182
183        // Add all other events
184        for( event in events ) {
185            def parameters = []
186            for( templateField in event.giveTemplateFields() ) {
187                def value = event.getFieldValue( templateField.name );
188                                if( value ) {
189                                        if( templateField.type == TemplateFieldType.RELTIME )
190                                                value = new RelTime( value ).toString();
191
192                        def param = templateField.name + " = " + value;
193
194                                        if( templateField.unit )
195                                                param += templateField.unit;
196
197                    parameters << param ;
198                }
199            }
200
201                        def description = parameters.join( '<br />\n' );
202
203                        if( event instanceof SamplingEvent ) {
204                                 json.events << [
205                                        'start':    new Date( startDate + event.startTime * 1000 ),
206                                        'end':      new Date( startDate + event.startTime * 1000 ),
207                                        'durationEvent': false,
208                                        'title': event.template.name,
209                                        'description': description
210                                ]
211                        } else {
212                                 json.events << [
213                                        'start':    new Date( startDate + event.startTime * 1000 ),
214                                        'end':      new Date( startDate + event.endTime * 1000 ),
215                                        'durationEvent': true,
216                                        'title': event.template.name,
217                                        'description': description
218                                ]
219                               
220                        }
221        }
222        render json as JSON
223    }
224
225    def delete = {
226        def studyInstance = Study.get(params.id)
227        if (studyInstance) {
228            try {
229                studyInstance.delete(flush: true)
230                flash.message = "${message(code: 'default.deleted.message', args: [message(code: 'study.label', default: 'Study'), params.id])}"
231                redirect(action: "list")
232            }
233            catch (org.springframework.dao.DataIntegrityViolationException e) {
234                flash.message = "${message(code: 'default.not.deleted.message', args: [message(code: 'study.label', default: 'Study'), params.id])}"
235                redirect(action: "show", id: params.id)
236            }
237        }
238        else {
239            flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'study.label', default: 'Study'), params.id])}"
240            redirect(action: "list")
241        }
242    }
243
244    /*def edit = {
245        def studyInstance = Study.get(params.id)
246        if (!studyInstance) {
247            flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'study.label', default: 'Study'), params.id])}"
248            redirect(action: "list")
249        }
250        else {
251            return [studyInstance: studyInstance]
252        }
253    }
254
255    def update = {
256        def studyInstance = Study.get(params.id)
257        if (studyInstance) {
258            if (params.version) {
259                def version = params.version.toLong()
260                if (studyInstance.version > version) {
261                   
262                    studyInstance.errors.rejectValue("version", "default.optimistic.locking.failure", [message(code: 'study.label', default: 'Study')] as Object[], "Another user has updated this Study while you were editing")
263                    render(view: "edit", model: [studyInstance: studyInstance])
264                    return
265                }
266            }
267            studyInstance.properties = params
268            if (!studyInstance.hasErrors() && studyInstance.save(flush: true)) {
269                flash.message = "${message(code: 'default.updated.message', args: [message(code: 'study.label', default: 'Study'), studyInstance.id])}"
270                redirect(action: "show", id: studyInstance.id)
271            }
272            else {
273                render(view: "edit", model: [studyInstance: studyInstance])
274            }
275        }
276        else {
277            flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'study.label', default: 'Study'), params.id])}"
278            redirect(action: "list")
279        }
280    }
281*/
282}
Note: See TracBrowser for help on using the browser.