source: trunk/grails-app/controllers/dbnp/studycapturing/WizardController.groovy @ 157

Last change on this file since 157 was 157, checked in by duh, 13 years ago
  • temporary commit
  • Property svn:keywords set to Rev Author Date
File size: 4.1 KB
RevLine 
[86]1package dbnp.studycapturing
[101]2
[86]3import dbnp.studycapturing.*
[138]4import dbnp.data.*
[86]5import grails.converters.*
6
7/**
8 * Wizard Controler
9 *
10 * The wizard controller handles the handeling of pages and data flow
11 * through the study capturing wizard.
12 *
[101]13 * @author Jeroen Wesbeek
14 * @since 20100107
[86]15 * @package studycapturing
16 *
17 * Revision information:
18 * $Rev: 157 $
19 * $Author: duh $
20 * $Date: 2010-02-02 09:31:25 +0000 (di, 02 feb 2010) $
21 */
22class WizardController {
[101]23        /**
24         * index method, redirect to the webflow
25         * @void
26         */
27        def index = {
28                /**
29                 * Do you believe it in your head?
30                 * I can go with the flow
31                 * Don't say it doesn't matter (with the flow) matter anymore
32                 * I can go with the flow (I can go)
33                 * Do you believe it in your head?
34                 */
35                redirect(action: 'pages')
36        }
[86]37
[101]38        /**
39         * WebFlow definition
40         * @see http://grails.org/WebFlow
41         * @void
42         */
43        def pagesFlow = {
44                // start the flow
45                onStart {
46                        // define flow variables
47                        flow.page = 0
48                        flow.pages = [
[105]49                                [title: 'Study'],               // study
[138]50                                [title: 'Subjects'],    // subjects
[145]51                                [title: 'Groups'],              // groups
[138]52                                [title: 'Form elements demo page']
[101]53                        ]
[86]54
[101]55                }
[86]56
[105]57                // render the main wizard page which immediately
58                // triggers the 'next' action (hence, the main
59                // page dynamically renders the study template
60                // and makes the flow jump to the study logic)
[101]61                mainPage {
62                        render(view: "/wizard/index")
63                        onRender {
64                                flow.page = 1
65                        }
[103]66                        on("next").to "study"
[101]67                }
[86]68
[105]69                // render the study page and handle study logic
[103]70                study {
71                        render(view: "_study")
[101]72                        onRender {
73                                flow.page = 1
74                        }
75                        on("next") {
[138]76                                // create date instance from date string?
77                                // @see WizardTagLibrary::dateElement{...}
78                                if (params.get('startDate')) {
79                                        params.startDate = new Date().parse("d/M/yyyy", params.get('startDate').toString())
80                                }
81
[145]82                                // if a template is selected, get template instance
83                                if (params.get('template')) {
84                                        params.template = Template.findByName(params.get('template'))
85                                }
86
[101]87                                // create a study instance
[103]88                                flow.study = new Study(params)
[101]89
[103]90                                // validate study
91                                if (flow.study.validate()) {
[105]92                                        success()
[101]93                                } else {
[103]94                                        // validation failed, feedback errors
95                                        flash.errors = new LinkedHashMap()
96                                        this.appendErrors(flow.study,flash.errors)
[101]97                                        error()
98                                }
[138]99                        }.to "subjects"
[101]100                }
101
102                // render page two
[138]103                subjects {
104                        render(view: "_subjects")
[101]105                        onRender {
106                                flow.page = 2
[138]107
108                                if (!flow.subjects) {
[140]109                                        flow.subjects = []
[138]110                                }
[101]111                        }
[138]112                        on ("add") {
[157]113                                // fetch species by name (as posted by the form)
[138]114                                def speciesTerm = Term.findByName(params.addSpecies)
115                               
116                                // add x subject of species y
117                                (params.addNumber as int).times {
118                                        def increment = flow.subjects.size()
119                                        flow.subjects[ increment ] = new Subject(
120                                                name: 'Subject ' + (increment+1),
121                                                species: speciesTerm
122                                        )
123                                }
124                        }.to "subjects"
[101]125                        on("next") {
[138]126                                // got one or more subjects?
127                                if (flow.subjects.size() < 1) {
128                                        error()
129                                }
[145]130                        }.to "groups"
[101]131                        on("previous") {
[145]132                                // TODO
[103]133                        }.to "study"
[101]134                }
135
[145]136                groups {
137                        render(view: "_groups")
138                        onRender {
139                                flow.page = 3
140
141                                if (!flow.groups) {
142                                        flow.groups = []
143                                }
144                        }
145                        on("next") {
146                                // TODO
147                        }.to "groups"
148                        on("previous") {
149                                // TODO
150                        }.to "subjects"
151                }
152
[101]153                // render page three
[145]154                demo {
[101]155                        render(view: "_three")
156                        onRender {
157                                flow.page = 3
158                        }
159                        on("previous") {
[157]160                                // TODO
[138]161                        }.to "subjects"
[101]162                }
163        }
[103]164
165        /**
166         * transform domain class validation errors into a human readable
167         * linked hash map
168         * @param object validated domain class
169         * @returns object  linkedHashMap
170         */
171        def getHumanReadableErrors(object) {
172                def errors = new LinkedHashMap()
173
174                object.errors.getAllErrors().each() {
175                        errors[it.getArguments()[0]] = it.getDefaultMessage()
176                }
177
178                return errors
179        }
180
181        /**
182         * append errors of a particular object to a map
183         * @param object
184         * @param map linkedHashMap
185         * @void
186         */
187        def appendErrors(object, map) {
188                this.appendErrorMap(this.getHumanReadableErrors(object), map)
189        }
190
191        /**
192         * append errors of one map to another map
193         * @param map linkedHashMap
194         * @param map linkedHashMap
195         * @void
196         */
197        def appendErrorMap(map, mapToExtend) {
198                map.each() {key, value ->
199                        mapToExtend[key] = value
200                }
201        }
[86]202}
Note: See TracBrowser for help on using the repository browser.