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

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

Views for EventDescription? (edit and create) have been cleaned, tested, debugged, and improved.

  • Property svn:keywords set to Author Rev Date
File size: 11.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
24
25
26    def collectParametersFromForm( params ) {
27
28            def parameters = [:]
29            def options    = [:]
30
31            params.each { key, value ->
32                 if(key=~/row_(.*)__(.*)/) {
33                      def matcher = (key=~/row_(.*?)__(.*?)$/)
34                      def id = matcher[0][1]
35                      def member = matcher[0][2]
36
37                      if(member=~/parameterStringValue__(.*?)$/) {
38                          matcher = member=~/parameterStringValue__(.*?)$/
39                          def psv = matcher[0][1]
40                          if(options[id]==null) { options[id]=[:] }  // store paramter string value's id and value
41                          (options[id])[psv]=value
42                      }
43                      else if(member!='reference')  {
44                          if(parameters[id]==null) { parameters[id]=new ProtocolParameter() }
45
46                          if(member=~/^type.*/) {
47                               value= ProtocolParameterType.valueOf(value)
48                               member='type'
49                          }
50                          parameters[id].setProperty(member,value)
51                      }
52                 }
53           }
54
55
56            // collect options (i.e., ParameterStringListItem from parameters)
57
58           parameters.each{ key, value ->
59               if(value.type==ProtocolParameterType.STRINGLIST) {
60                    def parameter = parameters[key]
61               }
62           }
63
64
65           return [parameters,options]
66    }
67
68
69
70    // convenience method for save()
71    def saveParameterStringListItem(item) {
72
73        if (item.save(flush: true)) {
74            flash.message = "${message(code: 'default.created.message', args: [message(code: 'description.label', default: 'Item'), item.id])}"
75        }
76        else {
77            item.errors.each { println it }
78        }
79
80    }
81
82
83    // convenience method for save()
84    def saveParameter(item) {
85
86        if (item.save(flush: true)) {
87            flash.message = "${message(code: 'default.created.message', args: [message(code: 'description.label', default: 'Parameter'), item.id])}"
88        }
89        else {
90            item.errors.each { println it }
91        }
92
93    }
94
95
96
97
98
99
100    def save = {
101       
102
103        def description = null      // the variable to be updated
104
105
106
107        // create a new event from scratch
108
109        if( !(params['id']=~/^[\d]+$/) ) {
110            description = new EventDescription()
111        }
112        else { 
113            description = EventDescription.get(params['id'])
114        }
115
116            description.name=params['name']
117
118            // description.description=params['description']   // has to be a Term
119            // description.classification=params['classification']  // has to be a Term
120            description.isSamplingEvent= params['isSample']=='true'?true:false
121
122            def protocol = Protocol.get(params['protocol'])   // the protocol
123
124
125
126
127            // STEP 1 parse params and fill hashes
128            def para_opt = collectParametersFromForm(params)
129
130            def parameters = para_opt[0]      // parameters given by the user (in the view)
131                                              // key: id (as string), value: non-persistant ProtocolParameter object
132
133            def options = para_opt[1]         // store options, i.e. ParameterStringListItems given by the user.
134                                              // use ids of parameter as key, store hash of id and name.
135
136            def originalParameters
137
138
139
140
141           // STEP 2  -  remove deleted parameters (from persistent protocol description)
142           protocol.parameters.each{
143               def toRemove = []
144               if( parameters[it.id.toString()]==null ) { toRemove.push(it) }
145               toRemove.each{ protocol.removeFromParameters(it) }
146           }
147
148
149
150           // STEP 3  -  update altered parameters
151           protocol.parameters.each{ 
152
153               def inDb = ProtocolParameter.get(it.id)
154               def originalListEntries = inDb.listEntries.collect{it}
155               def itemsToBeRemoved = []
156
157               if(  parameters[inDb.id.toString()] != null )
158               {
159                   def found = parameters[inDb.id.toString()]
160
161                   // update options (i.e. ParameterStringListItem objects) of parameter inDb
162                   if(inDb.type==ProtocolParameterType.STRINGLIST ) {
163
164                           if(found.type==ProtocolParameterType.STRINGLIST ) {
165
166                                // add or modifiy options for existing parameters
167                                options[inDb.id.toString()].each{ id, name ->
168
169                                    def item = inDb.listEntries.find{ it.id.toString()==id }
170                                    if(item==null) {  // add as new option to persistant parameter
171                                        item = new ParameterStringListItem()
172                                        item.name = name
173                                        saveParameterStringListItem(item)
174                                        inDb.addToListEntries(item)
175                                        inDb.save(flush: true)     // needed??
176                                    }
177                                    else {       // update persistant paramter
178                                        item.name = name
179                                    }
180                                }
181
182                           }
183
184                           else {                                                       // remove all options because the parameter type has changed
185                               inDb.listEntries.each{ itemsToBeRemoved.push( it ) }
186                           }
187                   }
188
189
190                   ['name','type','description','unit' ].each {           // references are missing
191                       inDb.setProperty(it,found.getProperty(it))         // type has to be set after checking for
192                   }                                                      // STRINGLIST above.
193               }
194
195               // delete all options removed by the user
196               originalListEntries.each { original ->
197                       // if the original is not found in the user's modifications
198                       def allOptionsForParameters = options[inDb.id.toString()]
199                       if( allOptionsForParameters==null || allOptionsForParameters[original.id.toString()]==null )
200                           { itemsToBeRemoved.push( original ) }
201               }
202               itemsToBeRemoved.each { 
203                   inDb.removeFromListEntries(it)
204               }
205          }
206
207
208           // STEP 4  - add new parameters
209
210            // find new parameters, added by user
211            // remove all other parameters from paramters list
212            def newParameters = [:]
213            parameters.each{ key, value ->
214                if( ! protocol.parameters.find {it.id.toString()==key} ) {
215                    newParameters[key]=value
216                }
217            }
218            parameters=newParameters
219
220
221
222
223            //  add new parameters (to persistent protocolDescription)
224            parameters.each { id, parameter->
225                if( id=~/new/ )
226                {
227                    def newParameter = new ProtocolParameter()                           // update properties
228                    ['name','type','description','unit'].each {
229                        newParameter.setProperty( it, parameter.getProperty(it) )
230                    }
231
232                    if(parameter.type==ProtocolParameterType.STRINGLIST) {               // update options
233                         options[id].each { someKey, name ->
234                             def item = new ParameterStringListItem()
235                             item.name=name
236                             parameter.addToListEntries(item)
237                             saveParameterStringListItem(item)
238                         }
239                    }
240                    saveParameter(newParameter)
241                    protocol.addToParameters(parameter)
242                }
243            }
244
245
246        // make changes persitant
247
248        if (description.save(flush: true)) {
249            flash.message = "${message(code: 'default.created.message', args: [message(code: 'description.label', default: 'EventDescription'), description.id])}"
250            redirect(action: "show", id: description.id)
251        }
252        else {
253            render(view: "create", model: [description: description])
254        }
255
256        render( action: 'list' )
257    }
258
259
260
261    def show = {
262
263        def eventDescriptionInstance = EventDescription.get(params.id)
264        if (!eventDescriptionInstance) {
265            flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'eventDescription.label', default: 'EventDescription'), params.id])}"
266            redirect(action: "list")
267        }
268
269        else {
270            [eventDescriptionInstance: eventDescriptionInstance, params:params]
271        }
272    }
273
274
275    def edit = {
276        def eventDescriptionInstance = EventDescription.get(params.id)
277        if (!eventDescriptionInstance) {
278            flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'eventDescription.label', default: 'EventDescription'), params.id])}"
279            redirect(action: "list")
280        }
281        else {
282            return [eventDescriptionInstance: eventDescriptionInstance]
283        }
284    }
285
286
287
288    def showMyProtocol = {
289
290        if( EventDescription.get(params.id)==null || EventDescription.get(params.id).protocol==null ) {
291            def description=new EventDescription();
292            render( view:"showMyProtocolFilled", model:[protocol:null,description:description] )
293        }
294        else {
295            def description = EventDescription.get(params.id)
296            render( view: "showMyProtocolFilled", model:[protocol:description.protocol,description:description] )
297        }
298    }
299
300
301
302    def showPartial = {
303        def description = EventDescription.get(params['protocolid'])
304        def event       = Event.get(params['id'])
305        render( view: "showPartial", model:[description:description,event:event] )    // error handling missing
306    }
307
308
309
310
311    def showMyProtocolEmpty = {
312    }
313
314
315    def showMyProtocolFilled = {
316    }
317
318
319
320
321
322
323    def update = {
324        def eventDescriptionInstance = EventDescription.get(params.id)
325        if (eventDescriptionInstance) {
326            try {
327                eventDescriptionInstance.delete(flush: true)
328                flash.message = "${message(code: 'default.deleted.message', args: [message(code: 'eventDescription.label', default: 'EventDescription'), params.id])}"
329                redirect(action: "list")
330            }
331            catch (org.springframework.dao.DataIntegrityViolationException e) {
332                flash.message = "${message(code: 'default.not.deleted.message', args: [message(code: 'eventDescription.label', default: 'EventDescription'), params.id])}"
333                redirect(action: "show", id: params.id)
334            }
335        }
336        else {
337            flash.message = "${message(code: 'default.not.found.message', args: [message(code: 'eventDescription.label', default: 'EventDescription'), params.id])}"
338            redirect(action: "list")
339        }
340    }
341
342
343
344    def addProtocolParameter = {
345        render( action:"showProtocolParameters", model:['addNew':true] )
346    }
347
348
349    def showProtocolParameters = {
350        def description = EventDescription.get(params.id)
351        def protocol = null
352        def list = []
353
354        if(description!=null) {                           // editing an existing EventDescription
355            protocol = description.protocol==null ? new Protocol() : description.protocol
356                protocol.parameters.each {
357                    list.add(it)
358                    list.sort{ a,b -> a.name <=> b.name }
359                }
360        }
361
362        render( view:"showProtocolParameters", model:[protocol:null,description:description,list:list] )
363    }
364
365}
Note: See TracBrowser for help on using the repository browser.