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@…, 12 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
RevLine 
[169]1/**
2 * Importer tag library
3 *
4 * The importer tag library gives support for automating several 'components'
5 *
[1426]6 * @package importer
7 * @author t.w.abma@umcutrecht.nl
8 * @since 20100202
[169]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
[1461]17import org.dbnp.gdt.*
[1469]18import org.dbnp.gdt.*
19
[1087]20import org.apache.poi.ss.usermodel.Cell
[297]21import org.apache.poi.ss.usermodel.DataFormatter
[169]22
23class ImporterTagLib {
[1426]24        static namespace = 'importer'
25        def ImporterService
[1443]26        def GdtService
[169]27
[1426]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 ->
[169]34
[1426]35                def header = attrs['header']
36                def datamatrix = attrs['datamatrix']
[169]37
[1426]38                out << render(template: "common/preview", model: [header: header, datamatrix: datamatrix])
39        }
[283]40
[1426]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']
[283]47
[1426]48                out << render(template: "common/postview", model: [datamatrix: datamatrix])
49        }
[200]50
[1426]51        def entity = { attrs ->
52                out << entities[attrs['index']].name
53        }
[632]54
[1426]55        def datapreview = { attrs ->
56                def datamatrix = attrs['datamatrix']
57                out << render(template: "common/datapreview", model: [datamatrix: datamatrix])
58        }
[632]59
[1426]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        }
[1058]68
[1426]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        }
[632]76
[1426]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']
[200]85
[1426]86                out << render(template: "common/properties_horizontal")
87        }
[321]88
[1426]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
[1505]96     * @param fuzzymatching boolean true if fuzzy matching should be used, otherwise false
[1426]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
[489]103
[1426]104                def t = Template.get(attrs['template_id'])
105                def mc = attrs['mappingcolumn']
[1505]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 }
[1426]110                domainfields = domainfields.findAll { it.preferredIdentifier != mc.identifier}
[545]111
[1426]112                //def templatefields = (allfieldtypes=="true") ? t.fields : t.fields.findAll { it.type == mc.templatefieldtype }
[1481]113                /*def templatefields = (allfieldtypes == "true") ?
[1426]114                        t.fields + mc.entity.giveDomainFields() :
[1481]115                        t.fields.findAll { it.type == mc.templatefieldtype } + domainfields*/
116        def templatefields = t.fields + mc.entity.giveDomainFields()
[231]117
[1426]118                // map identifier to preferred column
119                def prefcolumn = mc.entity.giveDomainFields().findAll { it.preferredIdentifier == true }
[1141]120
[1481]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)
[1426]124        }
[231]125
[1426]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
[1505]137                def mostsimilar = (matchvalue) ? ImporterService.mostSimilar(matchvalue, options) : ""
[669]138
[1479]139                def res = "<select style=\"font-size:10px\" id=\"${name}.index.${columnIndex}\" name=\"${name}.index.${columnIndex}\">"
[1143]140
[1426]141                res += "<option value=\"dontimport\">Don't import</option>"
[231]142
[1426]143                options.each { f ->
144                        res += "<option value=\"${f.name}\""
[231]145
[1426]146                        res += (mostsimilar.toString().toLowerCase() == f.name.toLowerCase()) ?
147                                " selected>" :
148                                ">"
[259]149
[1426]150                        res += (f.preferredIdentifier) ?
151                                "${f.name} (IDENTIFIER)</option>" :
152                                "${f.name}</option>"
153                }
[256]154
[1426]155                res += "</select>"
156                return res
[256]157        }
158
[1426]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         *
[1456]165         * @see org.dbnp.gdt.TemplateFieldType
[1426]166         */
[169]167
[1426]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']
[256]172
[1426]173                def res = "<select style=\"font-size:10px\" name=\"${name}.index.${custval}\">"
[256]174
[1443]175                GdtService.getTemplateEntities().each { e ->
176                        res += "<option value\"${e.name}\""
177                        res += ">${e.name} bla</option>"
[1426]178                }
179
180                res += "</select>"
181                out << res
[256]182        }
183
[1426]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         *
[1456]192         * @see org.dbnp.gdt.TemplateFieldType
[1426]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']
[256]198
[1426]199                def res = "<select style=\"font-size:10px\" name=\"${name}.index.${custval}\">"
[297]200
[1426]201                TemplateFieldType.list().each { e ->
202                        res += "<option value=\"${e}\""
203                        res += (e == selected) ? " selected" : ""
204                        res += ">${e}</option>"
205                }
[297]206
[1426]207                res += "</select>"
208
209                out << res
[297]210        }
[1426]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        }
[169]227}
Note: See TracBrowser for help on using the repository browser.