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

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