36

在我的应用程序中，我需要在保存模型时保存更改的值（旧的和新的）。任何示例或工作代码？

我需要这个来预先审核内容。例如，如果用户更改模型中的某些内容，那么管理员可以在单独的表中查看所有更改，然后决定是否应用它们。

4

10 回答 10

24

我发现 Armin 的想法非常有用。这是我的变体；

class DirtyFieldsMixin(object):
    def __init__(self, *args, **kwargs):
        super(DirtyFieldsMixin, self).__init__(*args, **kwargs)
        self._original_state = self._as_dict()

    def _as_dict(self):
        return dict([(f.name, getattr(self, f.name)) for f in self._meta.local_fields if not f.rel])

    def get_dirty_fields(self):
        new_state = self._as_dict()
        return dict([(key, value) for key, value in self._original_state.iteritems() if value != new_state[key]])

编辑：我已经测试过这个 BTW。

很抱歉排长队。不同之处在于（除了名称）它只缓存本地非关系字段。换句话说，它不会缓存父模型的字段（如果存在）。

还有一件事；保存后需要重置_original_statedict。但我不想覆盖save()方法，因为大多数时候我们在保存后丢弃模型实例。

def save(self, *args, **kwargs):
    super(Klass, self).save(*args, **kwargs)
    self._original_state = self._as_dict()
于 2008-12-01T21:09:14.250 回答
14

您没有对您的特定用例或需求进行太多说明。特别是，了解您需要如何处理更改信息（您需要存储多长时间？）会很有帮助。如果您只需要将其存储用于临时目的，@S.Lott 的会话解决方案可能是最好的。如果您想要对存储在数据库中的对象的所有更改进行完整的审计跟踪，请尝试使用此AuditTrail 解决方案。

更新：我在上面链接到的 AuditTrail 代码是我见过的最接近适用于您的案例的完整解决方案的代码，尽管它有一些限制（对于 ManyToMany 字段根本不起作用）。它将所有以前版本的对象存储在数据库中，因此管理员可以回滚到任何以前的版本。如果您希望更改在获得批准之前不会生效，您将不得不使用它。

您还可以基于 @Armin Ronacher 的 DiffingMixin 之类的东西构建自定义解决方案。您将 diff 字典（可能是腌制的？）存储在一个表中，供管理员稍后查看并在需要时应用（您需要编写代码来获取 diff 字典并将其应用于实例）。

于 2008-09-21T14:04:00.800 回答
13

Django 当前正在将所有列发送到数据库，即使您只是更改了一个。要改变这一点，需要对数据库系统进行一些更改。这可以很容易地在现有代码上实现，方法是在模型中添加一组脏字段并在每次添加__set__列值时添加列名。

如果您需要该功能，我建议您查看 Django ORM，实现它并将补丁放入 Django trac。添加它应该很容易，它也会帮助其他用户。当你这样做时，添加一个每次设置列时调用的钩子。

如果您不想破解 Django 本身，您可以复制对象创建时的字典并对其进行比较。

也许使用这样的mixin：

class DiffingMixin(object):

    def __init__(self, *args, **kwargs):
        super(DiffingMixin, self).__init__(*args, **kwargs)
        self._original_state = dict(self.__dict__)

    def get_changed_columns(self):
        missing = object()
        result = {}
        for key, value in self._original_state.iteritems():
            if key != self.__dict__.get(key, missing):
                result[key] = value
        return result

 class MyModel(DiffingMixin, models.Model):
     pass

此代码未经测试，但应该可以工作。当您打电话时，model.get_changed_columns()您会得到所有更改值的字典。这当然不适用于列中的可变对象，因为原始状态是字典的平面副本。

于 2008-09-21T16:33:51.750 回答
10

添加第二个答案，因为自最初发布此问题以来发生了很多变化。

现在 Django 世界中有许多应用程序可以解决这个问题。您可以在 Django Packages 站点上找到模型审计和历史应用程序的完整列表。

我写了一篇博客文章比较了其中一些应用程序。这篇文章现在有 4 年历史了，有点过时了。不过，解决这个问题的不同方法似乎是相同的。

方法：

  1. 将所有历史更改以序列化格式（JSON？）存储在单个表中
  2. 将所有历史更改存储在一个表中，以反映每个模型的原始更改
  3. 将所有历史更改存储在与原始模型相同的表中（我不推荐这样做）

django-reversion包似乎仍然是这个问题最流行的解决方案。它采用第一种方法：序列化更改而不是镜像表。

几年前我恢复了django-simple-history 。它采用第二种方法：镜像每个表。

所以我建议使用一个应用程序来解决这个问题。在这一点上，有一些流行的方法效果很好。

哦，如果您只是在寻找脏字段检查而不是存储所有历史更改，请查看django-model-utils 中的 FieldTracker。

于 2015-12-31T22:11:05.817 回答
6

我扩展了 Trey Hunner 的解决方案以支持 m2m 关系。希望这将帮助其他人寻找类似的解决方案。

from django.db.models.signals import post_save

DirtyFieldsMixin(object):
    def __init__(self, *args, **kwargs):
        super(DirtyFieldsMixin, self).__init__(*args, **kwargs)
        post_save.connect(self._reset_state, sender=self.__class__,
            dispatch_uid='%s._reset_state' % self.__class__.__name__)
        self._reset_state()

    def _as_dict(self):
        fields =  dict([
            (f.attname, getattr(self, f.attname))
            for f in self._meta.local_fields
        ])
        m2m_fields = dict([
            (f.attname, set([
                obj.id for obj in getattr(self, f.attname).all()
            ]))
            for f in self._meta.local_many_to_many
        ])
        return fields, m2m_fields

    def _reset_state(self, *args, **kwargs):
        self._original_state, self._original_m2m_state = self._as_dict()

    def get_dirty_fields(self):
        new_state, new_m2m_state = self._as_dict()
        changed_fields = dict([
            (key, value)
            for key, value in self._original_state.iteritems()
            if value != new_state[key]
        ])
        changed_m2m_fields = dict([
            (key, value)
            for key, value in self._original_m2m_state.iteritems()
            if sorted(value) != sorted(new_m2m_state[key])
        ])
        return changed_fields, changed_m2m_fields

还可能希望合并两个字段列表。为此，替换最后一行

return changed_fields, changed_m2m_fields

和

changed_fields.update(changed_m2m_fields)
return changed_fields
于 2012-06-13T08:57:22.627 回答
3

继续 Muhuk 的建议并添加 Django 的信号和唯一的 dispatch_uid，您可以在不覆盖 save() 的情况下重置保存状态：

from django.db.models.signals import post_save

class DirtyFieldsMixin(object):
    def __init__(self, *args, **kwargs):
        super(DirtyFieldsMixin, self).__init__(*args, **kwargs)
        post_save.connect(self._reset_state, sender=self.__class__, 
                            dispatch_uid='%s-DirtyFieldsMixin-sweeper' % self.__class__.__name__)
        self._reset_state()

    def _reset_state(self, *args, **kwargs):
        self._original_state = self._as_dict()

    def _as_dict(self):
        return dict([(f.name, getattr(self, f.name)) for f in self._meta.local_fields if not f.rel])

    def get_dirty_fields(self):
        new_state = self._as_dict()
        return dict([(key, value) for key, value in self._original_state.iteritems() if value != new_state[key]])

这将在保存后清除原始状态，而无需覆盖 save()。该代码有效，但不确定在 __init__ 处连接信号的性能损失是多少

于 2009-11-11T15:43:49.257 回答
3

我扩展了 muhuk 和 smn 的解决方案，包括对外键和一对一字段的主键进行差异检查：

from django.db.models.signals import post_save

class DirtyFieldsMixin(object):
    def __init__(self, *args, **kwargs):
        super(DirtyFieldsMixin, self).__init__(*args, **kwargs)
        post_save.connect(self._reset_state, sender=self.__class__,
                            dispatch_uid='%s-DirtyFieldsMixin-sweeper' % self.__class__.__name__)
        self._reset_state()

    def _reset_state(self, *args, **kwargs):
        self._original_state = self._as_dict()

    def _as_dict(self):
        return dict([(f.attname, getattr(self, f.attname)) for f in self._meta.local_fields])

    def get_dirty_fields(self):
        new_state = self._as_dict()
        return dict([(key, value) for key, value in self._original_state.iteritems() if value != new_state[key]])

唯一的区别是_as_dict我将最后一行从

return dict([
    (f.name, getattr(self, f.name)) for f in self._meta.local_fields
    if not f.rel
])

到

return dict([
    (f.attname, getattr(self, f.attname)) for f in self._meta.local_fields
])

这个mixin，和上面的一样，可以这样使用：

class MyModel(DirtyFieldsMixin, models.Model):
    ....
于 2011-01-13T02:03:00.120 回答
2

如果您使用自己的事务（不是默认的管理应用程序），您可以保存对象的前后版本。您可以将之前的版本保存在会话中，也可以将其放在表单中的“隐藏”字段中。隐藏字段是安全的噩梦。因此，使用会话来保留该用户发生的事情的历史记录。

此外，当然，您必须获取先前的对象，以便对其进行更改。因此，您有多种方法可以监控差异。

def updateSomething( request, object_id ):
    object= Model.objects.get( id=object_id )
    if request.method == "GET":
        request.session['before']= object
        form= SomethingForm( instance=object )
    else request.method == "POST"
        form= SomethingForm( request.POST )
        if form.is_valid():
            # You have before in the session
            # You have the old object
            # You have after in the form.cleaned_data
            # Log the changes
            # Apply the changes to the object
            object.save()
于 2008-09-21T11:42:58.547 回答
0

基于以上@Trey 和@Tony 的具有m2m 支持的更新解决方案（使用更新的dirtyfields和新的_meta API以及一些错误修复）。这对我来说已经通过了一些基本的光照测试。

from dirtyfields import DirtyFieldsMixin
class M2MDirtyFieldsMixin(DirtyFieldsMixin):
    def __init__(self, *args, **kwargs):
        super(M2MDirtyFieldsMixin, self).__init__(*args, **kwargs)
        post_save.connect(
            reset_state, sender=self.__class__,
            dispatch_uid='{name}-DirtyFieldsMixin-sweeper'.format(
                name=self.__class__.__name__))
        reset_state(sender=self.__class__, instance=self)

    def _as_dict_m2m(self):
        if self.pk:
            m2m_fields = dict([
                (f.attname, set([
                    obj.id for obj in getattr(self, f.attname).all()
                ]))
                for f,model in self._meta.get_m2m_with_model()
            ])
            return m2m_fields
        return {}

    def get_dirty_fields(self, check_relationship=False):
        changed_fields = super(M2MDirtyFieldsMixin, self).get_dirty_fields(check_relationship)
        new_m2m_state = self._as_dict_m2m()
        changed_m2m_fields = dict([
            (key, value)
            for key, value in self._original_m2m_state.iteritems()
            if sorted(value) != sorted(new_m2m_state[key])
        ])
        changed_fields.update(changed_m2m_fields)
        return changed_fields

def reset_state(sender, instance, **kwargs):
    # original state should hold all possible dirty fields to avoid
    # getting a `KeyError` when checking if a field is dirty or not
    instance._original_state = instance._as_dict(check_relationship=True)
    instance._original_m2m_state = instance._as_dict_m2m()
于 2015-12-30T08:26:30.783 回答
-1

对于每个人的信息，muhuk 的解决方案在 python2.6 下失败，因为它引发了一个异常，指出 'object.__ init __()' 不接受任何参数......

编辑：嗬！显然这可能是我滥用了 mixin ...我没有注意并将其声明为最后一个父级，因此对 init的调用最终在对象父级而不是下一个父级中结束，因为它通常会使用 diamond图继承！所以请无视我的评论:)

于 2009-06-23T01:03:09.107 回答