Changeset 57102

Timestamp:

30/06/08 16:12:47 (2 months ago)

Author:

ischommer

Message:

FEATURE Using $columnMap and $hasHeaderRow in combination for CsvBulkLoader? class
BUGFIX More robust iteration over $columnMap in CsvBulkLoader?

Location:

modules/sapphire/branches/roa/tools

Files:

• BulkLoader.php (modified) (2 diffs)
• CsvBulkLoader.php (modified) (5 diffs)

modules/sapphire/branches/roa/tools/BulkLoader.php

@@ -6 +6 @@
  * You can configure column-handling, 
  * 
- * @todo Allow updating of existing records based on user-specified unique criteria/callbacks (e.g. database ID)
  * @todo Add support for adding/editing has_many relations.
  * @todo Add support for deep chaining of relation properties (e.g. Player.Team.Stats.GoalCount)
+ * @todo Character conversion
  * 
  * @see http://rfc.net/rfc4180.html
@@ -41 +41 @@
          * The column count should match the count of array elements,
          * fill with NULL values if you want to skip certain columns.
+         *
+         * You can also combine {@link $hasHeaderRow} = true and {@link $columnMap}
+         * and omit the NULL values in your map.
          * 
          * Supports one-level chaining of has_one relations and properties with dot notation

modules/sapphire/branches/roa/tools/CsvBulkLoader.php

@@ -39 +39 @@
                 
                 $return = new DataObjectSet();
-                
-                // assuming that first row is column naming if no columnmap is passed
+
                 if($this->hasHeaderRow && $this->columnMap) {
                         $columnRow = fgetcsv($file, 0, $this->delimiter, $this->enclosure);
-                        $columnMap = $this->columnMap;
+                        $columnMap = array();
+                        foreach($columnRow as $k => $origColumnName) {
+                                if(isset($this->columnMap[$origColumnName])) {
+                                        $columnMap[$origColumnName] = $this->columnMap[$origColumnName];
+                                } else {
+                                        $columnMap[$origColumnName] = null;
+                                }
+                                
+                        }
                 } elseif($this->columnMap) {
                         $columnMap = $this->columnMap;
                 } else {
+                        // assuming that first row is column naming if no columnmap is passed
                         $columnRow = fgetcsv($file, 0, $this->delimiter, $this->enclosure);
                         $columnMap = array_combine($columnRow, $columnRow);
                 }
                 
+                $rowIndex = 0;
                 while (($row = fgetcsv($file, 0, $this->delimiter, $this->enclosure)) !== FALSE) {
-                        $indexedRow = array_combine(array_values($columnMap), array_values($row));
+                        $rowIndex++;
+                        
+                        /*
+                        // the columnMap should have the same amount of columns as each record row
+                        if(count(array_keys($columnMap)) == count(array_values($row))) {
+                                user_error("CsvBulkLoader::processAll(): Columns in row {$rowIndex} don't match the \$columnMap", E_USER_WARNING);
+                        }
+                        */
+                        
+                        $indexedRow = array();
+                        foreach($columnMap as $origColumnName => $fieldName) {
+                                // in case the row has less fields than the columnmap,
+                                // ignore the "leftover" mappings
+                                if(!isset($row[count($indexedRow)])) {
+                                                user_error("CsvBulkLoader::processAll(): Columns in row {$rowIndex} don't match the \$columnMap", E_USER_NOTICE);
+                                        continue;
+                                }
+        
+                                $indexedRow[$origColumnName] = $row[count($indexedRow)];
+                        }
+
                         $return->push($this->processRecord($indexedRow, $columnMap));
                 }
@@ -71 +100 @@
                 // we can't combine runs, as other columns might rely on the relation being present
                 $relations = array();
-                foreach($record as $key => $val) {
+                foreach($record as $origColumnName => $val) {
+                        $fieldName = $columnMap[$origColumnName];
+                        
                         // don't bother querying of value is not set
                         if($this->isNullValue($val)) continue;
                         
                         // checking for existing relations
-                        if(isset($this->relationCallbacks[$key])) {
+                        if(isset($this->relationCallbacks[$fieldName])) {
                                 // trigger custom search method for finding a relation based on the given value
                                 // and write it back to the relation (or create a new object)
-                                $relationName = $this->relationCallbacks[$key]['relationname'];
-                                $relationObj = $obj->{$this->relationCallbacks[$key]['callback']}($val, $record);
+                                $relationName = $this->relationCallbacks[$fieldName]['relationname'];
+                                $relationObj = $obj->{$this->relationCallbacks[$fieldName]['callback']}($val, $record);
                                 if(!$relationObj || !$relationObj->exists()) {
                                         $relationClass = $obj->has_one($relationName);
@@ -89 +120 @@
                                 $obj->{"{$relationName}ID"} = $relationObj->ID;
                                 $obj->write();
-                        } elseif(strpos($key, '.') !== false) {
+                        } elseif(strpos($fieldName, '.') !== false) {
                                 // we have a relation column with dot notation
-                                list($relationName,$columnName) = split('\.', $key);
+                                list($relationName,$columnName) = split('\.', $fieldName);
                                 $relationObj = $obj->getComponent($relationName); // always gives us an component (either empty or existing)
                                 $obj->setComponent($relationName, $relationObj);
@@ -103 +134 @@
                 $id = ($preview) ? 0 : $obj->write();
 
-                
                 // second run: save data
-                foreach($record as $key => $val) {
-                        if($this->isNullValue($val, $key)) continue;
-                        
-                        if($obj->hasMethod("import{$key}")) {
-                                $obj->{"import{$key}"}($val, $record);
-                        } elseif(strpos($key, '.') !== false) {
+                foreach($record as $origColumnName => $val) {
+                        $fieldName = $columnMap[$origColumnName];
+
+                        if($this->isNullValue($val, $fieldName)) continue;
+
+                        if($obj->hasMethod("import{$fieldName}")) {
+                                $obj->{"import{$fieldName}"}($val, $record);
+                        } elseif(strpos($fieldName, '.') !== false) {
                                 // we have a relation column
-                                list($relationName,$columnName) = split('\.', $key);
+                                list($relationName,$columnName) = split('\.', $fieldName);
                                 $relationObj = $obj->getComponent($relationName);
                                 $relationObj->{$columnName} = $val;
                                 $relationObj->write();
                                 $obj->flushCache(); // avoid relation caching confusion
-                        } elseif($obj->hasField($key) || $obj->hasMethod($key)) {
+                        //} elseif($obj->hasField($fieldName) || $obj->hasMethod($fieldName)) {
+                        } else {
                                 // plain old value setter
-                                $obj->{$key} = $val;
+                                $obj->{$fieldName} = $val;
                         }
                 }
@@ -150 +183 @@
                         if(is_string($duplicateCheck)) {
                                 $SQL_fieldName = Convert::raw2sql($duplicateCheck); 
-                                $SQL_fieldValue = $record[$columnMap[$fieldName]];
+
+                                if(!isset($record[$fieldName])) {
+                                        user_error("CsvBulkLoader:processRecord: Couldn't find duplicate identifier '{$fieldName}' in columns", E_USER_ERROR);
+                                }
+                                $SQL_fieldValue = $record[$fieldName];
                                 $existingRecord = DataObject::get_one($this->objectClass, "`$SQL_fieldName` = '{$SQL_fieldValue}'");
                                 if($existingRecord) return $existingRecord;
                         } elseif(is_array($duplicateCheck) && isset($duplicateCheck['callback'])) {
-                                $existingRecord = singleton($this->objectClass)->{$duplicateCheck['callback']}($val, $record);
+                                $existingRecord = singleton($this->objectClass)->{$duplicateCheck['callback']}($record[$fieldName], $record);
                                 if($existingRecord) return $existingRecord;
                         } else {