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

Last change on this file was 1588, checked in by s.h.sikkema@…, 8 years ago

Fixed tests (except webtests); cleaned up Example{Studies,Templates}.groovy; decapitalized injected services; made 'transactional' properties static

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