Org delete to delete children first

Author: snyaggarwal

core/common/models.py

@@ -176,6 +176,11 @@ def batch_index(queryset, document):
             offset = limit
             limit += batch_size
 
+    @staticmethod
+    def batch_delete(queryset):
+        for batch in queryset.iterator(chunk_size=200):
+            batch.delete()
+
 
 class CommonLogoModel(models.Model):
     logo_path = models.TextField(null=True, blank=True)

core/common/tasks.py

@@ -22,23 +22,18 @@ def delete_organization(org_id):
     from core.orgs.models import Organization
     logger.info('Finding org...')
 
-    queryset = Organization.objects.filter(id=org_id)
+    org = Organization.objects.filter(id=org_id).first()
 
-    if not queryset.exists():
+    if not org:
         logger.info('Not found org %s', org_id)
         return
 
-    org = queryset.first()
-
     try:
         logger.info('Found org %s.  Beginning purge...', org.mnemonic)
-        queryset.delete()  # not using org.delete() to use django's bulk delete
-        from core.pins.models import Pin
-        Pin.objects.filter(resource_type__model='organization', resource_id=org.id).delete()
-        from core.client_configs.models import ClientConfig
-        ClientConfig.objects.filter(resource_type__model='organization', resource_id=org.id).delete()
+        org.delete()
         logger.info('Purge complete!')
     except Exception as ex:
+        print("****", ex)
         logger.info('Org delete failed for %s with exception %s', org.mnemonic, ex.args)
 
 
@@ -415,8 +410,9 @@ def delete_dormant_locales():  # pragma: no cover
 def delete_concept(concept_id):  # pragma: no cover
     from core.concepts.models import Concept
 
-    concept = Concept.objects.filter(id=concept_id).first()
-    concept.delete()
+    queryset = Concept.objects.filter(id=concept_id)
+    if queryset.exists():
+        queryset.delete()
 
     return 1
 

core/orgs/models.py

@@ -1,7 +1,7 @@
 from django.contrib import admin
 from django.contrib.contenttypes.fields import GenericRelation
 from django.core.validators import RegexValidator
-from django.db import models
+from django.db import models, transaction
 
 from core.client_configs.models import ClientConfig
 from core.common.constants import NAMESPACE_REGEX, ACCESS_TYPE_VIEW, ACCESS_TYPE_EDIT
@@ -15,7 +15,6 @@ class Meta:
         db_table = 'organizations'
         indexes = [] + BaseResourceModel.Meta.indexes
 
-
     OBJECT_TYPE = ORG_OBJECT_TYPE
     es_fields = {
         'name': {'sortable': True, 'filterable': True, 'exact': True},
@@ -71,5 +70,29 @@ def save(self, force_insert=False, force_update=False, using=None, update_fields
             if self.updated_by_id:
                 self.members.add(self.updated_by)
 
+    def delete(self, using=None, keep_parents=False):
+        with transaction.atomic():
+            for source in self.source_set.all():
+                self.batch_delete(source.concepts_set)
+                self.batch_delete(source.mappings_set)
+                source.delete()
+            for collection in self.collection_set.all():
+                self.batch_delete(collection.references)
+                collection.delete()
+            self.delete_pins()
+            self.delete_client_configs()
+
+            return super().delete(using=using, keep_parents=keep_parents)
+
+    def delete_client_configs(self):
+        ClientConfig.objects.filter(resource_type__model='organization', resource_id=self.id).delete()
+
+    def delete_pins(self):
+        from core.pins.models import Pin
+        # deletes pins where org is pinned
+        Pin.objects.filter(resource_type__model='organization', resource_id=self.id).delete()
+        # deletes pins for this org
+        self.pins.all().delete()
+
 
 admin.site.register(Organization)

core/orgs/tests/tests.py

@@ -1,12 +1,18 @@
 from django.core.exceptions import ValidationError
 from mock import patch, Mock
 
+from core.collections.models import Collection, CollectionReference
 from core.common.constants import ACCESS_TYPE_NONE, HEAD
 from core.common.tasks import delete_organization
 from core.common.tests import OCLTestCase
+from core.concepts.models import Concept
+from core.concepts.tests.factories import ConceptFactory
+from core.mappings.models import Mapping
+from core.mappings.tests.factories import MappingFactory
 from core.orgs.constants import ORG_OBJECT_TYPE
 from core.orgs.models import Organization
 from core.orgs.tests.factories import OrganizationFactory
+from core.sources.models import Source
 from core.sources.tests.factories import OrganizationSourceFactory
 from core.collections.tests.factories import OrganizationCollectionFactory
 from core.users.tests.factories import UserProfileFactory
@@ -124,7 +130,20 @@ def test_org_active_inactive_should_affect_children(self):
         self.assertTrue(collection.is_active)
 
     def test_delete_organization_task(self):
-        org = OrganizationFactory()
+        org = OrganizationFactory(mnemonic='to-be-deleted-org')
+        source = OrganizationSourceFactory(mnemonic='to-be-deleted-source', organization=org)
+        collection = OrganizationCollectionFactory(mnemonic='to-be-deleted-coll', organization=org)
+        concept = ConceptFactory(mnemonic='to-be-deleted-concept', parent=source)
+        mapping = MappingFactory(mnemonic='to-be-deleted-mapping', parent=source)
+        collection.add_references([concept.uri, mapping.uri])
+
+        self.assertEqual(org.source_set.count(), 1)
+        self.assertEqual(org.collection_set.count(), 1)
+        self.assertEqual(source.concepts_set.count(), 2)
+        self.assertEqual(source.mappings_set.count(), 2)
+        self.assertEqual(collection.references.count(), 2)
+        self.assertEqual(collection.concepts.count(), 1)
+        self.assertEqual(collection.mappings.count(), 1)
 
         delete_organization(0)
 
@@ -133,6 +152,11 @@ def test_delete_organization_task(self):
         delete_organization(org.id)
 
         self.assertFalse(Organization.objects.filter(id=org.id).exists())
+        self.assertFalse(Source.objects.filter(mnemonic='to-be-deleted-source').exists())
+        self.assertFalse(Collection.objects.filter(mnemonic='to-be-deleted-coll').exists())
+        self.assertFalse(Concept.objects.filter(mnemonic='to-be-deleted-concept').exists())
+        self.assertFalse(Mapping.objects.filter(mnemonic='to-be-deleted-mapping').exists())
+        self.assertEqual(CollectionReference.objects.count(), 0)
 
     def test_logo_url(self):
         self.assertIsNone(Organization(logo_path=None).logo_url)