ADD support for deleting objects during import

Author: bmihelac

docs/changelog.rst

@@ -5,6 +5,8 @@ Change Log
 0.1.2 (not released)
 ====================
 
+* support for deleting objects during import
+
 * bug fixes
 
 * Allowing a field to be 'dehydrated' with a custom method

docs/getting_started.rst

@@ -203,6 +203,26 @@ check for any errors and import data.
     :doc:`/import_workflow`
         for detailed import workflow descripton and customization options.
 
+Deleting data
+^^^^^^^^^^^^^
+
+To delete objects during import, implement ``for_delete`` method on resource
+class.
+
+Example resource with ``delete`` field::
+
+    class BookResource(resources.ModelResource):
+        delete = fields.Field(widget=widgets.BooleanWidget())
+
+        def for_delete(self, row, instance):
+            return self.fields['delete'].clean(row)
+        
+        class Meta:
+            model = Book
+
+Import of this resource will delete model instances for rows
+that have column ``delete`` set to ``1``.
+
 Admin integration
 -----------------
 

docs/import_workflow.rst

@@ -57,38 +57,45 @@ responsible for import data from given `dataset`.
       arguments. You can override ``init_instance`` method to manipulate how
       new objects are initialized (ie: to set default values).
 
-   #. ``import_obj`` method is called with current object `instance` and
-      current `row`.
-
-      ``import_obj`` loop through all `Resource` `fields`, skipping
-      many to many fields and calls ``import_field`` for each. (Many to many
-      fields require that instance have a primary key, this is why assigning
-      them is postponed, after object is saved).
-
-      ``import_field`` calls ``field.save`` method, if ``field`` has
-      both `attribute` and field `column_name` exists in given row.
-
-   #. ``save_instance`` method is called.
-
-      ``save_instance`` receives ``dry_run`` argument and actually saves
-      instance only when ``dry_run`` is False.
-
-      ``save_instance`` calls two hooks methods that by default does not
-      do anything but can be overriden to customize import process:
-
-      * ``before_save_instance``
-
-      * ``after_save_instance``
-
-      Both methods receive ``instance`` and ``dry_run`` arguments.
-
-   #. ``save_m2m`` method is called to save many to many fields.
-
+   #. ``for_delete`` method is called to determine if current `instance`
+      should be deleted:
+
+      #. current `instance` is deleted
+ 
+      OR
+ 
+      #. ``import_obj`` method is called with current object `instance` and
+         current `row`.
+ 
+         ``import_obj`` loop through all `Resource` `fields`, skipping
+         many to many fields and calls ``import_field`` for each. (Many to many
+         fields require that instance have a primary key, this is why assigning
+         them is postponed, after object is saved).
+ 
+         ``import_field`` calls ``field.save`` method, if ``field`` has
+         both `attribute` and field `column_name` exists in given row.
+ 
+      #. ``save_instance`` method is called.
+ 
+         ``save_instance`` receives ``dry_run`` argument and actually saves
+         instance only when ``dry_run`` is False.
+ 
+         ``save_instance`` calls two hooks methods that by default does not
+         do anything but can be overriden to customize import process:
+ 
+         * ``before_save_instance``
+ 
+         * ``after_save_instance``
+ 
+         Both methods receive ``instance`` and ``dry_run`` arguments.
+ 
+      #. ``save_m2m`` method is called to save many to many fields.
+ 
    #. ``RowResult`` is assigned with diff between original and imported
-      object fields as well as import type(new, updated).
-
-      If exception is raised inside row processing, and ``raise_errors`` is
-      ``False`` (default), traceback is appended to ``RowResult``.
+       object fields as well as import type(new, updated).
+ 
+       If exception is raised inside row processing, and ``raise_errors`` is
+       ``False`` (default), traceback is appended to ``RowResult``.
 
 #. ``result`` is returned.
 

docs/todo.rst

@@ -2,8 +2,6 @@
 TODO
 ====
 
-* support for deleting objects for importing data
-
 * DB transactions support for importing data
 
 * support for exporting multiple formats in admin integration

import_export/resources.py

@@ -129,6 +129,24 @@ def after_save_instance(self, instance, dry_run):
         """
         pass
 
+    def delete_instance(self, instance, dry_run=False):
+        self.before_delete_instance(instance, dry_run)
+        if not dry_run:
+            instance.delete()
+        self.after_delete_instance(instance, dry_run)
+
+    def before_delete_instance(self, instance, dry_run):
+        """
+        Override to add additional logic.
+        """
+        pass
+
+    def after_delete_instance(self, instance, dry_run):
+        """
+        Override to add additional logic.
+        """
+        pass
+
     def import_field(self, field, obj, data):
         if field.attribute and field.column_name in data:
             field.save(obj, data)
@@ -154,6 +172,15 @@ def save_m2m(self, obj, data, dry_run):
                     continue
                 self.import_field(field, obj, data)
 
+    def for_delete(self, row, instance):
+        """
+        Returns ``True`` if ``row`` importing should delete instance.
+
+        Default implementation returns ``False``.
+        Override this method to handle deletion.
+        """
+        return False
+
     def get_diff(self, original, current, dry_run=False):
         """
         Get diff between original and current object when ``import_data``
@@ -165,8 +192,8 @@ def get_diff(self, original, current, dry_run=False):
         data = []
         dmp = diff_match_patch()
         for field in self.get_fields():
-            v1 = self.export_field(field, original)
-            v2 = self.export_field(field, current)
+            v1 = self.export_field(field, original) if original else ""
+            v2 = self.export_field(field, current) if current else ""
             diff = dmp.diff_main(unicode(v1), unicode(v2))
             dmp.diff_cleanupSemantic(diff)
             html = dmp.diff_prettyHtml(diff)
@@ -193,10 +220,21 @@ def import_data(self, dataset, dry_run=False, raise_errors=False):
                     row_result.import_type = RowResult.IMPORT_TYPE_UPDATE
                 row_result.new_record = new
                 original = deepcopy(instance)
-                self.import_obj(instance, row)
-                self.save_instance(instance, dry_run)
-                self.save_m2m(instance, row, dry_run)
-                row_result.diff = self.get_diff(original, instance, dry_run)
+                if self.for_delete(row, instance):
+                    if new:
+                        row_result.import_type = RowResult.IMPORT_TYPE_SKIP
+                        row_result.diff = self.get_diff(None, None, dry_run)
+                    else:
+                        row_result.import_type = RowResult.IMPORT_TYPE_DELETE
+                        self.delete_instance(instance, dry_run)
+                        row_result.diff = self.get_diff(original, None,
+                                dry_run)
+                else:
+                    self.import_obj(instance, row)
+                    self.save_instance(instance, dry_run)
+                    self.save_m2m(instance, row, dry_run)
+                    row_result.diff = self.get_diff(original, instance,
+                            dry_run)
             except Exception, e:
                 tb_info = traceback.format_exc(sys.exc_info()[2])
                 row_result.errors.append(Error(repr(e), tb_info))

import_export/results.py

@@ -9,6 +9,7 @@ class RowResult(object):
     IMPORT_TYPE_UPDATE = 'update'
     IMPORT_TYPE_NEW = 'new'
     IMPORT_TYPE_DELETE = 'delete'
+    IMPORT_TYPE_SKIP = 'skip'
 
     def __init__(self):
         self.errors = []

import_export/templates/admin/import_export/import.html

@@ -95,6 +95,8 @@ <h2>
       <td>
         {% if row.import_type == 'new' %}
           {% trans "New" %}
+        {% elif row.import_type == 'skip' %}
+          {% trans "Skipped" %}
         {% elif row.import_type == 'delete' %}
           {% trans "Delete" %}
         {% elif row.import_type == 'update' %}

tests/core/tests/resources_tests.py

@@ -143,6 +143,22 @@ def test_import_data_error_saving_model(self):
         msg = 'ValueError("invalid literal for int() with base 10: \'foo\'",)'
         self.assertTrue(result.rows[0].errors[0].error, msg)
 
+    def test_import_data_delete(self):
+
+        class B(BookResource):
+            delete = fields.Field(widget=widgets.BooleanWidget())
+
+            def for_delete(self, row, instance):
+                return self.fields['delete'].clean(row)
+
+        row = [self.book.pk, self.book.name, '1']
+        dataset = tablib.Dataset(*[row], headers=['id', 'name', 'delete'])
+        result = B().import_data(dataset, raise_errors=True)
+        self.assertFalse(result.has_errors())
+        self.assertEqual(result.rows[0].import_type,
+                results.RowResult.IMPORT_TYPE_DELETE)
+        self.assertFalse(Book.objects.filter(pk=self.book.pk))
+
     def test_relationships_fields(self):
 
         class B(resources.ModelResource):