root/trunk/grails-app/controllers/dbnp/importer/ImporterController.groovy @ 632

Revision 632, 8.9 KB (checked in by tabma, 4 years ago)

- extra step for Simple Import Wizard implemented for easy adding and editing of cells (which were not imported yet)

  • Property svn:keywords set to Date Author Rev
Line 
1/**
2 * Importer controller
3 *
4 * The importer controller handles the uploading of tabular, comma delimited and Excel format
5 * based files. When uploaded a preview is shown of the data and the user can adjust the column
6 * type. Data in cells which don't correspond to the specified column type will be represented as "#error".
7 *
8 * The importer controller catches the actions and consecutively performs the
9 * logic behind it.
10 *
11 * @package     importer
12 * @author      t.w.abma@umcutrecht.nl
13 * @since       20100126
14 *
15 * Revision information:
16 * $Rev$
17 * $Author$
18 * $Date$
19 */
20
21package dbnp.importer
22
23import dbnp.studycapturing.Template
24import dbnp.studycapturing.Study
25import dbnp.studycapturing.Subject
26import dbnp.studycapturing.Event
27
28import dbnp.studycapturing.Sample
29import dbnp.studycapturing.TemplateFieldType
30import dbnp.studycapturing.TemplateField
31import grails.converters.JSON
32import org.apache.poi.hssf.usermodel.HSSFWorkbook
33
34class ImporterController {
35    def ImporterService   
36
37    /**
38     * Default page
39     **/
40    def index = {       
41    }
42
43    def simpleWizard = {
44        render(view:"index_simple", model:[studies:Study.list(), entities: grailsApplication.config.gscf.domain.importableEntities])
45    }
46
47    def advancedWizard = {
48        render(view:"index_advanced", model:[templates:Template.list()])
49    }
50
51    /**
52    * This method will move the uploaded file to a temporary path and send the header
53    * and the first n rows to the preview
54    * @param importfile uploaded file to import
55    * @param study.id study identifier
56    */
57    def upload_advanced = {
58        def wb = handleUpload('importfile')
59
60        session.importer_header = ImporterService.getHeader(wb, 0)
61        session.importer_study = Study.get(params.study.id.toInteger())
62        session.importer_template_id = params.template_id
63        session.importer_workbook = wb
64
65        render (view:"step1_advanced", model:[header:session.importer_header, datamatrix:ImporterService.getDatamatrix(wb, 0, 5)])
66    }
67
68    /**
69    * This method will move the uploaded file to a temporary path and send the header
70    * and the rows to the postview
71    *
72    * @param importfile uploaded file to import
73    * @param entity string representation of the entity chosen
74    */
75    def upload_simple = {
76        def wb = handleUpload('importfile')
77        def selectedentities = []
78        def entity = grailsApplication.config.gscf.domain.importableEntities.get(params.entity).entity
79        def entityClass = Class.forName(entity, true, this.getClass().getClassLoader())
80
81        session.importer_header = ImporterService.getHeader(wb, 0, entityClass)
82        session.importer_study = Study.get(params.study.id.toInteger())
83        session.importer_template_id = params.template_id
84        session.importer_workbook = wb
85
86        session.importer_header.each {     
87            selectedentities.add([name:params.entity, columnindex:it.key.toInteger()])
88        }
89
90        def templates = Template.get(session.importer_template_id)
91       
92        render(view:"step2_simple", model:[entities: selectedentities, header:session.importer_header, datamatrix:ImporterService.getDatamatrix(wb, 0, 5), templates:templates])
93    }
94
95    /**
96     * This method handles a file being uploaded and storing it in a temporary directory
97     * and returning a workbook
98     *
99     * @param formfilename name used for the file field in the form
100     * @return workbook object reference
101     */
102    private HSSFWorkbook handleUpload(formfilename) {
103
104        def downloadedfile = request.getFile(formfilename);
105        def tempfile = new File(System.getProperty('java.io.tmpdir') + File.separatorChar + System.currentTimeMillis() + ".nmcdsp")
106        downloadedfile.transferTo(tempfile)
107
108        return ImporterService.getWorkbook(new FileInputStream(tempfile))
109    }
110
111    /**
112     * @param entity entity class we are using (dbnp.studycapturing.Subject etc.)
113     */
114
115    def saveMissingProperties = {
116        println params.entity
117       
118        session.importer_importeddata.each { table ->
119            table.each { entity ->
120                entity.giveFields().each { field ->
121                    print ":" + params["entity_" + entity.hashCode() + "_" + field.escapedName()]
122                    entity.setFieldValue (field.toString(), params["entity_" + entity.hashCode() + "_" + field.escapedName()])
123                }               
124            }
125        }
126
127        render(view:"step3", model:[datamatrix:session.importer_importeddata])
128        //render("Succesful")
129    }
130
131    /**
132    * User has assigned all entities and templatefieldtypes to the columns and continues to the next step (assigning properties to columns)
133    * All information of the columns is stored in a session as MappingColumn object
134    *
135    * @param entities list of entities and columns it has been assigned to (columnindex.entitytype)
136    * @param templatefieldtype list of celltypes and columns it has been assigned to (columnindex:templatefieldtype format)
137    * @return properties page
138    *
139    * @see celltype: http://poi.apache.org/apidocs/org/apache/poi/ss/usermodel/Cell.html
140    */
141    def savePreview = {
142        def tft = null 
143        def identifiercolumnindex = (params.identifier!=null) ? params.identifier.toInteger() : -1
144        def selectedentities = []
145
146        // loop all entities and see which column has been assigned which entitytype
147        // and build an array containing the selected entities
148        params.entity.index.each { columnindex, entityname ->
149            def _entity = [name:entityname,columnindex:columnindex.toInteger()]
150            selectedentities.add(_entity)
151        }
152
153        params.templatefieldtype.index.each { columnindex, _templatefieldtype ->
154            switch (_templatefieldtype) {
155                case "STRING"       : tft = TemplateFieldType.STRING
156                                      break
157                case "TEXT"         : tft = TemplateFieldType.TEXT
158                                      break
159                case "INTEGER"      : tft = TemplateFieldType.INTEGER
160                                      break
161                case "FLOAT"        : tft = TemplateFieldType.FLOAT
162                                      break
163                case "DOUBLE"       : tft = TemplateFieldType.DOUBLE
164                                      break
165                case "STRINGLIST"   : tft = TemplateFieldType.STRINGLIST
166                                      break
167                case "ONTOLOGYTERM" : tft = TemplateFieldType.ONTOLOGYTERM
168                                      break
169                case "DATE"         : tft = TemplateFieldType.DATE
170                                      break
171                default: break
172            }
173           
174            session.importer_header[columnindex.toInteger()].templatefieldtype = tft
175        }
176
177        params.entity.index.each { columnindex, entityname ->
178            Class clazz = null
179
180            switch (entityname) {
181                case "Study"    : clazz = dbnp.studycapturing.Study
182                        break
183                case "Subject"  : clazz = dbnp.studycapturing.Subject
184                        break
185                case "Event"    : clazz = dbnp.studycapturing.Event
186                        break
187                case "Protocol" : clazz = dbnp.studycapturing.Protocol
188                        break
189                case "Sample"   : clazz = dbnp.studycapturing.Sample
190                        break
191                default: clazz = Object
192                        break
193            }
194
195            session.importer_header[columnindex.toInteger()].identifier = (columnindex.toInteger() == identifiercolumnindex) ? true : false
196            session.importer_header[columnindex.toInteger()].index = columnindex.toInteger()
197            session.importer_header[columnindex.toInteger()].entity = clazz
198        }
199
200        // currently only one template is used for all entities
201        // TODO: show template fields per entity
202       
203        def templates = Template.get(session.importer_template_id)
204
205        render(view:"step2", model:[entities:selectedentities, header:session.importer_header, templates:templates])
206    }
207
208    /**
209    * @param columnproperty array of columns containing index and property (represented as a String)
210    *
211    */
212    def saveProperties = {
213
214        params.columnproperty.index.each { columnindex, property ->
215                def template = Template.get(session.imported_template_id)
216
217                def entityClass = Class.forName(session.importer_header[columnindex.toInteger()].entity.getName(), true, this.getClass().getClassLoader())
218                def entityObj = entityClass.newInstance(template:template)
219               
220                session.importer_header[columnindex.toInteger()].property = property
221               
222                //if it's an identifier set the mapping column true or false           
223                entityObj.giveFields().each {
224                    (it.preferredIdentifier && (it.name==property)) ? session.importer_header[columnindex.toInteger()].identifier = true : false
225                }
226        }
227
228        //import workbook
229        session.importer_importeddata = ImporterService.importdata(session.importer_template_id, session.importer_workbook, 0, 1, session.importer_header)
230
231        if (params.layout=="horizontal")
232            render(view:"step3_simple", model:[datamatrix:session.importer_importeddata])
233        else if (params.layout=="vertical")
234            render(view:"step3", model:[datamatrix:session.importer_importeddata])
235    }
236
237    def savePostview = {
238        ImporterService.saveDatamatrix(session.importer_study, session.importer_importeddata)
239        render(view:"step4")
240    }
241
242    /**
243    * Return templates which belong to a certain entity type
244    *
245    * @param entity entity name string (Sample, Subject, Study et cetera)
246    * @return JSON object containing the found templates
247    */
248    def ajaxGetTemplatesByEntity = {
249        def entityClass = grailsApplication.config.gscf.domain.importableEntities.get(params.entity).entity
250       
251
252        // fetch all templates for a specific entity
253        //def templates = Template.findAllByEntity(Class.forName(entityClass, true, this.getClass().getClassLoader()))
254        def templates = Template.list()
255
256        println templates.dump()
257
258        // render as JSON
259        render templates as JSON
260    }
261}
Note: See TracBrowser for help on using the browser.