Как сделать полную историю текста в Django?

Для управления различиями вы, вероятно, захотите изучить Python дифлиб.

Что касается атомарности, я бы, вероятно, поступил так же, как и вики (Trac и т. д.). Если содержимое изменилось с момента последнего его получения пользователем, запросите его замену новой версией. Если вы храните текст и различия в одной и той же записи, не составит труда избежать состояния гонки базы данных, используя методы, указанные в размещенных вами ссылках.

Проблема с хранением: Я думаю, вам следует хранить различия только двух последовательных действительных версий документа. Как вы отметили, проблема заключается в получении действительной версии при одновременном редактировании.

Проблема параллелизма:

1. Могли бы вы избежать их всех вместе, как Джефф предлагает, или заблокировав документ?
2. Если нет, то я думаю, что вы в конечном итоге находитесь в парадигме онлайн-редакторы для совместной работы в режиме реального времени, такие как Google Docs.

Чтобы получить иллюстрированный вид банки с червями, вы открываете catch этот технический разговор Google в 9:21 (речь идет о совместном редактировании Eclipse в реальном времени)

В качестве альтернативы, есть пара патентов, в которых подробно описаны способы решения этих проблем в Статья в Википедии о совместных редакторах в реальном времени.

Ваше автосохранение, я полагаю, сохраняет черновую версию до того, как пользователь действительно нажмет кнопку сохранения, верно?

Если это так, вам не нужно хранить черновики сохранений, просто удалите их после того, как пользователь решит сохранить их в реальном времени, и сохраните только историю реальных / явных сохранений.

Вот что я сделал, чтобы сохранить историю объекта:

Для истории приложений Django:

история / __ init__.py:

"""
history/__init__.py
"""
from django.core import serializers
from django.utils import simplejson as json
from django.db.models.signals import pre_save, post_save

# from http://code.google.com/p/google-diff-match-patch/
from contrib.diff_match_patch import diff_match_patch

from history.models import History

def register_history(M):
  """
  Register Django model M for keeping its history

  e.g. register_history(Document) - every time Document is saved,
  its history (i.e. the differences) is saved.
  """
  pre_save.connect(_pre_handler, sender=M)
  post_save.connect(_post_handler, sender=M)

def _pre_handler(signal, sender, instance, **kwargs):
  """
  Save objects that have been changed.
  """
  if not instance.pk:
    return

  # there must be a before, if there's a pk, since
  # this is before the saving of this object.
  before = sender.objects.get(pk=instance.pk)

  _save_history(instance, _serialize(before).get('fields'))

def _post_handler(signal, sender, instance, created, **kwargs):
  """
  Save objects that are being created (otherwise we wouldn't have a pk!)
  """
  if not created:
     return

  _save_history(instance, {})

def _serialize(instance):
   """
   Given a Django model instance, return it as serialized data
   """
   return serializers.serialize("python", [instance])[0]

def _save_history(instance, before):
  """
  Save two serialized objects
  """
  after = _serialize(instance).get('fields',{})

  # All fields.
  fields = set.union(set(before.keys()),set(after.keys()))

  dmp = diff_match_patch()

  diff = {}

  for field in fields:
    field_before = before.get(field,False)
    field_after = after.get(field,False)

    if field_before != field_after:
      if isinstance(field_before, unicode) or isinstance(field_before, str):
      # a patch
        diff[field] = dmp.diff_main(field_before,field_after)
      else:
        diff[field] = field_before

  history = History(history_for=instance, diff=json.dumps(diff))
  history.save()

history / models.py

"""
history/models.py
"""

from django.db import models

from django.contrib.contenttypes.models import ContentType
from django.contrib.contenttypes import generic

from contrib import diff_match_patch as diff

class History(models.Model):
     """
     Retain the history of generic objects, e.g. documents, people, etc..
  """

  content_type = models.ForeignKey(ContentType, null=True)

  object_id = models.PositiveIntegerField(null=True)

  history_for = generic.GenericForeignKey('content_type', 'object_id')

  diff = models.TextField()

  def __unicode__(self):
       return "<History (%s:%d):%d>" % (self.content_type, self. object_id, self.pk)

Надеюсь, что это поможет кому-то, и комментарии будут оценены.

Обратите внимание, что это нет устраняет состояние гонки, которое меня больше всего беспокоит. Если в _pre_handler "before = sender.objects.get (pk = instance.pk)" вызывается до сохранения другого экземпляра, но после того, как этот другой экземпляр обновил историю, и текущий экземпляр сохраняет сначала, будет история »(т.е. не по порядку). К счастью, diff_match_patch пытается изящно обрабатывать «нефатальные» прерывания, но нет гарантии успеха.

Одно из решений - атомарность. Однако я не уверен, как сделать вышеупомянутое условие гонки (т.е. _pre_handler) атомарной операцией для всех экземпляров Django. Таблица HistoryLock или общий хеш в памяти (memcached?) Подойдут - предложения?

Другое решение, как уже упоминалось, - это алгоритм согласования. Однако одновременные сохранения могут иметь «настоящие» конфликты и требовать вмешательства пользователя для определения правильного согласования.

Очевидно, что сбор истории по кусочкам не является частью приведенных выше фрагментов.

С тех пор я обнаружил также джанго-реверсия, который, кажется, хорошо работает и активно поддерживается, хотя он не выполняет различий для эффективного хранения небольших различий в больших фрагментах текста.