软删除模型不符合预期

# 软删除模型不符合预期

首先向 **dvadmin开发组** 表达深深的敬意，dvadmin3项目以其优雅的设计和强大的功能让无数开发者受益。但在使用的过程中，我发现有一些值得注意的地方。

模型`AppUser`同时继承`CoreModel`和`SoftDeleteModel`，在访问字段`is_deleted`后，`filter`方法行为不符合预期。

![截图](https://foruda.gitee.com/images/1751996270568043348/85a293ed_9594642.png "屏幕截图")

# 相关代码

代码位于`backend/dvadmin/utils/models.py`，如下

``` python

class SoftDeleteManager(models.Manager):
    """支持软删除"""

def __init__(self, *args, **kwargs):
        self.__add_is_del_filter = False
        super(SoftDeleteManager, self).__init__(*args, **kwargs)

def filter(self, *args, **kwargs):
        # 考虑是否主动传入is_deleted
        if not kwargs.get('is_deleted') is None:
            self.__add_is_del_filter = True
        return super(SoftDeleteManager, self).filter(*args, **kwargs)

def get_queryset(self):
        if self.__add_is_del_filter:
            return SoftDeleteQuerySet(self.model, using=self._db).exclude(is_deleted=False)
        return SoftDeleteQuerySet(self.model).exclude(is_deleted=True)

def get_by_natural_key(self, name):
        return SoftDeleteQuerySet(self.model).get(username=name)

```

在`filter`方法中，当传入的参数`kwargs`中包含`is_deleted`（无论其值是`True`还是`False`）时，就会将`__add_is_del_filter`设置为`True`。然后在`get_queryset`中，如果`__add_is_del_filter`为`True`，就返回`exclude(is_deleted=False)`，即已删除的对象

# 级联数据安全

在`SoftDeletedModel`中，`delete`方法重写为

```python
    def delete(self, using=None, soft_delete=True, *args, **kwargs):
        """
        重写删除方法,直接开启软删除
        """
        if soft_delete:
            self.is_deleted = True
            self.save(using=using)
            # 级联软删除关联对象
            for related_object in self._meta.related_objects:
                related_model = getattr(self, related_object.get_accessor_name())
                # 处理一对多和多对多的关联对象
                if related_object.one_to_many or related_object.many_to_many:
                    related_objects = related_model.all()
                elif related_object.one_to_one:
                    related_objects = [related_model]
                else:
                    continue

for obj in related_objects:
                    obj.delete(soft_delete=True)
        else:
            super().delete(using=using, *args, **kwargs)

```

注意到代码没有限制`on_delete=CASCADE`的外键关系。

# 修复建议

``` python
class SoftDeleteQuerySet(models.QuerySet):
    """
    软删除QuerySet
    """

def delete(self):
        """批量软删除"""
        return self.update(is_deleted=True, deleted_at=timezone.now())

def hard_delete(self):
        """批量物理删除"""
        return super().delete()

def alive(self):
        """只返回未删除的对象"""
        return self.filter(is_deleted=False)

def dead(self):
        """只返回已删除的对象"""
        return self.filter(is_deleted=True)

def all_objects(self):
        """返回所有对象（包括已删除）"""
        return self

class SoftDeleteManager(models.Manager):
    """
    软删除管理器
    """

def get_queryset(self):
        """默认只返回未删除对象"""
        return SoftDeleteQuerySet(self.model).filter(is_deleted=False)

def all_objects(self):
        """返回所有对象（包含已删除）"""
        return SoftDeleteQuerySet(self.model)

def deleted(self):
        """只返回已删除对象"""
        return self.all_objects().filter(is_deleted=True)

def get_by_natural_key(self, name):
        """按自然键获取对象（只获取未删除的）"""
        return self.get(username=name)

class SoftDeleteModel(models.Model):
    is_deleted = models.BooleanField(
        verbose_name="是否软删除", help_text="是否软删除", default=False, db_index=True
    )
    deleted_at = models.DateTimeField(
        verbose_name="删除时间", null=True, blank=True, db_index=True
    )
    objects = SoftDeleteManager()

class Meta:
        abstract = True

def delete(self, using=None, soft_delete=True):
        """
        重写删除方法
        :param soft_delete: 是否软删除 (默认为True)
        """
        if soft_delete:
            self.is_deleted = True
            self.deleted_at = timezone.now()

update_fields = ["is_deleted", "deleted_at"]
            if hasattr(self, "update_datetime"):
                self.update_datetime = timezone.now()
                update_fields.append("update_datetime")

self.save(update_fields=update_fields)

self._cascade_soft_delete()
        else:
            super().delete(using=using)

def _cascade_soft_delete(self):
        """
        级联软删除关联对象
        - 只处理设置了 on_delete=models.CASCADE 的关系
        - 跳过多对多关系（只解除关系，不删除对象）
        """
        for related in self._meta.related_objects:
            if related.on_delete != models.CASCADE:
                continue

accessor_name = related.get_accessor_name()

if not hasattr(self, accessor_name):
                continue
            related_manager = getattr(self, accessor_name)

if related.one_to_many or related.one_to_one:
                if hasattr(related_manager, "all"):
                    related_manager.all().delete()
                else:
                    related_manager.delete()

elif related.many_to_many:
                related_manager.clear()

def restore(self):
        """
        恢复软删除的对象
        """
        if not self.is_deleted:
            return

self.is_deleted = False
        self.deleted_at = None

update_fields = ["is_deleted", "deleted_at"]
        if hasattr(self, "update_datetime"):
            self.update_datetime = timezone.now()
            update_fields.append("update_datetime")

self.save(update_fields=update_fields)

```

# 修复结果

![修复后](https://foruda.gitee.com/images/1752002812486833301/c6274b38_9594642.png "屏幕截图")
![验证](https://foruda.gitee.com/images/1752002997396693837/1eeaccaf_9594642.png "屏幕截图")

huge-dream/django-vue3-admin

内容风险标识

评论 (0)

huge-dream/django-vue3-admin .gitee-modal { width: 500px !important; }

内容风险标识