Ignore:
Timestamp:
Feb 11, 2011, 2:59:27 PM (9 years ago)
Author:
t.w.abma@…
Message:
  • added load/save button to mappings page
  • fuzzy button applies fuzzy matching
  • fixed bug when pressing save didn't remember selected properties and went into "fuzzy mode"
  • importmapping instance is stored, but adding the mappingcolumns is the last "todo"
File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/grails-app/controllers/dbnp/importer/ImporterController.groovy

    r1514 r1515  
    148148                                if (pluginManager.getGrailsPlugin('grom')) ".rendering the partial: pages/_page_two.gsp".grom()
    149149
     150                flow.importer_importmappings = ImportMapping.list()
     151
    150152                                flow.page = 2
    151153                                success()
    152154                        }
    153155            on("refresh") {
     156                flow.importer_importmappings = ImportMapping.list()
     157
    154158                // a name was given to the current property mapping, try to store it
    155159                if (params.mappingname) {
    156                     flash['mappingname'] = params.mappingname
    157                     propertiesSaveImportMappingPage(flow, flash, params)
     160                    flash.importer_columnproperty = params.columnproperty
     161                    propertiesSaveImportMappingPage(flow, flash, params)                   
    158162                }
    159                 flow.importer_fuzzymatching="true"
    160                                 success()
     163               
     164                if (params.fuzzymatching == "true")
     165                    flow.importer_fuzzymatching="true" else
     166                    flow.importer_fuzzymatching="false"
     167
     168                success()
    161169                        }.to "pageTwo"
    162170
     
    338346                        flow.importer_datamatrix_start = params.datamatrix_start.toInteger() - 1 // 0 == first row
    339347                        flow.importer_headerrow = params.headerrow.toInteger()
     348            flow.importer_entityclass = entityClass.getClass()
    340349
    341350                        // Get the header from the Excel file using the arguments given in the first step of the wizard
     
    346355                                entityClass)
    347356
    348                         // Initialize 'selected entities', used to show entities above the columns
    349                         flow.importer_header.each {
    350                                 selectedentities.add([name: entityName, columnindex: it.key.toInteger()])
    351                         }
    352 
    353                         flow.importer_selectedentities = selectedentities
    354 
    355357                        session.importer_datamatrix = ImporterService.getDatamatrix(
    356358                                session.importer_workbook, flow.importer_header,
     
    379381    boolean propertiesSaveImportMappingPage(flow, flash, params) {
    380382        flash.wizardErrors = [:]
     383        def isPreferredIdentifier = false
    381384
    382385                // Find actual Template object from the chosen template name
    383386                def template = Template.get(flow.importer_template_id)
    384         //def im = new ImportMapping(name:params.mappingname).save()
     387       
     388        // Create new ImportMapping instance and persist it
     389        def im = new ImportMapping(name:params.mappingname, entity: flow.importer_entityclass, template:template).save()
     390       
    385391
    386392                params.columnproperty.index.each { columnindex, property ->
    387393                        // Create an actual class instance of the selected entity with the selected template
    388                         // This should be inside the closure because in some cases in the advanced importer, the fields can have different target entities
    389                         def entityClass = Class.forName(flow.importer_header[columnindex.toInteger()].entity.getName(), true, this.getClass().getClassLoader())
    390                         def entityObj = entityClass.newInstance(template: template)
     394                        // This should be inside the closure because in some cases in the advanced importer, the fields can have different target entities                     
     395                        def entityClass = GdtService.getInstanceByEntityName(flow.importer_header[columnindex.toInteger()].entity.getName())
     396            def entityObj = entityClass.newInstance(template:template)
     397
    391398            def dontimport = (property == "dontimport") ? true : false
    392399
    393             def mc = new MappingColumn (property:property, templatefieldtype:entityObj.giveFieldType(property), dontimport: dontimport )
    394 
    395                         // Store the selected property for this column into the column map for the ImporterService
    396                         /*flow.importer_header[columnindex.toInteger()].property = property
    397 
    398                         // Look up the template field type of the target TemplateField and store it also in the map
    399                         flow.importer_header[columnindex.toInteger()].templatefieldtype = entityObj.giveFieldType(property)
    400 
    401                         // Is a "Don't import" property assigned to the column?
    402                         flow.importer_header[columnindex.toInteger()].dontimport = (property == "dontimport") ? true : false
    403 
    404                         //if it's an identifier set the mapping column true or false
    405                         entityObj.giveFields().each {
    406                                 (it.preferredIdentifier && (it.name == property)) ? flow.importer_header[columnindex.toInteger()].identifier = true : false
    407                         }*/
     400            // Loop through all fields and find the preferred identifier
     401            entityObj.giveFields().each {               
     402                                isPreferredIdentifier = (it.preferredIdentifier && (it.name == property)) ? true : false
     403                        }
     404
     405            // Create new MappingColumn instance
     406            /*def mc = new MappingColumn (name: flow.importer_header[columnindex.toInteger()].name,
     407                                        property:property,
     408                                        index:columnindex,
     409                                        entity:entityClass,
     410                                        templatefieldtype:entityObj.giveFieldType(property),
     411                                        dontimport: dontimport,
     412                                        identifier:isPreferredIdentifier)
     413
     414            println "storing mapping: " + mc.validate()
     415            im.addToMappingColumns(mc)*/
    408416                }
    409417    }
Note: See TracChangeset for help on using the changeset viewer.