Changeset 1515 for trunk/grails-app

Timestamp:

Feb 11, 2011, 2:59:27 PM (10 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"

Location:

trunk/grails-app

Files:

• controllers/dbnp/importer/ImporterController.groovy (modified) (4 diffs)
• domain/dbnp/importer/ImportMapping.groovy (modified) (1 diff)
• domain/dbnp/importer/MappingColumn.groovy (modified) (1 diff)
• services/dbnp/importer/ImporterService.groovy (modified) (1 diff)
• taglib/dbnp/importer/ImporterTagLib.groovy (modified) (6 diffs)
• views/importer/common/_on_page.gsp (modified) (1 diff)
• views/importer/common/_properties_horizontal.gsp (modified) (2 diffs)

trunk/grails-app/controllers/dbnp/importer/ImporterController.groovy

@@ -148 +148 @@
                                 if (pluginManager.getGrailsPlugin('grom')) ".rendering the partial: pages/_page_two.gsp".grom()
 
+                flow.importer_importmappings = ImportMapping.list()
+
                                 flow.page = 2
                                 success()
                         }
             on("refresh") {
+                flow.importer_importmappings = ImportMapping.list()
+
                 // a name was given to the current property mapping, try to store it
                 if (params.mappingname) {
-                    flash['mappingname'] = params.mappingname
-                    propertiesSaveImportMappingPage(flow, flash, params)
+                    flash.importer_columnproperty = params.columnproperty
+                    propertiesSaveImportMappingPage(flow, flash, params)                    
                 }
-                flow.importer_fuzzymatching="true"
-                                success()
+                
+                if (params.fuzzymatching == "true")
+                    flow.importer_fuzzymatching="true" else
+                    flow.importer_fuzzymatching="false"
+
+                success()
                         }.to "pageTwo"
 
@@ -338 +346 @@
                         flow.importer_datamatrix_start = params.datamatrix_start.toInteger() - 1 // 0 == first row
                         flow.importer_headerrow = params.headerrow.toInteger()
+            flow.importer_entityclass = entityClass.getClass()
 
                         // Get the header from the Excel file using the arguments given in the first step of the wizard
@@ -346 +355 @@
                                 entityClass)
 
-                        // Initialize 'selected entities', used to show entities above the columns
-                        flow.importer_header.each {
-                                selectedentities.add([name: entityName, columnindex: it.key.toInteger()])
-                        }
-
-                        flow.importer_selectedentities = selectedentities
-
                         session.importer_datamatrix = ImporterService.getDatamatrix(
                                 session.importer_workbook, flow.importer_header,
@@ -379 +381 @@
     boolean propertiesSaveImportMappingPage(flow, flash, params) {
         flash.wizardErrors = [:]
+        def isPreferredIdentifier = false
 
                 // Find actual Template object from the chosen template name
                 def template = Template.get(flow.importer_template_id)
-        //def im = new ImportMapping(name:params.mappingname).save()
+        
+        // Create new ImportMapping instance and persist it
+        def im = new ImportMapping(name:params.mappingname, entity: flow.importer_entityclass, template:template).save()
+        
 
                 params.columnproperty.index.each { columnindex, property ->
                         // Create an actual class instance of the selected entity with the selected template
-                        // This should be inside the closure because in some cases in the advanced importer, the fields can have different target entities
-                        def entityClass = Class.forName(flow.importer_header[columnindex.toInteger()].entity.getName(), true, this.getClass().getClassLoader())
-                        def entityObj = entityClass.newInstance(template: template)
+                        // This should be inside the closure because in some cases in the advanced importer, the fields can have different target entities                      
+                        def entityClass = GdtService.getInstanceByEntityName(flow.importer_header[columnindex.toInteger()].entity.getName())
+            def entityObj = entityClass.newInstance(template:template)
+
             def dontimport = (property == "dontimport") ? true : false
 
-            def mc = new MappingColumn (property:property, templatefieldtype:entityObj.giveFieldType(property), dontimport: dontimport )
-
-                        // Store the selected property for this column into the column map for the ImporterService
-                        /*flow.importer_header[columnindex.toInteger()].property = property
-
-                        // Look up the template field type of the target TemplateField and store it also in the map
-                        flow.importer_header[columnindex.toInteger()].templatefieldtype = entityObj.giveFieldType(property)
-
-                        // Is a "Don't import" property assigned to the column?
-                        flow.importer_header[columnindex.toInteger()].dontimport = (property == "dontimport") ? true : false
-
-                        //if it's an identifier set the mapping column true or false
-                        entityObj.giveFields().each {
-                                (it.preferredIdentifier && (it.name == property)) ? flow.importer_header[columnindex.toInteger()].identifier = true : false
-                        }*/
+            // Loop through all fields and find the preferred identifier
+            entityObj.giveFields().each {                
+                                isPreferredIdentifier = (it.preferredIdentifier && (it.name == property)) ? true : false
+                        }
+
+            // Create new MappingColumn instance
+            /*def mc = new MappingColumn (name: flow.importer_header[columnindex.toInteger()].name,
+                                        property:property,
+                                        index:columnindex,
+                                        entity:entityClass,
+                                        templatefieldtype:entityObj.giveFieldType(property),
+                                        dontimport: dontimport,
+                                        identifier:isPreferredIdentifier)
+
+            println "storing mapping: " + mc.validate()
+            im.addToMappingColumns(mc)*/
                 }
     }

trunk/grails-app/domain/dbnp/importer/ImportMapping.groovy

@@ -4 +4 @@
 class ImportMapping implements Serializable {
 
-        static hasMany = [columns: MappingColumn]    
+        static hasMany = [mappingcolumns: MappingColumn]
     Template template
     Class entity

trunk/grails-app/domain/dbnp/importer/MappingColumn.groovy

@@ -24 +24 @@
 
     static transients = [ "templatefieldtype", "entity" ]
+    static belongsTo = [importmapping:ImportMapping]
 
     static constraints = {

trunk/grails-app/services/dbnp/importer/ImporterService.groovy

@@ -41 +41 @@
                 def sheetrow = sheet.getRow(datamatrix_start)
                 //def header = []
-                def header = [:]
+                def header = []
                 def df = new DataFormatter()
                 def property = new String()

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

@@ -84 +84 @@
         def properties = { attrs ->
                 def header = attrs['header']
-                def entities = attrs['entities']
-
-                out << render(template: "common/properties_horizontal")
+                def entities = attrs['entities']        
+
+                out << render(template: "common/properties_horizontal", model: [header:header])
         }
 
@@ -95 +95 @@
          * @param importtemplate_id template identifier where fields are retrieved from
          * @param matchvalue value which will be looked up via fuzzy matching against the list of options and will be selected
+     * @param selected value to be selected by default
          * @param MappingColumn object containing all required information
      * @param fuzzymatching boolean true if fuzzy matching should be used, otherwise false
@@ -108 +109 @@
                 def allfieldtypes = attrs['allfieldtypes']              
         def matchvalue = (attrs['fuzzymatching']=="true") ? attrs['matchvalue'] : ""
+        def selected = (attrs['selected']) ? attrs['selected'] : ""
 
         def domainfields = mc.entity.giveDomainFields().findAll { it.type == mc.templatefieldtype }
@@ -123 +125 @@
                 /*(mc.identifier) ? out << createPropertySelect(attrs['name'], prefcolumn, matchvalue, mc.index) :
                         out << createPropertySelect(attrs['name'], templatefields, matchvalue, mc.index)*/
-         out << createPropertySelect(attrs['name'], templatefields, matchvalue, mc.index)
+         out << createPropertySelect(attrs['name'], templatefields, matchvalue, selected, mc.index)
         }
 
@@ -135 +137 @@
          * @return HTML select object
          */
-        def createPropertySelect(String name, options, matchvalue, Integer columnIndex) {
+        def createPropertySelect(String name, options, matchvalue, selected, Integer columnIndex) {
                 // Determine which field in the options list matches the best with the matchvalue
                 def mostsimilar = (matchvalue) ? ImporterService.mostSimilar(matchvalue, options) : ""
@@ -146 +148 @@
                         res += "<option value=\"${f.name}\""
 
-                        res += (mostsimilar.toString().toLowerCase() == f.name.toLowerCase()) ?
+                        // mostsimilar string passed as argument or selected value passed?
+            res += (mostsimilar.toString().toLowerCase() == f.name.toLowerCase() || selected.toLowerCase() == f.name.toLowerCase() ) ?
                                 " selected>" :
                                 ">"
-
+            
                         res += (f.preferredIdentifier) ?
                                 "${f.name} (IDENTIFIER)</option>" :

trunk/grails-app/views/importer/common/_on_page.gsp

@@ -46 +46 @@
          // attach event to apply fuzzy matching
          $('#fuzzymatchselect').click(function() {
+            $("#fuzzymatching").val("true")
             refreshFlow()
           });
 
+          // open load box
+          $('#loadpropertiesbutton').click(function() {
+            $("#loadmapping").toggle("scale")
+          });
+
+          // open save box
           $('#savepropertiesbutton').click(function() {
             var width = 500

trunk/grails-app/views/importer/common/_properties_horizontal.gsp

@@ -16 +16 @@
 
 
-<!-- saveproperties action was defined in the form -->
-  ${flash.mappingname}
+<!-- saveproperties action was defined in the form -->  
+  ${mappingname}
+
     <table>
-          <g:each var="stdentity" in ="${GdtService.cachedEntities}">
-              <% if (importer_selectedentities.any { it.name.toLowerCase() == stdentity.entity.toLowerCase() } && stdentity.entity!="") { %>
-            
-              <tr><td colspan="3"><h4>${stdentity.name}</h4></td></tr>
+              <tr><td colspan="3"><h4>defaultentity</h4></td></tr>
                 <tr>
             <td class="header" width="55px">
               <input class="buttonsmall" id="clearselect" type="button" value="Clear" name="clearselect">
               <input class="buttonsmall" id="fuzzymatchselect" type="button" value="Match" name="fuzzymatchselect">
+              <input type="hidden" name="fuzzymatching" id="fuzzymatching" value="false">
               <input class="buttonsmall" id="savepropertiesbutton" type="button" value="Save" name="savepropertiesbutton">
+              <input class="buttonsmall" id="loadpropertiesbutton" type="button" value="Load" name="loadpropertiesbutton">
               <div id="savemapping" style="display:none">
                 Give current mapping a name and press Save:
                 <input type="text" name="mappingname" size="20" id="mappingname">
               </div>
-            </td>
-            <g:each var="selentity" in="${importer_selectedentities}">
-              <g:if test="${selentity.name.toLowerCase()==stdentity.entity.toLowerCase()}">
-                            <td class="header" width="200px">
-                                <b>${importer_header[selentity.columnindex.toInteger()].name}</b>
-                  <importer:propertyChooser name="columnproperty" mappingcolumn="${importer_header[selentity.columnindex.toInteger()]}" matchvalue="${importer_header[selentity.columnindex.toInteger()].name}" fuzzymatching="${importer_fuzzymatching}" template_id="${importer_template_id}" allfieldtypes="true"/>
-                            </td>                                       
+              <div id="loadmapping" style="display:none">
+                Select an existing mapping and press Load:
+                <g:select name="importmapping" from="${importer_importmappings}" optionValue="name"/>
+              </div>
+            </td>           
+            <g:each var="mappingcolumn" in="${importer_header}">
+              <g:if test="${importer_columnproperty}">
+                <g:set var="selected" value="${importer_columnproperty.index['' + mappingcolumn.index + '']}"/>
               </g:if>
+
+                          <td class="header" width="200px">
+                                <b>${mappingcolumn.name}</b>
+                  <importer:propertyChooser name="columnproperty" mappingcolumn="${mappingcolumn}" matchvalue="${mappingcolumn.name}" selected="${selected}" fuzzymatching="${importer_fuzzymatching}" template_id="${importer_template_id}" "allfieldtypes="true"/>
+                          </td>                                 
             </g:each>
                 </tr>
@@ -55 +61 @@
                 </tr>
                 </g:each>
-
-          <% }  %> <!-- end of JSP if-->
-          </g:each>
+          
     </table>