source: trunk/grails-app/taglib/dbnp/importer/ImporterTagLib.groovy @ 1426

Last change on this file since 1426 was 1426, checked in by work@…, 10 years ago
  • Resolved part of improvement #225
  • refactored the template model out of GSCF into the GDT (Grails Domain Templates) plugin version 0.0.1
  • still work needs to be done (move template editor into gdt, etcetera)
  • fix template owner
  • some methods are missing from Template, but most of it works
  • Property svn:keywords set to Author Date Rev
File size: 6.9 KB
Line 
1/**
2 * Importer tag library
3 *
4 * The importer tag library gives support for automating several 'components'
5 *
6 * @package importer
7 * @author t.w.abma@umcutrecht.nl
8 * @since 20100202
9 *
10 * Revision information:
11 * $Rev: 1426 $
12 * $Author: work@osx.eu $
13 * $Date: 2011-01-21 18:37:02 +0000 (vr, 21 jan 2011) $
14 */
15
16package dbnp.importer
17
18import dbnp.studycapturing.*
19import nl.grails.plugins.gdt.*
20import org.apache.poi.ss.usermodel.Cell
21import org.apache.poi.ss.usermodel.DataFormatter
22
23class ImporterTagLib {
24        static namespace = 'importer'
25        def ImporterService
26
27        /**
28         * @param header string array containing header
29         * @param datamatrix two dimensional array containing actual data
30         * @return preview of the data with the ability to adjust the datatypes
31         */
32        def preview = { attrs ->
33
34                def header = attrs['header']
35                def datamatrix = attrs['datamatrix']
36
37                out << render(template: "common/preview", model: [header: header, datamatrix: datamatrix])
38        }
39
40        /**
41         * @param datamatrix two dimensional array containing entities with read values
42         * @return postview of the imported data
43         */
44        def postview = { attrs ->
45                def datamatrix = attrs['datamatrix']
46
47                out << render(template: "common/postview", model: [datamatrix: datamatrix])
48        }
49
50        def entity = { attrs ->
51                out << entities[attrs['index']].name
52        }
53
54        def datapreview = { attrs ->
55                def datamatrix = attrs['datamatrix']
56                out << render(template: "common/datapreview", model: [datamatrix: datamatrix])
57        }
58
59        /**
60         * Show missing properties
61         */
62        def missingProperties = { attrs ->
63                def datamatrix = attrs['datamatrix']
64                def failedcells = attrs['failedcells']
65                out << render(template: "common/missingproperties", model: [datamatrix: datamatrix, failedcells: failedcells])
66        }
67
68        /**
69         * Show failed cells
70         */
71        def failedCells = { attrs ->
72                def failedcells = attrs['failedcells']
73                out << render(template: "common/failedcells", model: [failedcells: failedcells])
74        }
75
76        /**
77         * @param entities array containing selected entities
78         * @param header array containing mappingcolumn objects
79         * @param allfieldtypes if set, show all fields
80         */
81        def properties = { attrs ->
82                def header = attrs['header']
83                def entities = attrs['entities']
84
85                out << render(template: "common/properties_horizontal")
86        }
87
88        /**
89         * Possibly this will later on return an AJAX-like autocompletion chooser for the fields?
90         *
91         * @param name name for the property chooser element
92         * @param importtemplate_id template identifier where fields are retrieved from
93         * @param matchvalue value which will be looked up via fuzzy matching against the list of options and will be selected
94         * @param MappingColumn object containing all required information
95         * @param allfieldtypes boolean true if all templatefields should be listed, otherwise only show filtered templatefields
96         * @return chooser object
97         * */
98        def propertyChooser = { attrs ->
99                // TODO: this should be changed to retrieving fields per entity instead of from one template
100                //       and session variables should not be used inside the service, migrate to controller
101
102                def t = Template.get(attrs['template_id'])
103                def mc = attrs['mappingcolumn']
104                def allfieldtypes = attrs['allfieldtypes']
105                def matchvalue = attrs['matchvalue']
106                def domainfields = mc.entity.giveDomainFields().findAll { it.type == mc.templatefieldtype }
107                domainfields = domainfields.findAll { it.preferredIdentifier != mc.identifier}
108
109                //def templatefields = (allfieldtypes=="true") ? t.fields : t.fields.findAll { it.type == mc.templatefieldtype }
110                def templatefields = (allfieldtypes == "true") ?
111                        t.fields + mc.entity.giveDomainFields() :
112                        t.fields.findAll { it.type == mc.templatefieldtype } + domainfields
113
114                // map identifier to preferred column
115                def prefcolumn = mc.entity.giveDomainFields().findAll { it.preferredIdentifier == true }
116
117                (mc.identifier) ? out << createPropertySelect(attrs['name'], prefcolumn, matchvalue, mc.index) :
118                        out << createPropertySelect(attrs['name'], templatefields, matchvalue, mc.index)
119        }
120
121        /**
122         * Create the property chooser select element
123         *
124         * @param name name of the HTML select object
125         * @param options list of options (fields) to be used
126         * @param matchvalue value which will be looked up via fuzzy matching against the list of options and will be selected
127         * @param columnIndex column identifier (corresponding to position in header of the Excel sheet)
128         * @return HTML select object
129         */
130        def createPropertySelect(String name, options, matchvalue, Integer columnIndex) {
131                // Determine which field in the options list matches the best with the matchvalue
132                def mostsimilar = ImporterService.mostSimilar(matchvalue, options)
133
134                def res = "<select style=\"font-size:10px\" name=\"${name}.index.${columnIndex}\">"
135
136                res += "<option value=\"dontimport\">Don't import</option>"
137
138                options.each { f ->
139                        res += "<option value=\"${f.name}\""
140
141                        res += (mostsimilar.toString().toLowerCase() == f.name.toLowerCase()) ?
142                                " selected>" :
143                                ">"
144
145                        res += (f.preferredIdentifier) ?
146                                "${f.name} (IDENTIFIER)</option>" :
147                                "${f.name}</option>"
148                }
149
150                res += "</select>"
151                return res
152        }
153
154        /**
155         * @param selected selected TemplateFieldType
156         * @param custval custom value to be combined in the option(s) of the selector
157         * @param name name of the HTML select object
158         * @return HTML select object
159         *
160         * @see nl.grails.plugins.gdt.TemplateFieldType
161         */
162
163        def entitySelect = { attrs ->
164                def sel = (attrs['selected'] == null) ? -1 : attrs['selected']
165                def custval = (attrs['customvalue'] == null) ? "" : attrs['customvalue']
166                def name = (attrs['name'] == null) ? -1 : attrs['name']
167
168                def res = "<select style=\"font-size:10px\" name=\"${name}.index.${custval}\">"
169
170                grailsApplication.config.gscf.domain.importableEntities.each { e ->
171                        res += "<option value=\"${e.value.name}\""
172                        res += (e.value.type == sel) ? " selected" : ""
173                        res += ">${e.value.name}</option>"
174                }
175
176                res += "</select>"
177                out << res
178        }
179
180        /**
181         * Create a templatefieldtype selector
182         *
183         * @param selected selected TemplateFieldType
184         * @param customvalue custom value to be combined in the option(s) of the selector
185         * @param name name of the HTML select object
186         * @return HTML select object
187         *
188         * @see nl.grails.plugins.gdt.TemplateFieldType
189         */
190        def templatefieldtypeSelect = { attrs ->
191                def selected = (attrs['selected'] == null) ? -1 : attrs['selected']
192                def custval = (attrs['customvalue'] == null) ? "" : attrs['customvalue']
193                def name = (attrs['name'] == null) ? "" : attrs['name']
194
195                def res = "<select style=\"font-size:10px\" name=\"${name}.index.${custval}\">"
196
197                TemplateFieldType.list().each { e ->
198                        res += "<option value=\"${e}\""
199                        res += (e == selected) ? " selected" : ""
200                        res += ">${e}</option>"
201                }
202
203                res += "</select>"
204
205                out << res
206        }
207
208        /**
209         * @param cell Cell variable
210         * @return good representation of variable (instead of toString())
211         */
212        def displayCell = { attrs ->
213                def cell = attrs['cell']
214                def df = new DataFormatter()
215
216                switch (cell.getCellType()) {
217                        case Cell.CELL_TYPE_STRING: out << cell.getStringCellValue()
218                                break
219                        case Cell.CELL_TYPE_NUMERIC: out << df.formatCellValue(cell)
220                                break
221                }
222        }
223}
Note: See TracBrowser for help on using the repository browser.