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

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