source: trunk/grails-app/controllers/dbnp/importer/ImporterController.groovy @ 485

Last change on this file since 485 was 485, checked in by tabma, 12 years ago
  • refactored (now using configuration file where entities to be used are configured)
  • Property svn:keywords set to Date Author Rev
File size: 7.5 KB
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: 485 $
17 * $Author: tabma $
18 * $Date: 2010-05-27 11:13:50 +0000 (do, 27 mei 2010) $
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    */
56    def upload_advanced = {
57        def wb = handleUpload('importfile')
58       
59        session.importer_header = ImporterService.getHeader(wb, 0)
60        session.importer_template_id = params.template_id
61        session.importer_workbook = wb
62
63        render (view:"step1_advanced", model:[header:session.importer_header, datamatrix:ImporterService.getDatamatrix(wb, 0, 5)])
64    }
65
66    /**
67    * This method will move the uploaded file to a temporary path and send the header
68    * and the rows to the postview
69    *
70    * @param importfile uploaded file to import
71    * @param entity string representation of the entity chosen
72    */
73    def upload_simple = {
74        def wb = handleUpload('importfile')
75        def entity = grailsApplication.config.gscf.domain.importableEntities.get(params.entity).entity
76        def entityClass = Class.forName(entity, true, this.getClass().getClassLoader()) 
77
78        session.importer_header = ImporterService.getHeader(wb, 0, entityClass)
79        session.importer_template_id = params.template_id
80        session.importer_workbook = wb
81
82        //import workbook
83        //session.importer_importeddata = ImporterService.importdata(session.importer_template_id, session.importer_workbook, 0, 1, session.importer_header)
84
85        //println "DAS" + session.importer_header
86
87        //render(view:"step2_simple", model:[datamatrix:session.importer_importeddata])
88        def templates = Template.get(session.importer_template_id)
89       
90        render(view:"step2", model:[entities:entities, header:session.importer_header, templates:templates])
91    }
92
93    /**
94     * This method handles a file being uploaded and storing it in a temporary directory
95     * and returning a workbook
96     *
97     * @param formfilename name used for the file field in the form
98     * @return workbook object reference
99     */
100    private HSSFWorkbook handleUpload(formfilename) {
101
102        def downloadedfile = request.getFile(formfilename);
103        def tempfile = new File(System.getProperty('java.io.tmpdir') + File.separatorChar + System.currentTimeMillis() + ".nmcdsp")
104        downloadedfile.transferTo(tempfile)
105
106        return ImporterService.getWorkbook(new FileInputStream(tempfile))
107    }
108
109    /**
110    * User has assigned all entities and templatefieldtypes to the columns and continues to the next step (assigning properties to columns)
111    * All information of the columns is stored in a session as MappingColumn object
112    *
113    * @param entities list of entities and columns it has been assigned to (columnindex.entitytype)
114    * @param templatefieldtype list of celltypes and columns it has been assigned to (columnindex:templatefieldtype format)
115    * @return properties page
116    *
117    * @see celltype: http://poi.apache.org/apidocs/org/apache/poi/ss/usermodel/Cell.html
118    */
119    def savepreview = {
120        def tft = null 
121        def identifiercolumnindex = (params.identifier!=null) ? params.identifier.toInteger() : -1
122        def selectedentities = []
123
124        // loop all entities and see which column has been assigned which entitytype
125        // and build an array containing the selected entities
126        params.entity.index.each { columnindex, entityname ->
127            def _entity = [name:entityname,columnindex:columnindex.toInteger()]
128            selectedentities.add(_entity)
129        }
130
131        params.templatefieldtype.index.each { columnindex, _templatefieldtype ->
132            switch (_templatefieldtype) {
133                case "STRING"       : tft = TemplateFieldType.STRING
134                                      break
135                case "TEXT"         : tft = TemplateFieldType.TEXT
136                                      break
137                case "INTEGER"      : tft = TemplateFieldType.INTEGER
138                                      break
139                case "FLOAT"        : tft = TemplateFieldType.FLOAT
140                                      break
141                case "DOUBLE"       : tft = TemplateFieldType.DOUBLE
142                                      break
143                case "STRINGLIST"   : tft = TemplateFieldType.STRINGLIST
144                                      break
145                case "ONTOLOGYTERM" : tft = TemplateFieldType.ONTOLOGYTERM
146                                      break
147                case "DATE"         : tft = TemplateFieldType.DATE
148                                      break
149                default: break
150            }
151           
152            session.importer_header[columnindex.toInteger()].templatefieldtype = tft
153        }
154
155        params.entity.index.each { columnindex, entityname ->
156            Class clazz
157
158            switch (entityname) {
159                case "Study"    : clazz = Study
160                        break
161                case "Subject"  : clazz = Subject
162                        break
163                case "Event"    : clazz = Event
164                        break
165                case "Protocol" : clazz = Protocol
166                        break
167                case "Sample"   : clazz = Sample
168                        break
169                default: clazz = Object
170                        break
171            }
172
173            session.importer_header[columnindex.toInteger()].identifier = (columnindex.toInteger() == identifiercolumnindex) ? true : false
174            session.importer_header[columnindex.toInteger()].index = columnindex.toInteger()
175            session.importer_header[columnindex.toInteger()].entity = clazz
176        }
177
178        // currently only one template is used for all entities
179        // TODO: show template fields per entity
180       
181        def templates = Template.get(session.importer_template_id)
182
183        render(view:"step2", model:[entities:selectedentities, header:session.importer_header, templates:templates])
184    }
185
186    /**
187    * @param columnproperty array of columns containing index and property_id
188    *
189    */
190    def saveproperties = {     
191        session.importer_study = Study.get(params.study.id.toInteger())
192
193        params.columnproperty.index.each { columnindex, property_id ->
194                session.importer_header[columnindex.toInteger()].property = TemplateField.get(property_id.toInteger())
195        }
196
197        //import workbook
198        session.importer_importeddata = ImporterService.importdata(session.importer_template_id, session.importer_workbook, 0, 1, session.importer_header)
199
200        render(view:"step3", model:[datamatrix:session.importer_importeddata])
201    }
202
203    def savepostview = {
204        ImporterService.saveDatamatrix(session.importer_study, session.importer_importeddata)
205        render(view:"step4")
206    }
207
208    /**
209    * Return templates which belong to a certain entity type
210    *
211    * @param entity entity name string (Sample, Subject, Study et cetera)
212    * @return JSON object containing the found templates
213    */
214    def ajaxGetTemplatesByEntity = {
215        def entityClass = grailsApplication.config.gscf.domain.importableEntities.get(params.entity).entity
216
217        // fetch all templates for a specific entity
218        def templates = Template.findAllByEntity(Class.forName(entityClass, true, this.getClass().getClassLoader()))
219
220        // render as JSON
221        render templates as JSON
222    }
223}
Note: See TracBrowser for help on using the repository browser.