Ignore:
Timestamp:
Feb 22, 2010, 6:35:37 PM (12 years ago)
Author:
duh
Message:
  • added events, eventDescriptions, etc
File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/grails-app/controllers/dbnp/studycapturing/WizardController.groovy

    r204 r209  
    4747                        flow.page = 0
    4848                        flow.pages = [
    49                                 [title: 'Templates'],   // templates
    50                                 [title: 'Study'],               // study
    51                                 [title: 'Subjects'],    // subjects
    52                                 [title: 'Groups'],              // groups
    53                                 [title: 'Events'],              // events
    54                                 [title: 'Samples'],             // samples
    55                                 [title: 'Protocols'],   // protocols
    56                                 [title: 'Assays'],              // assays
    57                                 [title: 'Done']                 // finish page
     49                                [title: 'Templates'],                   // templates
     50                                [title: 'Study'],                               // study
     51                                [title: 'Subjects'],                    // subjects
     52                                [title: 'Event Descriptions'],  // event descriptions
     53                                [title: 'Events'],                              // groups
     54                                [title: '---'],                         // events
     55                                [title: '---'],                         // samples
     56                                [title: '---'],                 // protocols
     57                                [title: '---'],                         // assays
     58                                [title: 'Done']                                 // finish page
    5859                        ]
    5960
     
    170171                                        success()
    171172                                }
    172                         }.to "groups"
     173                        }.to "eventDescriptions"
    173174                        on("previous") {
    174175                                flash.errors = new LinkedHashMap()
     
    181182                                }
    182183                        }.to "study"
     184                }
     185
     186                // render page three
     187                eventDescriptions {
     188                        render(view: "_eventDescriptions")
     189                        onRender {
     190                                flow.page = 4
     191
     192                                if (!flow.eventDescriptions) {
     193                                        flow.eventDescriptions = []
     194                                }
     195                        }
     196                        on("add") {
     197                                // fetch classification by name (as posted by the form)
     198                                params.classification = Term.findByName(params.classification)
     199
     200                                // transform checkbox form value to boolean
     201                                params.isSamplingEvent = (params.containsKey('isSamplingEvent'))
     202
     203                                // instantiate EventDescription with parameters
     204                                def eventDescription = new EventDescription(params)
     205
     206                                // validate
     207                                if (eventDescription.validate()) {
     208                                        def increment = flow.eventDescriptions.size()
     209                                        flow.eventDescriptions[increment] = eventDescription
     210                                        success()
     211                                } else {
     212                                        // validation failed, feedback errors
     213                                        flash.errors = new LinkedHashMap()
     214                                        this.appendErrors(eventDescription, flash.errors)
     215                                        error()
     216                                }
     217                        }.to "eventDescriptions"
     218                        on("previous") {
     219                                flash.errors = new LinkedHashMap()
     220
     221                                // handle form data
     222                                if (!this.handleEventDescriptions(flow, flash, params)) {
     223                                        error()
     224                                } else {
     225                                        success()
     226                                }
     227                        }.to "subjects"
     228                        on("next") {
     229                                flash.errors = new LinkedHashMap()
     230
     231                                // check if we have at least one subject
     232                                // and check form data
     233                                if (flow.eventDescriptions.size() < 1) {
     234                                        // append error map
     235                                        this.appendErrorMap(['eventDescriptions': 'You need at least to create one eventDescription for your study'], flash.errors)
     236                                        error()
     237                                } else if (!this.handleEventDescriptions(flow, flash, params)) {
     238                                        error()
     239                                } else {
     240                                        success()
     241                                }
     242                        }.to "events"
     243                }
     244
     245                // render events page
     246                events {
     247                        render(view: "_events")
     248                        onRender {
     249                                flow.page = 5
     250
     251                                if (!flow.events) {
     252                                        flow.events = []
     253                                }
     254
     255                                if (!flow.eventGroups) {
     256                                        flow.eventGroups = []
     257                                }
     258                        }
     259                        on("add") {
     260                                // create date instances from date string?
     261                                // @see WizardTagLibrary::timeElement{...}
     262                                if (params.get('startTime')) {
     263                                        println params.get('startTime').toString()
     264                                        params.startTime = new Date().parse("d/M/yyyy HH:mm", params.get('startTime').toString())
     265                                }
     266                                if (params.get('endTime')) {
     267                                        params.get('endTime').toString()
     268                                        params.endTime = new Date().parse("d/M/yyyy HH:mm", params.get('endTime').toString())
     269                                }
     270
     271                                // get eventDescription instance by name
     272                                params.eventDescription = this.getObjectByName(params.get('eventDescription'),flow.eventDescriptions)
     273
     274                                // instantiate Event with parameters
     275                                def event = new Event(params)
     276
     277                                // validate event
     278                                if (event.validate()) {
     279                                        def increment = flow.events.size()
     280                                        flow.events[increment] = event
     281                                        success()
     282                                } else {
     283                                        // validation failed, feedback errors
     284                                        flash.errors = new LinkedHashMap()
     285                                        this.appendErrors(event, flash.errors)
     286
     287                                        flash.startTime                 = params.startTime
     288                                        flash.endTime                   = params.endTime
     289                                        flash.eventDescription  = params.eventDescription
     290                                       
     291                                        error()
     292                                }
     293                        }.to "events"
     294                        on("addEventGroup") {
     295                                def increment = flow.eventGroups.size()
     296                                flow.eventGroups[ increment ] = new EventGroup(name: "group "+(increment+1))
     297                        }.to "events"
     298                        on("previous") {
     299                                // TODO
     300                        }.to "eventDescriptions"
     301                        on("next") {
     302                                // TODO
     303                        }.to "events"
    183304                }
    184305
     
    187308                        render(view: "_groups")
    188309                        onRender {
    189                                 flow.page = 4
     310                                flow.page = 6
    190311
    191312                                if (!flow.groups) {
     
    206327
    207328                // render page three
    208                 events {
    209                         render(view: "_events")
    210                         onRender {
    211                                 flow.page = 5
    212                         }
    213                         on("previous") {
    214                                 // TODO
    215                         }.to "subjects"
    216                         on("next") {
    217                                 // TODO
    218                         }.to "samples"
    219                 }
    220 
    221                 // render page three
    222329                samples {
    223330                        render(view: "_samples")
    224331                        onRender {
    225                                 flow.page = 6
     332                                flow.page = 7
    226333                        }
    227334                        on("previous") {
     
    237344                        render(view: "_protocols")
    238345                        onRender {
    239                                 flow.page = 7
     346                                flow.page = 8
    240347                        }
    241348                        on("previous") {
     
    251358                        render(view: "_assays")
    252359                        onRender {
    253                                 flow.page = 8
     360                                flow.page = 9
    254361                        }
    255362                        on("previous") {
     
    265372                        render(view: "_done")
    266373                        onRender {
    267                                 flow.page = 9
     374                                flow.page = 10
    268375                        }
    269376                        on("previous") {
     
    310417                        this.appendErrors(flow.study, flash.errors)
    311418                        return false
     419                }
     420        }
     421
     422        /**
     423         * re-usable code for handling eventDescription form data in a web flow
     424         * @param Map LocalAttributeMap (the flow scope)
     425         * @param Map localAttributeMap (the flash scope)
     426         * @param Map GrailsParameterMap (the flow parameters = form data)
     427         * @returns boolean
     428         */
     429        def handleEventDescriptions(flow, flash, params) {
     430                def names = new LinkedHashMap();
     431                def errors = false;
     432                def id = 0;
     433
     434                flow.eventDescriptions.each() {
     435                        it.name                 = params.get('eventDescription_' + id + '_name')
     436                        it.description          = params.get('eventDescription_' + id + '_description')
     437                        it.classification       = Term.findByName(params.get('eventDescription_' + id + '_classification'))
     438                        it.isSamplingEvent      = (params.containsKey('eventDescription_' + id + '_isSamplingEvent'))
     439
     440                        // validate eventDescription
     441                        if (!it.validate()) {
     442                                errors = true
     443                                println id + ' :: ' + it.errors.getAllErrors()
     444                                this.appendErrors(it, flash.errors)
     445                        }
     446
     447                        id++
    312448                }
    313449        }
     
    403539        }
    404540
     541
     542        /**
     543         * return the object from a map of objects by searching for a name
     544         * @param String        name
     545         * @param Map           map of objects
     546         * @return Object
     547         */
     548        def getObjectByName(name, map) {
     549                def result = null
     550                map.each() {
     551                        if (it.name == name) {
     552                                result = it
     553                        }
     554                }
     555
     556                return result
     557        }
     558
    405559        /**
    406560         * transform domain class validation errors into a human readable
Note: See TracChangeset for help on using the changeset viewer.