Changeset 1093 for trunk

Timestamp:

Nov 6, 2010, 4:01:11 PM (10 years ago)

Author:

t.w.abma@…

Message:

• failed cells correction now implemented in an extra step which allows the user to specify a corrected ontology value

Location:

trunk/grails-app

Files:

• controllers/dbnp/importer/ImporterController.groovy (modified) (4 diffs)
• services/dbnp/importer/ImporterService.groovy (modified) (4 diffs)
• views/importer/common/_failedcells.gsp (modified) (1 diff)

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

@@ -154 +154 @@
      * the original value which was read from the Excel file.
      *
-     * @param cell array of cells with updated ontologies
+     * @param cell array of cells with corrected cells (ontologies)
      * 
     */
@@ -161 +161 @@
 
         // Loop through the form with cell fields and values
-        params.cell.index.each { cellhashcode, value ->
-            correctedcells.put(cellhashcode, value)
+        params.cell.index.each { mappingcolumnhash, value ->
+            correctedcells.put(mappingcolumnhash, value)
         }
 
@@ -168 +168 @@
         ImporterService.saveCorrectedCells(
                     session.importer_importeddata,
-                    session.imported_failedcells,
+                    session.importer_failedcells,
                     correctedcells)
 
@@ -290 +290 @@
         }
 
-        //import workbook and store it in a session
-        session.importer_importeddata = ImporterService.importData(session.importer_template_id, session.importer_workbook, session.importer_sheetindex, session.importer_datamatrix_start, session.importer_header)
-
-        // First handle the "failed cells"
-        session.imported_failedcells = ImporterService.getFailedCells(session.importer_importeddata)
-
-        //render(view:"step2a_simple", model:[failedcells:session.imported_failedcells])
-
-        if (params.layout=="horizontal")
+        // Import the workbook and store the table with entity records and store the failed cells
+        def (table, failedcells) = ImporterService.importData(session.importer_template_id, session.importer_workbook, session.importer_sheetindex, session.importer_datamatrix_start, session.importer_header)
+
+        session.importer_importeddata = table        
+        session.importer_failedcells = failedcells
+
+        render(view:"step2a_simple", model:[failedcells:session.importer_failedcells])
+
+        /*if (params.layout=="horizontal")
             render(view:"step3_simple", model:[datamatrix:session.importer_importeddata])
         else if (params.layout=="vertical")
-            render(view:"step3", model:[datamatrix:session.importer_importeddata])
+            render(view:"step3", model:[datamatrix:session.importer_importeddata])*/
     }
 

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

@@ -219 +219 @@
         def sheet = wb.getSheetAt(sheetindex)
         def table = []
+        def failedcells = [:] // map [recordhash, [mappingcolumnlist]] values
         
         // walk through all rows and fill the table with records
         (rowindex..sheet.getLastRowNum()).each { i ->
-            table.add(createRecord(template_id, sheet.getRow(i), mcmap))
+            //table.add(createRecord(template_id, sheet.getRow(i), mcmap))
+            // Create an entity record based on a row read from Excel and store the cells which failed to be mapped
+            def (record, failed) = createRecord(template_id, sheet.getRow(i), mcmap)
+
+            // Add record with entity and its values to the table
+            table.add(record)
+
+            // If failed cells have been found, add them to the failed cells map
+            // the record hashcode is later on used to put the failed data back
+            // in the data matrix
+            if (failed.size()!=0) failedcells.put(record.hashCode(), failed)
         }
-        return table    
-    }
-
-    /** Method to extract failed cells from the datamatrix. Failed cells are cell values
+
+        failedcells.each { record ->
+           record.each { cell ->
+               cell.each {
+                   println it.value.dump()
+               }
+            }
+        }
+
+
+        return [table,failedcells]
+    }
+
+    /** Method to put failed cells back into the datamatrix. Failed cells are cell values
      * which could not be stored in an entity (e.g. Humu Supiuns in an ontology field).
+     * Empty corrections should not be stored
      *
      * @param datamatrix two dimensional array containing entities and possibly also failed cells
-     * @return array of failed cells in [mappingcolumn, cell] format
-     * */
-    def getFailedCells(datamatrix) {
-       def failedcells = []
-       
-       datamatrix.each { record ->
-            record.each { column ->
-                column.each {                    
-                    if (it.getClass().getName().equals('java.util.LinkedHashMap$Entry')) {                        
-                        failedcells.add(it)
-                    }
-                }
-            }
-        }
-
-        return failedcells
-    }
-
-    /** Method to put failed cells back into the datamatrix. Failed cells are cell values
-     * which could not be stored in an entity (e.g. Humu Supiuns in an ontology field).
-     *
-     * @param datamatrix two dimensional array containing entities and possibly also failed cells
-     * @param failedcells map of failed cells in [mappingcolumn, cell] format
-     * @param correctedcells map of corrected cells
+     * @param failedcells list with maps of failed cells in [mappingcolumn, cell] format
+     * @param correctedcells map of corrected cells in [cellhashcode, value] format
      **/
-    def saveCorrectedCells(datamatrix, failedcells, correctedcells) {
-        /*failedcells.each {
-            println it
-        }*/
-        def newdatamatrix = []
-
-        // Remove failed cells 'entity' / clean up datamatrix
-        datamatrix.each { record ->
-            def newrecord = []
-
-            record.each { entity ->
-              // LinkedHashMap means a "mappingcolumn:cell" object is inside the record (= failed to map to entity)
-              if (!entity.getClass().getName().equals('java.util.LinkedHashMap'))
-              newrecord.add(entity)
-            }
-
-            newdatamatrix.add(newrecord)
-        }
-
-        newdatamatrix.each { record ->
-            record.each { entity ->
-                entity.giveFields().each { field ->
-                    println "das"+ field
-                }
-            }
-        }
-
-        println "-----"
-        correctedcells.each {
-            println it.dump()
-        }
+    def saveCorrectedCells(datamatrix, failedcells, correctedcells) {       
+        // Loop through all failed cells
+        failedcells.each { mcrecord ->
+            mcrecord.each { mappingcolumn ->
+                  // Get the corrected value
+                  def correctedvalue = correctedcells.find { it.key.toInteger() == mappingcolumn.hashCode()}.value
+
+                  // Find the record in the table which the mappingcolumn belongs to
+                  def tablerecord = datamatrix.find { it.hashCode() == mcrecord.key }
+                  
+                  // Loop through all entities in the record
+                  tablerecord.each { rec ->
+                      rec.each { entity ->                          
+                            try {
+                                // Update the entity field
+                                entity.setFieldValue(mappingcolumn.value.property[0], correctedvalue)
+                                println "Adjusted " + mappingcolumn.value.property[0] + " to " + correctedvalue
+                            }
+                            catch (Exception e) {
+                                println "Could not map corrected ontology"
+                            }
+                      }
+                  } // end of table record
+            } // end of mapping record
+        } // end of failed cells loop
     }
    
@@ -347 +341 @@
 
     /**
-     * Check whether an entity already exists within a study. A combination of
-     * the study where the entity will be stored and a unique field in the entity is
+     * Check whether an entity already exist. A unique field in the entity is
      * used to check whether the instantiated entity (read from Excel) is new.
-     * If the entity is found in the database it will be returned as so and
-     * it should update the entity-values (read from Ecel) into the record in the database.
+     * If the entity is found in the database it will be returned as is.
      *
      * @param entity entity object like a Study, Subject, Sample et cetera
@@ -428 +420 @@
          * @param excelrow POI based Excel row containing the cells
          * @param mcmap map containing MappingColumn objects
+         * @return list of entities and list of failed cells
          */
         def createRecord(template_id, Row excelrow, mcmap) {
                 def df = new DataFormatter()
                 def template = Template.get(template_id)
-                def record = []
-                def failed = [:]
+                def record = [] // list of entities and the read values
+                def failed = [] // list of failed columns [mappingcolumn] with the value which couldn't be mapped into the entity
 
                 // Initialize all possible entities with the chosen template
@@ -480 +473 @@
                                     } // end switch
                                 } catch (IllegalArgumentException iae) {
-                                    // store the mapping column and the cell in an array
-                                    failed.put(mc, cell)
-                                    //println "failed ("+mc.templatefieldtype+"`" + value + "`"
+                                    // store the mapping column and value which failed
+                                    def temp = new MappingColumn()
+                                    temp.properties = mc.properties
+                                    temp.value = value                                    
+                                    failed.add(temp)
                                 }
                         } // end
                 } // end for
-
-        // add the failed columns to the record (might also be just an empty map if nothing failed)
-        // a failed column means that using the entity.setFieldValue() threw an exception
-        //record.add(failed)
-        return record
+        
+        // a failed column means that using the entity.setFieldValue() threw an exception        
+        return [record, failed]        
     }
 

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

@@ -32 +32 @@
 <g:form name="failedcellsform" action="saveCorrectedCells">
         <g:each var="record" in="${failedcells}">
-          <tr>
-            <td>${record.key.name}</td>
-            <td>${record.value.getRowIndex()}</td>
-            <td>${record.value}</td>
-            <td>
-                <input type="text" name="cell.index.${record.value.hashCode()}" rel="ontology-all-name"/>
-                <!-- <input type="hidden" name="cell.index.${record.value}-concept_id"/>
-                <input type="hidden" name="cell.index.${record.value}-ontology_id"/>
-                <input type="hidden" name="cell.index.${record.value}-full_id"/> -->
-            </td>
-          </tr>
+          <g:each var="list" in="${record}">
+            <g:each var="cell" in="${list}">
+            <tr>
+              <td>${cell.value.name}</td>
+              <td>-</td>
+              <td>${cell.value.value}</td>
+              <td>
+                  <input type="text" name="cell.index.${cell.hashCode()}" rel="ontology-all-name"/>
+                  <!-- <input type="hidden" name="cell.index.${cell.value}-concept_id"/>
+                  <input type="hidden" name="cell.index.${cell.value}-ontology_id"/>
+                  <input type="hidden" name="cell.index.${cell.value}-full_id"/> -->
+              </td>
+            </tr>
+            </g:each>
+          </g:each>
         </g:each>
   <tr>