Sale champs dans django

Vous n'avez pas dit grand-chose sur votre cas d'utilisation spécifiques ou des besoins. En particulier, il serait utile de savoir ce que vous devez faire avec les informations de changement (combien de temps devez-vous conserver?). Si vous avez seulement besoin de les stocker pour une passagère fins, @S. Lott session solution peut-être mieux. Si vous voulez une piste de vérification complète de toutes les modifications apportées à vos objets stockés dans la base de données, essayez cette AuditTrail solution.

Mise à JOUR: L'AuditTrail code que j'ai lié ci-dessus est le plus proche que j'ai vu à une solution complète qui fonctionne pour votre cas, si elle a certaines limites (ne fonctionne pas du tout pour ManyToMany champs). Il permet de stocker toutes les versions précédentes de vos objets dans la base de données, de sorte que l'administrateur pourrait revenir à une version précédente. Vous devez travailler avec un peu si vous voulez que la modification ne prend effet qu'après approbation.

Vous pouvez aussi construire une solution personnalisée basée sur quelque chose comme @Armin Ronacher de DiffingMixin. Vous auriez stocker les diff dictionnaire (peut-être marinés?) dans un tableau pour l'admin pour la revoir plus tard et de les appliquer si vous le souhaitez (vous devez écrire le code pour prendre le diff et le dictionnaire de l'appliquer à un exemple).

Django est actuellement l'envoi de toutes les colonnes de la base de données, même si vous avez simplement changé d'un. Pour changer cela, certains changements dans le système de base de données serait nécessaire. Cela pourrait être facilement mis en œuvre sur le code existant par l'ajout d'un ensemble de champs de données modifiées pour le modèle et l'ajout de noms de colonnes, chaque fois que vous __set__ une valeur de colonne.

Si vous avez besoin de cette fonctionnalité, je vous suggère de regarder l'ORM de Django, de l'appliquer et de mettre un patch dans le Django trac. Il devrait être très facile à ajouter que, et qu'il l'aidera d'autres utilisateurs. Lorsque vous faites cela, il faut ajouter un hook qui est appelée chaque fois qu'une colonne est définie.

Si vous ne voulez pas de hack sur Django lui-même, vous pouvez copier le dict sur la création de l'objet et de la diff d'elle.

Peut-être avec un mixin comme ceci:

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

Ce code n'est pas testé mais devrait fonctionner. Lorsque vous appelez model.get_changed_columns() vous obtenez un dict de toutes les valeurs modifiées. Bien sûr, cela ne fonctionnera pas pour mutable objets dans les colonnes parce que l'état initial est un plat copie de la dict.

L'ajout d'une deuxième réponse, car beaucoup de choses ont changé depuis l'époque où cette question a été posté.

Il y a un certain nombre d'applications dans le Django monde que maintenant résoudre ce problème. Vous pouvez trouver plein liste de vérification des modèles et à l'histoire des applications sur le Django Paquets site.

J'ai écrit un post de blog la comparaison de quelques-unes de ces applications. Ce post est maintenant 4 ans et c'est un peu daté. Les différentes approches pour la résolution de ce problème semble être le même.

Les approches:

1. Magasin historique de tous les changements dans un format sérialisé (JSON?) dans une table unique
2. Magasin historique de tous les changements dans un tableau de mise en miroir de l'original pour chaque modèle
3. Stocker l'historique des changements à la même table que le modèle d'origine (je ne le recommande pas)

La django-retour paquet semble toujours être le plus populaire de la solution à ce problème. Il prend la première approche: sérialiser les changements au lieu de la mise en miroir de tables.

J'ai relancé django-simple-histoire quelques années en arrière. Il prend la deuxième approche: miroir chaque table.

Donc je vous conseille de l'aide d'une application pour résoudre ce problème. Il ya un couple de ceux populaire qui fonctionnent assez bien à ce moment.

Oh, et si vous êtes simplement à la recherche pour sale domaine de la vérification et de ne pas stocker l'historique des changements, découvrez FieldTracker de django-modèle-utils.

J'ai étendu muhuk et smn de solutions pour inclure différence de vérification sur les clés primaires pour les clés étrangères et de l'un-à-un champs:

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]])

La seule différence est dans _as_dict j'ai changé la dernière ligne de

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
])

Ce mixin, comme celles ci-dessus, peuvent être utilisés comme suit:

class MyModel(DirtyFieldsMixin, models.Model):
    ....

Une mise à jour de solution m2m de soutien (à l'aide de mises à jour dirtyfields et de nouvelles _meta API et quelques corrections de bug), basé sur @Trey et @Tony ci-dessus. Ce qui a passé de base de la lumière de test pour moi.

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()