Merge pull request #56 from AyushDharDubey/fix/issue_54-add-delete-revision-feature

Adds `delete revision` option for admin

Author: lonvia

mainapp/database.py

@@ -158,23 +158,23 @@ def edit(options):
 
         return False
 
-def delete(model_id):
+def delete(model_id, revision=None):
     try:
         with transaction.atomic():
-            models = Model.objects.filter(model_id=model_id)
-            changes = Change.objects.filter(model__model_id=model_id)
+            if not revision:
+                models = Model.objects.filter(model_id=model_id)
+            else:
+                models = Model.objects.filter(model_id=model_id, revision=revision)
 
             if not models.exists():
                 logger.exception(None, 'Model does not exist.')
                 return False
-            
+
             for m in models:
-                path = '{}/{}'.format(settings.MODEL_DIR, m.model_id)
-                if os.path.exists(path):
-                    shutil.rmtree(path)
-            
-            changes.delete()
-            models.delete()
+                path = '{}/{}/{}.glb'.format(settings.MODEL_DIR, m.model_id, revision)
+                if os.path.isfile(path):
+                    os.remove(path)
+                m.delete()
 
             logger.info('Model deleted successfully.')
             return True

mainapp/models.py

@@ -105,6 +105,20 @@ def save(self, *args, **kwargs):
 
             super().save(*args, **kwargs)
 
+    def delete(self, *args, **kwargs):
+        with transaction.atomic():
+            if self.latest:
+                latest_model = Model.objects.filter(
+                    model_id=self.model_id
+                ).exclude(pk=self.pk).order_by('-revision').first()
+
+                # if self is not the last standing revision of the model
+                # assign the next revision as latest
+                if latest_model:
+                    latest_model.latest=True
+                    latest_model.save()
+            return super().delete(*args, **kwargs)
+
 class Change(models.Model):
     author = models.ForeignKey(User, models.CASCADE)
     model = models.ForeignKey(Model, models.CASCADE)

mainapp/templates/mainapp/model.html

@@ -129,7 +129,12 @@ <h3 class="panel-title">{{ model.title }}</h3>
 						<form action="{% url 'delete_model' %}" method="post" onsubmit="return confirmDeleteModel()">
 							{% csrf_token %}
 							<input type="hidden" name="model_id" value="{{ model.model_id }}">
+							{% if not latest_page %}
+							<input type="hidden" name="revision" value="{{ model.revision }}">
+							<button type="submit" class="btn btn-danger">Delete Revision</button>
+							{% else %}
 							<button type="submit" class="btn btn-danger">Delete Model</button>
+							{% endif %}
 						</form>
 					</p>
 					{% endif %}

mainapp/tests/test_database.py

@@ -381,8 +381,87 @@ def test_delete_model(self):
             Model.objects.get(pk=created_model.pk)
 
         expected_path = os.path.join(
-            settings.MODEL_DIR, str(created_model.model_id)
+            settings.MODEL_DIR, str(created_model.model_id), str(created_model.revision)
         )
         self.assertFalse(os.path.exists(expected_path), "Model file should be deleted")
 
         self.assertEqual(Change.objects.filter(model=created_model).count(), 0)
+
+    def test_delete_model_revision(self):
+        model_file = self._create_dummy_file()
+        options = {
+            "title": "Model to Delete",
+            "description": "This model will be deleted.",
+            "tags": {"delete": "yes"},
+            "categories": ["DeleteCat"],
+            "latitude": 20.0,
+            "longitude": 30.0,
+            "source": None,
+            "license": 8,
+            "author": self.user,
+            "translation": [0, 0, 0],
+            "rotation": 0,
+            "scale": 1,
+            "revision": False,
+        }
+
+        created_model = database.upload(model_file, options)
+        self.assertIsNotNone(created_model)
+
+        revision_options = {
+            "model_id": created_model.model_id,
+            "author": self.user,
+            "revision": True,
+        }
+        model_rev1 = database.upload(model_file, revision_options)
+        self.assertIsNotNone(model_rev1)
+        model_rev2 = database.upload(model_file, revision_options)
+        self.assertIsNotNone(model_rev2)
+
+        delete_result = database.delete(model_rev2.model_id, model_rev2.revision)
+        self.assertTrue(delete_result, "Delete should return True on success")
+
+        with self.assertRaises(Model.DoesNotExist):
+            Model.objects.get(pk=model_rev2.pk)
+
+        expected_path = os.path.join(
+            settings.MODEL_DIR, str(model_rev2.model_id), str(model_rev2.revision)
+        )
+        self.assertFalse(os.path.exists(expected_path), "Model file for revision 2 should be deleted")
+        
+        self.assertEqual(Change.objects.filter(model=model_rev2).count(), 0)
+
+        model_rev1.refresh_from_db()
+        self.assertTrue(model_rev1.latest)
+        created_model.refresh_from_db()
+        self.assertFalse(created_model.latest)
+
+        delete_result = database.delete(model_rev1.model_id, model_rev1.revision)
+        self.assertTrue(delete_result, "Delete should return True on success")
+
+        with self.assertRaises(Model.DoesNotExist):
+            Model.objects.get(pk=model_rev1.pk)
+
+        expected_path = os.path.join(
+            settings.MODEL_DIR, str(model_rev1.model_id), str(model_rev1.revision)
+        )
+        self.assertFalse(os.path.exists(expected_path), "Model file for revision 1 should be deleted")
+
+        self.assertEqual(Change.objects.filter(model=model_rev1).count(), 0)
+
+        created_model.refresh_from_db()
+        self.assertTrue(created_model.latest)
+
+        delete_result = database.delete(created_model.model_id, created_model.revision)
+        self.assertTrue(delete_result, "Delete should return True on success")
+
+        with self.assertRaises(Model.DoesNotExist):
+            Model.objects.get(pk=created_model.pk)
+
+        expected_path = os.path.join(
+            settings.MODEL_DIR, str(created_model.model_id), str(created_model.revision)
+        )
+        self.assertFalse(os.path.exists(expected_path), "Model file for revision 1 should be deleted")
+
+        self.assertEqual(Change.objects.filter(model=created_model).count(), 0)
+        self.assertEqual(Model.objects.filter(model_id=created_model.model_id).count(), 0)

mainapp/views.py

@@ -64,6 +64,7 @@ def model(request, model_id, revision=None):
 
     context = {
         'model': model,
+        'latest_page': revision is None,
         'license': LICENSES_DISPLAY[model.license]
     }
 
@@ -465,6 +466,7 @@ def delete_model(request):
         return redirect(index)
 
     model_id = request.POST.get('model_id')
+    revision = request.POST.get('revision')
 
     if not model_id:
         return HttpResponseBadRequest('Model ID is required.')
@@ -473,10 +475,16 @@ def delete_model(request):
         messages.error(request, 'You must be admin to use this feature.')
         return redirect(model, model_id=model_id)
 
-    m = get_object_or_404(Model, model_id=model_id, latest=True)
+    if not revision:
+        m = get_object_or_404(Model, model_id=model_id, latest=True)
+    else:
+        m = get_object_or_404(Model, model_id=model_id, revision=revision)
 
-    if database.delete(m.model_id):
-        messages.info(request, f'Model {m.title} deleted successfully.')
+    if database.delete(model_id, revision):
+        if revision:
+            messages.info(request, f'Model {m.title} ({m.revision}) deleted successfully.')
+        else:
+            messages.info(request, f'Model {m.title} deleted successfully.')
         return redirect(index)
     else:
         messages.error(request, 'An error occurred while deleting the model. Please try again later.')