source: trunk/grails-app/taglib/dbnp/studycapturing/WizardTagLib.groovy @ 247

Last change on this file since 247 was 247, checked in by duh, 9 years ago
  • set keyword expansion
  • Property svn:keywords set to Author Rev Date
File size: 16.9 KB
Line 
1package dbnp.studycapturing
2
3import org.codehaus.groovy.grails.plugins.web.taglib.JavascriptTagLib
4import dbnp.studycapturing.*
5import dbnp.data.*
6
7/**
8 * Wizard tag library
9 *
10 * @author Jeroen Wesbeek
11 * @since 20100113
12 * @package wizard
13 *
14 * Revision information:
15 * $Rev: 247 $
16 * $Author: duh $
17 * $Date: 2010-03-08 17:29:14 +0000 (ma, 08 mrt 2010) $
18 */
19class WizardTagLib extends JavascriptTagLib {
20        // define the tag namespace (e.g.: <wizard:action ... />
21        static namespace = "wizard"
22
23        // define the AJAX provider to use
24        static ajaxProvider = "jquery"
25
26        // define default text field width
27        static defaultTextFieldSize = 25;
28
29        /**
30         * ajaxButton tag, this is a modified version of the default
31         * grails submitToRemote tag to work with grails webflows.
32         * Usage is identical to submitToRemote with the only exception
33         * that a 'name' form element attribute is required. E.g.
34         * <wizard:ajaxButton name="myAction" value="myButton ... />
35         *
36         * you can also provide a javascript function to execute after
37         * success. This behaviour differs from the default 'after'
38         * action which always fires after a button press...
39         *
40         * @see http://blog.osx.eu/2010/01/18/ajaxifying-a-grails-webflow/
41         * @see http://www.grails.org/WebFlow
42         * @see http://www.grails.org/Tag+-+submitToRemote
43         * @todo perhaps some methods should be moved to a more generic
44         *        'webflow' taglib or plugin
45         * @param Map attributes
46         * @param Closure body
47         */
48        def ajaxButton = {attrs, body ->
49                // get the jQuery version
50                def jQueryVersion = grailsApplication.getMetadata()['plugins.jquery']
51
52                // fetch the element name from the attributes
53                def elementName = attrs['name'].replaceAll(/ /, "_")
54
55                // javascript function to call after success
56                def afterSuccess = attrs['afterSuccess']
57
58                // src parameter?
59                def src = attrs['src']
60                def alt = attrs['alt']
61
62                // generate a normal submitToRemote button
63                def button = submitToRemote(attrs, body)
64
65                /**
66                 * as of now (grails 1.2.0 and jQuery 1.3.2.4) the grails webflow does
67                 * not properly work with AJAX as the submitToRemote button does not
68                 * handle and submit the form properly. In order to support webflows
69                 * this method modifies two parts of a 'normal' submitToRemote button:
70                 *
71                 * 1) replace 'this' with 'this.form' as the 'this' selector in a button
72                 *    action refers to the button and / or the action upon that button.
73                 *    However, it should point to the form the button is part of as the
74                 *    the button should submit the form data.
75                 * 2) prepend the button name to the serialized data. The default behaviour
76                 *    of submitToRemote is to remove the element name altogether, while
77                 *    the grails webflow expects a parameter _eventId_BUTTONNAME to execute
78                 *    the appropriate webflow action. Hence, we are going to prepend the
79                 *    serialized formdata with an _eventId_BUTTONNAME parameter.
80                 */
81                if (jQueryVersion =~ /^1.([1|2|3]).(.*)/) {
82                        // fix for older jQuery plugin versions
83                        button = button.replaceFirst(/data\:jQuery\(this\)\.serialize\(\)/, "data:\'_eventId_${elementName}=1&\'+jQuery(this.form).serialize()")
84                } else {
85                        // as of jQuery plugin version 1.4.0.1 submitToRemote has been modified and the
86                        // this.form part has been fixed. Consequently, our wrapper has changed as well...
87                        button = button.replaceFirst(/data\:jQuery/, "data:\'_eventId_${elementName}=1&\'+jQuery")
88                }
89
90                // add an after success function call?
91                // usefull for performing actions on success data (hence on refreshed
92                // wizard pages, such as attaching tooltips)
93                if (afterSuccess) {
94                        button = button.replaceFirst(/\.html\(data\)\;/, '.html(data);' + afterSuccess + ';')
95                }
96
97                // got an src parameter?
98                if (src) {
99                        def replace = 'type="image" src="' + src + '"'
100
101                        if (alt) replace = replace + ' alt="' + alt + '"'
102
103                        button = button.replaceFirst(/type="button"/, replace)
104                }
105
106                // replace double semi colons
107                button = button.replaceAll(/;{2,}/, ';')
108
109                // render button
110                out << button
111        }
112
113        /**
114         * generate a ajax submit JavaScript
115         * @see WizardTagLib::ajaxFlowRedirect
116         * @see WizardTagLib::baseElement (ajaxSubmitOnChange)
117         */
118        def ajaxSubmitJs = {attrs, body ->
119                // define AJAX provider
120                setProvider([library: ajaxProvider])
121
122                // got a function name?
123                def functionName = attrs.remove('functionName')
124                if (functionName && !attrs.get('name')) {
125                        attrs.name = functionName
126                }
127
128                // generate an ajax button
129                def button = this.ajaxButton(attrs, body)
130
131                // strip the button part to only leave the Ajax call
132                button = button.replaceFirst(/<[^\"]*\"jQuery.ajax/, 'jQuery.ajax')
133                button = button.replaceFirst(/return false.*/, '')
134
135                // change form if a form attribute is present
136                if (attrs.get('form')) {
137                        button = button.replaceFirst(/this\.form/,
138                                "\\\$('" + attrs.get('form') + "')"
139                        )
140                }
141
142                out << button
143        }
144
145        /**
146         * generate ajax webflow redirect javascript
147         *
148         * As we have an Ajaxified webflow, the initial wizard page
149         * cannot contain a wizard form, as upon a failing submit
150         * (e.g. the form data does not validate) the form should be
151         * shown again. However, the Grails webflow then renders the
152         * complete initial wizard page into the success div. As this
153         * ruins the page layout (a page within a page) we want the
154         * initial page to redirect to the first wizard form to enter
155         * the webflow correctly. We do this by emulating an ajax post
156         * call which updates the wizard content with the first wizard
157         * form.
158         *
159         * Usage: <wizard:ajaxFlowRedirect form="form#wizardForm" name="next" url="[controller:'wizard',action:'pages']" update="[success:'wizardPage',failure:'wizardError']" />
160         * form = the form identifier
161         * name = the action to execute in the webflow
162         * update = the divs to update upon success or error
163         *
164         * OR: to generate a JavaScript function you can call yourself, use 'functionName' instead of 'name'
165         *
166         * Example initial webflow action to work with this javascript:
167         * ...
168         * mainPage {*  render(view: "/wizard/index")
169         *      onRender {*             flow.page = 1
170         *}*    on("next").to "pageOne"
171         *}* ...
172         *
173         * @param Map attributes
174         * @param Closure body
175         */
176        def ajaxFlowRedirect = {attrs, body ->
177                // generate javascript
178                out << '<script type="text/javascript">'
179                out << '$(document).ready(function() {'
180                out << ajaxSubmitJs(attrs, body)
181                out << '});'
182                out << '</script>'
183        }
184
185        /**
186         * render the content of a particular wizard page
187         * @param Map attrs
188         * @param Closure body  (help text)
189         */
190        def pageContent = {attrs, body ->
191                // define AJAX provider
192                setProvider([library: ajaxProvider])
193
194                // render new body content
195                out << render(template: "/wizard/common/tabs")
196                out << '<div class="content">'
197                out << body()
198                out << '</div>'
199                out << render(template: "/wizard/common/navigation")
200                out << render(template: "/wizard/common/error")
201        }
202
203        /**
204         * generate a base form element
205         * @param String inputElement name
206         * @param Map attributes
207         * @param Closure help content
208         */
209        def baseElement = {inputElement, attrs, help ->
210                // work variables
211                def description = attrs.remove('description')
212                def addExampleElement = attrs.remove('addExampleElement')
213                def addExample2Element = attrs.remove('addExample2Element')
214
215                // got an ajax onchange action?
216                def ajaxOnChange = attrs.remove('ajaxOnChange')
217                if (ajaxOnChange) {
218                        if (!attrs.onChange) attrs.onChange = ''
219
220                        // add onChange AjaxSubmit javascript
221                        attrs.onChange += ajaxSubmitJs(
222                                [
223                                        functionName: ajaxOnChange,
224                                        url: attrs.get('url'),
225                                        update: attrs.get('update'),
226                                        afterSuccess: attrs.get('afterSuccess')
227                                ],
228                                ''
229                        )
230                }
231
232                // execute inputElement call
233                def renderedElement = "$inputElement"(attrs)
234
235                // if false, then we skip this element
236                if (!renderedElement) return false
237
238                // render a form element
239                out << '<div class="element">'
240                out << ' <div class="description">'
241                out << description
242                out << ' </div>'
243                out << ' <div class="input">'
244                out << renderedElement
245                if (help()) {
246                        out << '        <div class="helpIcon"></div>'
247                }
248
249                // add an disabled input box for feedback purposes
250                // @see dateElement(...)
251                if (addExampleElement) {
252                        def exampleAttrs = new LinkedHashMap()
253                        exampleAttrs.name = attrs.get('name') + 'Example'
254                        exampleAttrs.class = 'isExample'
255                        exampleAttrs.disabled = 'disabled'
256                        exampleAttrs.size = 30
257                        out << textField(exampleAttrs)
258                }
259
260                // add an disabled input box for feedback purposes
261                // @see dateElement(...)
262                if (addExample2Element) {
263                        def exampleAttrs = new LinkedHashMap()
264                        exampleAttrs.name = attrs.get('name') + 'Example2'
265                        exampleAttrs.class = 'isExample'
266                        exampleAttrs.disabled = 'disabled'
267                        exampleAttrs.size = 30
268                        out << textField(exampleAttrs)
269                }
270
271                out << ' </div>'
272
273                // add help content if it is available
274                if (help()) {
275                        out << '  <div class="helpContent">'
276                        out << '    ' + help()
277                        out << '  </div>'
278                }
279
280                out << '</div>'
281        }
282
283        /**
284         * render a textFieldElement
285         * @param Map attrs
286         * @param Closure body  (help text)
287         */
288        def textFieldElement = {attrs, body ->
289                // set default size, or scale to max length if it is less than the default size
290                if (!attrs.get("size")) {
291                        if (attrs.get("maxlength")) {
292                                attrs.size = ((attrs.get("maxlength") as int) > defaultTextFieldSize) ? defaultTextFieldSize : attrs.get("maxlength")
293                        } else {
294                                attrs.size = defaultTextFieldSize
295                        }
296                }
297
298                // render template element
299                baseElement.call(
300                        'textField',
301                        attrs,
302                        body
303                )
304        }
305
306        /**
307         * render a select form element
308         * @param Map attrs
309         * @param Closure body  (help text)
310         */
311        def selectElement = {attrs, body ->
312                baseElement.call(
313                        'select',
314                        attrs,
315                        body
316                )
317        }
318
319        /**
320         * render a checkBox form element
321         * @param Map attrs
322         * @param Closure body  (help text)
323         */
324        def checkBoxElement = {attrs, body ->
325                baseElement.call(
326                        'checkBox',
327                        attrs,
328                        body
329                )
330        }
331
332        /**
333         * render a dateElement
334         * NOTE: datepicker is attached through wizard.js!
335         * @param Map attrs
336         * @param Closure body  (help text)
337         */
338        def dateElement = {attrs, body ->
339                // transform value?
340                if (attrs.value instanceof Date) {
341                        // transform date instance to formatted string (dd/mm/yyyy)
342                        attrs.value = String.format('%td/%<tm/%<tY', attrs.value)
343                }
344
345                // set some textfield values
346                attrs.maxlength = (attrs.maxlength) ? attrs.maxlength : 10
347                attrs.addExampleElement = true
348
349                // render a normal text field
350                //out << textFieldElement(attrs,body)
351                textFieldElement.call(
352                        attrs,
353                        body
354                )
355        }
356
357        /**
358         * render a dateElement
359         * NOTE: datepicker is attached through wizard.js!
360         * @param Map attrs
361         * @param Closure body  (help text)
362         */
363        def timeElement = {attrs, body ->
364                // transform value?
365                if (attrs.value instanceof Date) {
366                        // transform date instance to formatted string (dd/mm/yyyy)
367                        attrs.value = String.format('%td/%<tm/%<tY %<tH:%<tM', attrs.value)
368                }
369
370                attrs.addExampleElement = true
371                attrs.addExample2Element = true
372                attrs.maxlength = 16
373
374                // render a normal text field
375                //out << textFieldElement(attrs,body)
376                textFieldElement.call(
377                        attrs,
378                        body
379                )
380        }
381
382        /**
383         * Template form element
384         * @param Map attributes
385         * @param Closure help content
386         */
387        def speciesElement = {attrs, body ->
388                // render template element
389                baseElement.call(
390                        'speciesSelect',
391                        attrs,
392                        body
393                )
394        }
395
396        /**
397         * Button form element
398         * @param Map attributes
399         * @param Closure help content
400         */
401        def buttonElement = {attrs, body ->
402                // render template element
403                baseElement.call(
404                        'ajaxButton',
405                        attrs,
406                        body
407                )
408        }
409
410        /**
411         * render a species select element
412         * @param Map attrs
413         */
414        def speciesSelect = {attrs ->
415                // fetch the speciesOntology
416                // note that this is a bit nasty, probably the ontologyName should
417                // be configured in a configuration file... --> TODO: centralize species configuration
418                def speciesOntology = Ontology.findByName('NCBI Taxonomy')
419
420                // fetch all species
421                attrs.from = Term.findAllByOntology(speciesOntology)
422
423                // got a name?
424                if (!attrs.name) {
425                        // nope, use a default name
426                        attrs.name = 'species'
427                }
428
429                out << select(attrs)
430        }
431
432        /**
433         * Template form element
434         * @param Map attributes
435         * @param Closure help content
436         */
437        def templateElement = {attrs, body ->
438                // render template element
439                baseElement.call(
440                        'templateSelect',
441                        attrs,
442                        body
443                )
444        }
445
446        /**
447         * render a template select element
448         * @param Map attrs
449         */
450        def templateSelect = {attrs ->
451                def entity = attrs.remove('entity')
452
453                // fetch templates
454                if (attrs.remove('addDummy')) {
455                        attrs.from = ['']
456                        if (entity && entity instanceof Class) {
457                                Template.findAllByEntity(entity).each() {
458                                        attrs.from[attrs.from.size()] = it
459                                }
460                        }
461                } else {
462                        attrs.from = (entity) ? Template.findAllByEntity(entity) : Template.findAll()
463                }
464
465                // got a name?
466                if (!attrs.name) {
467                        attrs.name = 'template'
468                }
469
470                // got result?
471                if (attrs.from.size() > 0) {
472                        out << select(attrs)
473                } else {
474                        // no, return false to make sure this element
475                        // is not rendered in the template
476                        return false
477                }
478        }
479
480        /**
481         * Term form element
482         * @param Map attributes
483         * @param Closure help content
484         */
485        def termElement = {attrs, body ->
486                // render term element
487                baseElement.call(
488                        'termSelect',
489                        attrs,
490                        body
491                )
492        }
493
494        /**
495         * render a term select element
496         * @param Map attrs
497         */
498        def termSelect = {attrs ->
499                // fetch all terms
500                attrs.from = Term.findAll()     // for now, all terms as we cannot identify terms as being treatment terms...
501
502                // got a name?
503                if (!attrs.name) {
504                        attrs.name = 'term'
505                }
506
507                out << select(attrs)
508        }
509
510        /**
511         * Protocol form element
512         * @param Map attributes
513         * @param Closure help content
514         */
515        def protocolElement = {attrs, body ->
516                // render protocol element
517                baseElement.call(
518                        'protocolSelect',
519                        attrs,
520                        body
521                )
522        }
523
524        /**
525         * render a protocol select element
526         * @param Map attrs
527         */
528        def protocolSelect = {attrs ->
529                // fetch all protocold
530                attrs.from = Protocol.findAll() // for now, all protocols
531
532                // got a name?
533                if (!attrs.name) {
534                        attrs.name = 'protocol'
535                }
536
537                out << select(attrs)
538        }
539
540        def show = {attrs ->
541                // is object parameter set?
542                def o = attrs.object
543
544                println o.getProperties();
545                o.getProperties().each {
546                        println it
547                }
548
549                out << "!! test version of 'show' tag !!"
550        }
551
552        /**
553         * render table headers for all subjectFields in a template
554         * @param Map attributes
555         */
556        def templateColumnHeaders = {attrs ->
557                def template = attrs.remove('template')
558
559                // output table headers for template fields
560                template.fields.each() {
561                        out << '<div class="' + attrs.get('class') + '">' + it + '</div>'
562                }
563        }
564
565        /**
566         * render table input elements for all subjectFields in a template
567         * @param Map attributes
568         */
569        def templateColumns = {attrs, body ->
570                def subject = attrs.remove('subject')
571                def subjectId = attrs.remove('id')
572                def template = attrs.remove('template')
573                def intFields = subject.templateIntegerFields
574                def stringFields = subject.templateStringFields
575                def floatFields = subject.templateFloatFields
576                def termFields = subject.templateTermFields
577
578                // output columns for these subjectFields
579                template.fields.each() {
580                        // output div
581                        out << '<div class="' + attrs.get('class') + '">'
582
583                        switch (it.type) {
584                                case 'STRINGLIST':
585                                        // render stringlist subjectfield
586                                        if (!it.listEntries.isEmpty()) {
587                                                out << select(
588                                                        name: attrs.name + '_' + it.name,
589                                                        from: it.listEntries,
590                                                        value: (stringFields) ? stringFields.get(it.name) : ''
591                                                )
592                                        } else {
593                                                out << '<span class="warning">no values!!</span>'
594                                        }
595                                        break;
596                                case 'INTEGER':
597                                        // render integer subjectfield
598                                        out << textField(
599                                                name: attrs.name + '_' + it.name,
600                                                value: (intFields) ? intFields.get(it.name) : ''
601                                        )
602                                        break;
603                                case 'FLOAT':
604                                        // render float subjectfield
605                                        out << textField(
606                                                name: attrs.name + '_' + it.name,
607                                                value: (floatFields) ? floatFields.get(it.name) : ''
608                                        )
609                                        break;
610                                default:
611                                        // unsupported field type
612                                        out << '<span class="warning">!' + it.type + '</span>'
613                                        //out << subject.getFieldValue(it.name)
614                                        break;
615                        }
616
617                        out << '</div>'
618                }
619        }
620
621        /**
622         * render form elements based on an entity's template
623         * @param Map attributes
624         * @param String body
625         */
626        def templateElements = {attrs ->
627                def entity = (attrs.get('entity'))
628                def template = (entity && entity instanceof TemplateEntity) ? entity.template : null
629
630                // got a template?
631                if (template) {
632                        // render template fields
633                        template.fields.each() {
634                                switch (it.type) {
635                                        case 'STRINGLIST':
636                                                if (!it.listEntries.isEmpty()) {
637                                                        out << selectElement(
638                                                                description: it.name,
639                                                                name: it.name,
640                                                                from: it.listEntries,
641                                                                value: attrs
642                                                        )
643                                                } else {
644                                                        out << '<span class="warning">no values!!</span>'
645                                                }
646                                                break
647                                        case 'STRING':
648                                                out << textFieldElement(
649                                                        description: it.name,
650                                                        name: it.name
651                                                )
652                                                break
653                                        case 'DATE':
654                                                out << dateElement(
655                                                        description: it.name,
656                                                        name: it.name
657                                                )
658                                                break
659                                        case 'INTEGER':
660                                                out << textFieldElement(
661                                                        description: it.name,
662                                                        name: it.name
663                                                )
664                                                break
665                                        case 'DOUBLE':
666                                                out << textFieldElement(
667                                                        description: it.name,
668                                                        name: it.name
669                                                )
670                                                break
671                                        default:
672                                                out << "unkown field type '" + it.type + "'<br/>"
673                                                break
674                                }
675                        }
676                }
677        }
678}
Note: See TracBrowser for help on using the repository browser.