def get_adapter(self, model):
"""Returns the registration information for the given model class."""
if self.is_registered(model):
return self._registered_models[self._registration_key_for_model(model)]
raise RegistrationError("{model} has not been registered with django-reversion".format(
model = model,
))
def register(model):
# Prevent multiple registration.
if is_registered(model):
raise RegistrationError("{model} has already been registered with django-reversion".format(
model=model,
))
# Parse fields.
opts = model._meta.concrete_model._meta
version_options = _VersionOptions(
fields=tuple(
field_name
for field_name
in ([
field.name
for field
in opts.local_fields + opts.local_many_to_many
] if fields is None else fields)
if field_name not in exclude
),
follow=tuple(follow),
format=format,
for_concrete_model=for_concrete_model,
ignore_duplicates=ignore_duplicates,
)
# Register the model.
_registered_models[_get_registration_key(model)] = version_options
# Connect signals.
for sender, signal, signal_receiver in _get_senders_and_signals(model):
signal.connect(signal_receiver, sender=sender)
# All done!
return model
def register(self, model=None, adapter_cls=VersionAdapter, signals=None, eager_signals=None, **field_overrides):
"""Registers a model with this revision manager."""
# Default to post_save if no signals are given
if signals is None and eager_signals is None:
signals = [post_save]
# Store signals for usage in the signal receiver
self._eager_signals[model] = list(eager_signals or [])
self._signals[model] = list(signals or [])
# Return a class decorator if model is not given
if model is None:
return partial(self.register, adapter_cls=adapter_cls, **field_overrides)
# Prevent multiple registration.
if self.is_registered(model):
raise RegistrationError("{model} has already been registered with django-reversion".format(
model = model,
))
# Perform any customization.
if field_overrides:
adapter_cls = type(adapter_cls.__name__, (adapter_cls,), field_overrides)
# Perform the registration.
adapter_obj = adapter_cls(model)
self._registered_models[self._registration_key_for_model(model)] = adapter_obj
# Connect to the selected signals of the model.
all_signals = self._signals[model] + self._eager_signals[model]
for signal in all_signals:
signal.connect(self._signal_receiver, model)
return model
def unregister(self, model):
"""Removes a model from version control."""
if not self.is_registered(model):
raise RegistrationError(
"{model} has not been registered with django-reversion".format(
model=model, ))
del self._registered_models[self._registration_key_for_model(model)]
all_signals = self._signals[model] + self._eager_signals[model]
for signal in all_signals:
signal.disconnect(self._signal_receiver, model)
del self._signals[model]
del self._eager_signals[model]
def __init__(self, manager_slug, revision_context_manager=revision_context_manager):
"""Initializes the revision manager."""
# Check the slug is unique for this revision manager.
if manager_slug in RevisionManager._created_managers: # pragma: no cover
raise RegistrationError("A revision manager has already been created with the slug %r" % manager_slug)
# Store a reference to this manager.
self.__class__._created_managers[manager_slug] = self
# Store config params.
self._manager_slug = manager_slug
self._registered_models = {}
self._revision_context_manager = revision_context_manager
self._eager_signals = {}
self._signals = {}
# Proxies to common context methods.
self._revision_context = revision_context_manager.create_revision()
def _follow_relations(obj):
version_options = _get_options(obj.__class__)
for follow_name in version_options.follow:
try:
follow_obj = getattr(obj, follow_name)
except ObjectDoesNotExist:
continue
if isinstance(follow_obj, models.Model):
yield follow_obj
elif isinstance(follow_obj, (models.Manager, QuerySet)):
for follow_obj_instance in follow_obj.all():
yield follow_obj_instance
elif follow_obj is not None:
raise RegistrationError("{name}.{follow_name} should be a Model or QuerySet".format(
name=obj.__class__.__name__,
follow_name=follow_name,
))
def _assert_registered(model):
if not is_registered(model):
raise RegistrationError("{model} has not been registered with django-reversion".format(
model=model,
))
def get_manager(cls, manager_slug):
"""Returns the manager with the given slug."""
if manager_slug in cls._created_managers:
return cls._created_managers[manager_slug]
raise RegistrationError("No revision manager exists with the slug %r" %
manager_slug) # pragma: no cover