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