source: trunk/grails-app/controllers/dbnp/studycapturing/EventDescriptionController.groovy @ 288

Last change on this file since 288 was 288, checked in by jahn, 9 years ago

Event's create and edit action have been tested and are now working.

Also, the old problem of adding Samples has been addressed. When a new event is created as a SamplingEvent?, no new samples can be added directly. The reason for this is, that the event is not yet assigned to any Subject, and thus the non nullable subject field of a new sample (belonging to the new event) cannot be filled.
Similarly, when a SamplingEvent? event is edited, new samples can only be added, if the event already is assigned to belong to a subject. New samples are always added to the same subject as the first (random) sample belonging to the SamplingEvent?.

However, there are still open questions:

(1) Should the sample also be assigned to the samples of its subject's Study?

(2) Should a sample also be assigned, if there are no samples assigned yet, but there is a subject assigned to this event?

(3) Should the user be allowed to chose to assign a subject if the event is assigned to a Study that contains multiple subjects?

  • Property svn:keywords set to Author Rev Date
File size: 13.5 KB
Line 
1package dbnp.studycapturing
2import dbnp.data.Term
3
4class EventDescriptionController {
5
6    static allowedMethods = [save: "POST", update: "POST", delete: "POST"]
7
8    def index = {
9        redirect(action: "list", params: params)
10    }
11
12    def list = {
13        params.max = Math.min(params.max ? params.int('max') : 10, 100)
14        [eventDescriptionInstanceList: EventDescription.list(params), eventDescriptionInstanceTotal: EventDescription.count()]
15    }
16
17    def create = {
18        def eventDescriptionInstance = new EventDescription()
19            render(view:'edit', model:[eventDescriptionInstance: eventDescriptionInstance] )
20    }
21
22
23    def save = {
24        println "save"
25        println params
26        params.each { println it }
27
28
29
30        def description = null      // the variable to be updated
31
32
33        /*  update an existing description */
34
35        if(params['id']!='')  {             
36
37
38            // STEP 0  - set variables
39
40            description = new EventDescription()
41            description.name=params['name']
42            // description.description=params['description']   // has to be a Term
43            // description.classification=params['classification']  // has to be a Term
44            description.isSamplingEvent= params['isSample']=='true'?true:false
45
46            def protocol = Protocol.get(params['protocol'])   // the protocol
47
48            def parameters = [:]                   // parameters given by the user (in the view)
49                                                   // key: id (as string), value: non-persistant ProtocolParameter object
50
51            def options = [:]                      // store options, i.e. ParameterStringListItems given by the user
52                                                   // use ids of parameter as key, store hash of id and name
53
54
55
56
57            // STEP 1 parse params and fill hashes
58
59
60            // collect parameters from form
61            params.each { key, value ->
62                 if(key=~/row_(.*)__(.*)/) {
63                      def matcher = (key=~/row_(.*?)__(.*?)$/)
64                      println matcher[0][1]+'  '+matcher[0][2]
65                      def id = matcher[0][1]
66                      def member = matcher[0][2]
67
68                      println 'member: '+ member
69                      if(member=~/parameterStringValue__(.*?)$/) {
70                          matcher = member=~/parameterStringValue__(.*?)$/
71                          def psv = matcher[0][1]
72                          println "${id}\t${psv}:\tvalue:${value}"
73                          if(options[id]==null) { options[id]=[:] }  // store paramter string value's id and value
74                          (options[id])[psv]=value
75                      }
76                      else if(member!='reference')  { 
77                          if(parameters[id]==null) { parameters[id]=new ProtocolParameter() }
78
79                          if(member=~/^type.*/) {
80                               value= ProtocolParameterType.valueOf(value)
81                               member='type'
82                          }
83                          parameters[id].setProperty(member,value)
84                      }
85                 }
86            }
87
88println "here 1"
89
90            // collect options (i.e., ParameterStringListItem from parameters)
91            parameters.each{ key, value ->
92                if(value.type==ProtocolParameterType.STRINGLIST) {
93                    def parameter = parameters[key]
94                    options[key].each{k,v-> println "k: ${k}\t v:${v}" } // debug
95                }
96            }
97
98println "here 2"
99
100
101
102
103           // STEP 2  -  remove deleted parameters (from persistent protocol description)
104
105           protocol.parameters.each{ 
106               if( parameters[it.id.toString()]==null  )
107                   { protocol.removeFromParameters(it.id) }
108           }
109
110println "here 3"
111
112
113           // STEP 3  -  update altered parameters
114
115           protocol.parameters.each{ inDb ->
116
117               def found = parameters[inDb.id.toString()]
118               //['name','type','description','reference','unit'].each {
119               // debugging: ignoring the reference !!
120               ['name','type','description','unit'].each {
121                   inDb.setProperty(it,found.getProperty(it))
122               }
123
124
125               // update options (i.e. ParameterStringListItem objects) of parameter inDb
126               if(inDb.type==ProtocolParameterType.STRINGLIST ) {
127
128                       if(found.type==ProtocolParameterType.STRINGLIST ) {
129
130                            // add or modifiy options for existing parameters
131                            options[inDb.id.toString()].each{ id, name ->
132                                def item = inDb.listEntries.find{ it.id.toString()==id }
133                                if(!item) {  // add as new option to persistant parameter
134                                    item = new ParameterStringListItem()
135                                    item.name = name
136                                    inDb.addToListEntries(item)
137                                }
138                                else {       // update persistant paramter
139                                    item.name = name
140                                }
141                            }
142
143                            // remove options that have been deleted by the user
144                            def itemsToBeRemoved = []
145                            inDb.listEntries.each { item ->
146                                 if( ! ((options[inDb.id.toString()])[item.id.toString()]) )
147                                     { itemsToBeRemoved.push item }
148                            }
149                            itemsToBeRemoved.each { inDb.removeFromListEntries(it) }
150                       }
151
152               }
153               else { 
154                        inDb.listEntries.collect{it}.each{ inDb.removeFromListEntries(it) }
155               }
156
157          }
158
159
160
161println "here 4"
162
163           // STEP 4  - add new parameters
164
165            // find new parameters, added by user
166            // remove all other parameters from paramters list
167            def newParameters = [:]
168            parameters.each{ key, value ->
169                if( ! protocol.parameters.find {it.id.toString()==key} ) {
170                    newParameters[key]=value
171                }
172            }
173            parameters=newParameters
174
175
176
177println "here 5"
178            //  add new parameters (to persistent protocolDescription)
179            parameters.each { id, parameter->
180                def newParameter = new ProtocolParameter()                           // update properties
181                ['name','type','description','unit'].each {
182                    newParameter.setProperty( it, parameter.getProperty(it) )
183                }
184
185                if(parameter.type==ProtocolParameterType.STRINGLIST) {               // update options
186                     options[id].each { someKey, name ->
187                         if(item==null) item = new ParameterStringListItem()
188                         item.name=name
189                         parameter.addToListEntries(item)
190
191                         if (item.save(flush: true)) {
192                             flash.message = "${message(code: 'default.created.message', args: [message(code: 'item.label', default: 'EventDescription'), item.id])}"
193                             redirect(action: "show", id: item.id)
194                         }
195                         else {
196                             render(view: "create", model: [item:item])
197                         }
198
199
200
201                     }
202                }
203                description.addToListEntries(parameter)
204            }
205
206
207
208println "here 6"
209
210           // STEP 5  - make changes persitant
211
212
213            // compare paramters for protocol
214            def parametersFromUser = []
215
216            // check whether all parameters are still part of the protocol
217            protocol.parameters
218
219        }
220
221        if (description.save(flush: true)) {
222            flash.message = "${message(code: 'default.created.message', args: [message(code: 'description.label', default: 'EventDescription'), description.id])}"
223            redirect(action: "show", id: description.id)
224        }
225        else {
226            render(view: "create", model: [description: description])
227        }
228
229        render( action: 'list' )
230    }
231
232
233
234    def show = {
235
236        def eventDescriptionInstance = EventDescription.get(params.id)
237        if (!eventDescriptionInstance) {
238            flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'eventDescription.label', default: 'EventDescription'), params.id])}"
239            redirect(action: "list")
240        }
241
242        else {
243            [eventDescriptionInstance: eventDescriptionInstance, params:params]
244        }
245    }
246
247
248    def edit = {
249        def eventDescriptionInstance = EventDescription.get(params.id)
250        if (!eventDescriptionInstance) {
251            flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'eventDescription.label', default: 'EventDescription'), params.id])}"
252            redirect(action: "list")
253        }
254        else {
255            return [eventDescriptionInstance: eventDescriptionInstance]
256        }
257    }
258
259
260
261    def showMyProtocol = {
262        println "in showMyProtocol"
263        println params
264
265        if( EventDescription.get(params.id)==null || EventDescription.get(params.id).protocol==null ) {
266            def protocol = Protocol.find("from Protocol p where id>=0")
267            println "protocol: ${protocol}"
268            //def description = EventDescription.find("from EventDescription e where id>=0")
269            //println "description: ${description}"
270            def description=new EventDescription();
271            render( view:"showMyProtocolFilled", model:[protocol:protocol,description:description] )
272        }
273        else {
274            def description = EventDescription.get(params.id)
275            render( view: "showMyProtocolFilled", model:[protocol:description.protocol,description:description] )
276        }
277    }
278
279
280
281    def showPartial = {
282        def description = EventDescription.get(params['protocolid'])
283        def event       = Event.get(params['id'])
284        render( view: "showPartial", model:[description:description,event:event] )    // error handling missing
285    }
286
287
288    def showMyProtocolEmpty = {
289       println "in showMyProtocolEmpty"
290    }
291
292
293    def showMyProtocolFilled = {
294       println "in showMyProtocolFilled"
295    }
296
297
298
299
300
301
302    def update = {
303        println "update"
304        print params
305
306        def eventDescriptionInstance = EventDescription.get(params.id)
307        if (eventDescriptionInstance) {
308            if (params.version) {
309                def version = params.version.toLong()
310                if (eventDescriptionInstance.version > version) {
311                   
312                    eventDescriptionInstance.errors.rejectValue("version", "default.optimistic.locking.failure", [message(code: 'eventDescription.label', default: 'EventDescription')] as Object[], "Another user has updated this EventDescription while you were editing")
313                    render(view: "edit", model: [eventDescriptionInstance: eventDescriptionInstance])
314                    return
315                }
316            }
317            eventDescriptionInstance.properties = params
318            if (!eventDescriptionInstance.hasErrors() && eventDescriptionInstance.save(flush: true)) {
319                flash.message = "${message(code: 'default.updated.message', args: [message(code: 'eventDescription.label', default: 'EventDescription'), eventDescriptionInstance.id])}"
320                redirect(action: "show", id: eventDescriptionInstance.id)
321            }
322            else {
323                render(view: "edit", model: [eventDescriptionInstance: eventDescriptionInstance])
324            }
325        }
326        else {
327            flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'eventDescription.label', default: 'EventDescription'), params.id])}"
328            redirect(action: "list")
329        }
330    }
331
332    def delete = {
333            flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'eventDescription.label', default: 'EventDescription'), params.id])}"
334            redirect(action: "list")
335
336/*
337        // old shit
338        def eventDescriptionInstance = EventDescription.get(params.id)
339        if (eventDescriptionInstance) {
340            try {
341                eventDescriptionInstance.delete(flush: true)
342                flash.message = "${message(code: 'default.deleted.message', args: [message(code: 'eventDescription.label', default: 'EventDescription'), params.id])}"
343                redirect(action: "list")
344            }
345            catch (org.springframework.dao.DataIntegrityViolationException e) {
346                flash.message = "${message(code: 'default.not.deleted.message', args: [message(code: 'eventDescription.label', default: 'EventDescription'), params.id])}"
347                redirect(action: "show", id: params.id)
348            }
349        }
350        else {
351            flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'eventDescription.label', default: 'EventDescription'), params.id])}"
352            redirect(action: "list")
353        }
354        */
355    }
356
357
358    def test = { render(params) }
359
360    def test2 = {
361        def eventDescriptionInstance = EventDescription.get(params.id)
362        if (!eventDescriptionInstance) {
363            flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'eventDescription.label', default: 'EventDescription'), params.id])}"
364            redirect(action: "list")
365        }
366        else {
367            return [eventDescriptionInstance: eventDescriptionInstance]
368        }
369    }
370
371
372    def addProtocolParameter = {
373        render( action:"showProtocolParameters", model:['addNew':true] )
374    }
375
376
377    def showProtocolParameters = {
378        def description = EventDescription.get(params.id)
379        def protocol = []
380        def list = []
381
382        if(description!=null) {                           // editing an existing EventDescription
383            protocol = description.protocol==null ? new Protocol() : description.protocol
384        }
385        else {                                            // creating a new EventDescription
386           protocol=Protocol.find("from Protocol p where id>=0")
387        }
388
389        protocol.parameters.each {
390            list.add(it)
391            list.sort{ a,b -> a.name <=> b.name }
392        }
393
394        render( view:"showProtocolParameters", model:[protocol:protocol,description:description,list:list] )
395    }
396
397}
Note: See TracBrowser for help on using the repository browser.