def test_initial_state(self): self.assertTrue(reversion.is_registered(Factory)) self.assertTrue(reversion.is_registered(Car)) self.assertEqual(Revision.objects.all().count(), 3) self.assertEqual(len(self.version_ids), 3) self.assertEqual(Version.objects.all().count(), 10)
def testInlineAdmin(self): self.assertTrue(is_registered(InlineTestParentModel)) # make sure model is following the child FK self.assertTrue('children' in get_adapter(InlineTestParentModel).follow) self.createInlineObjects() # unregister model unregister(InlineTestParentModel) self.assertFalse(is_registered(InlineTestParentModel)) # re-register without following register(InlineTestParentModel) self.assertTrue(is_registered(InlineTestParentModel)) # make sure model is NOT following the child FK self.assertFalse('children' in get_adapter(InlineTestParentModel).follow) self.createInlineObjects()
def testDecoratorArgs(self): # Test a decorator with arguments @register(format='yaml') class DecoratorArgsModel(models.Model): pass self.assertTrue(is_registered(DecoratorArgsModel))
def testInlineAdmin(self): self.assertTrue(is_registered(InlineTestParentModel)) # make sure model is following the child FK self.assertTrue( 'children' in get_adapter(InlineTestParentModel).follow) self.createInlineObjects() # unregister model unregister(InlineTestParentModel) self.assertFalse(is_registered(InlineTestParentModel)) # re-register without following register(InlineTestParentModel) self.assertTrue(is_registered(InlineTestParentModel)) # make sure model is NOT following the child FK self.assertFalse( 'children' in get_adapter(InlineTestParentModel).follow) self.createInlineObjects()
def check_deregistration(self, test_model): # Unregister the model and text. unregister(test_model) self.assertFalse(is_registered(test_model)) self.assertRaises(RegistrationError, lambda: unregister(test_model)) self.assertTrue(test_model not in get_registered_models()) self.assertRaises(RegistrationError, lambda: isinstance(get_adapter(test_model)))
def check_registration(self, test_model): # Register the model and test. register(test_model) self.assertTrue(is_registered(test_model)) self.assertRaises(RegistrationError, lambda: register(test_model)) self.assertTrue(test_model in get_registered_models()) self.assertTrue(isinstance(get_adapter(test_model), VersionAdapter))
def _register_model(admin, model): if not hasattr(admin, "reversion_format"): admin.reversion_format = "json" if not is_registered(model): inline_fields = [] for inline in getattr(admin, "inlines", []): inline_model = inline.model if getattr(inline, "generic_inline", False): ct_field = getattr(inline, "ct_field", "content_type") ct_fk_field = getattr(inline, "ct_fk_field", "object_id") for field in model._meta.many_to_many: if (isinstance(field, GenericRelation) and field.rel.to == inline_model and field.object_id_field_name == ct_fk_field and field.content_type_field_name == ct_field): inline_fields.append(field.name) _autoregister(admin, inline_model) else: fk_name = getattr(inline, "fk_name", None) if not fk_name: for field in inline_model._meta.fields: if isinstance(field, (models.ForeignKey, models.OneToOneField)) and issubclass( model, field.rel.to): fk_name = field.name _autoregister(admin, inline_model, follow=[fk_name]) if not inline_model._meta.get_field(fk_name).rel.is_hidden(): accessor = inline_model._meta.get_field( fk_name).remote_field.get_accessor_name() inline_fields.append(accessor) _autoregister(admin, model, inline_fields)
def testDecorator(self): # Test the use of register as a decorator @register class DecoratorModel(models.Model): pass self.assertTrue(is_registered(DecoratorModel))
def get_models(self, options): # Load admin classes. if "django.contrib.admin" in settings.INSTALLED_APPS: admin.autodiscover() # Get options. app_labels = options["app_label"] # Parse model classes. if len(app_labels) == 0: selected_models = apps.get_models() else: selected_models = set() for label in app_labels: if "." in label: # This is an app.Model specifier. try: model = apps.get_model(label) except LookupError: raise CommandError("Unknown model: {}".format(label)) selected_models.add(model) else: # This is just an app - no model qualifier. app_label = label try: app = apps.get_app_config(app_label) except LookupError: raise CommandError("Unknown app: {}".format(app_label)) selected_models.update(app.get_models()) for model in selected_models: if is_registered(model): yield model
def _register_model(admin, model): if not hasattr(admin, 'reversion_format'): admin.reversion_format = 'json' if not is_registered(model): inline_fields = [] for inline in getattr(admin, 'inlines', []): inline_model = inline.model if getattr(inline, 'generic_inline', False): ct_field = getattr(inline, 'ct_field', 'content_type') ct_fk_field = getattr(inline, 'ct_fk_field', 'object_id') for field in model._meta.many_to_many: if isinstance(field, GenericRelation) \ and field.rel.to == inline_model \ and field.object_id_field_name == ct_fk_field \ and field.content_type_field_name == ct_field: inline_fields.append(field.name) _autoregister(admin, inline_model) else: fk_name = getattr(inline, 'fk_name', None) if not fk_name: for field in inline_model._meta.fields: if isinstance(field, (models.ForeignKey, models.OneToOneField)) and issubclass(model, field.rel.to): fk_name = field.name _autoregister(admin, inline_model, follow=[fk_name]) if not inline_model._meta.get_field(fk_name).rel.is_hidden(): accessor = inline_model._meta.get_field(fk_name).remote_field.get_accessor_name() inline_fields.append(accessor) _autoregister(admin, model, inline_fields)
def _register_model(admin, model): if not hasattr(admin, 'reversion_format'): admin.reversion_format = 'json' if not is_registered(model): inline_fields = [] for inline in getattr(admin, 'inlines', []): inline_model = inline.model if getattr(inline, 'generic_inline', False): ct_field = getattr(inline, 'ct_field', 'content_type') ct_fk_field = getattr(inline, 'ct_fk_field', 'object_id') for field in model._meta.many_to_many: if isinstance(field, GenericRelation) \ and field.rel.to == inline_model \ and field.object_id_field_name == ct_fk_field \ and field.content_type_field_name == ct_field: inline_fields.append(field.name) _autoregister(admin, inline_model) else: fk_name = getattr(inline, 'fk_name', None) if not fk_name: for field in inline_model._meta.fields: if isinstance(field, (models.ForeignKey, models.OneToOneField)) and issubclass( model, field.remote_field.model): fk_name = field.name _autoregister(admin, inline_model, follow=[fk_name]) if not inline_model._meta.get_field( fk_name).remote_field.is_hidden(): accessor = inline_model._meta.get_field( fk_name).remote_field.get_accessor_name() inline_fields.append(accessor) _autoregister(admin, model, inline_fields)
def get_models(self, options): # Load admin classes. admin.autodiscover() # Get options. app_labels = options["app_label"] # Parse model classes. if len(app_labels) == 0: selected_models = apps.get_models() else: selected_models = set() for label in app_labels: if "." in label: # This is an app.Model specifier. try: model = apps.get_model(label) except LookupError: raise CommandError("Unknown model: {}".format(label)) selected_models.add(model) else: # This is just an app - no model qualifier. app_label = label try: app = apps.get_app_config(app_label) except LookupError: raise CommandError("Unknown app: {}".format(app_label)) selected_models.update(app.get_models()) for model in selected_models: if is_registered(model): yield model
def _reversion_autoregister(self, model, follow): if not is_registered(model): for parent_model, field in model._meta.concrete_model._meta.parents.items( ): follow += (field.name, ) self._reversion_autoregister(parent_model, ()) self.reversion_register(model, follow=follow)
def testEagerRegistration(self): # Register the model and test. register(ReversionTestModel3, eager_signals=[pre_delete]) self.assertTrue(is_registered(ReversionTestModel3)) self.assertRaises(RegistrationError, lambda: register(ReversionTestModel3, eager_signals=[pre_delete])) self.assertTrue(ReversionTestModel3 in get_registered_models()) self.assertTrue(isinstance(get_adapter(ReversionTestModel3), VersionAdapter)) self.assertEqual([], default_revision_manager._signals[ReversionTestModel3]) self.assertEqual([pre_delete], default_revision_manager._eager_signals[ReversionTestModel3]) # Unregister the model and text. unregister(ReversionTestModel3) self.assertFalse(is_registered(ReversionTestModel3)) self.assertRaises(RegistrationError, lambda: unregister(ReversionTestModel3)) self.assertTrue(ReversionTestModel3 not in get_registered_models()) self.assertRaises(RegistrationError, lambda: isinstance(get_adapter(ReversionTestModel3))) self.assertFalse(ReversionTestModel3 in default_revision_manager._signals) self.assertFalse(ReversionTestModel3 in default_revision_manager._eager_signals)
def register_processes(): try: from reversion import revisions except ImportError: pass else: for model in utils.get_processes(): if not revisions.is_registered(model): revisions.register(model)
def register_workflows(): try: from reversion import revisions except ImportError: pass else: for workflow in utils.get_workflows(): if not revisions.is_registered(workflow): revisions.register(workflow)
def test_initial_state(self): self.assertTrue(reversion.is_registered(VariantModel)) self.assertEqual(VariantModel.objects.count(), 1) count = len(self.test_data) + 1 # incl. initial self.assertEqual(reversion.get_for_object(self.item).count(), count) self.assertEqual(Revision.objects.all().count(), count) self.assertEqual(len(self.version_ids), count)
def _autoregister(admin, model, follow=None): """Registers a model with reversion, if required.""" if model._meta.proxy: raise RegistrationError("Proxy models cannot be used with django-reversion, register the parent class instead") if not is_registered(model): follow = follow or [] for parent_cls, field in model._meta.parents.items(): follow.append(field.name) _autoregister(admin, parent_cls) register(model, follow=follow, format=admin.reversion_format)
def test_initial_state(self): self.assertTrue(reversion.is_registered(SimpleModel)) self.assertEqual(SimpleModel.objects.count(), 2) self.assertEqual(SimpleModel.objects.all()[0].text, "version two") self.assertEqual(reversion.get_for_object(self.item1).count(), 2) self.assertEqual(list(self.version_ids1), [2, 1]) self.assertEqual(list(self.version_ids1), [2, 1]) self.assertEqual(list(self.version_ids2), [7, 6, 5, 4, 3])
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) # Automatically register models if required. if not is_registered(self.model): inline_fields = () for inline in self.inlines: inline_model, follow_field = self._reversion_introspect_inline_admin(inline) if inline_model: self._reversion_autoregister(inline_model, ()) if follow_field: inline_fields += (follow_field,) self._reversion_autoregister(self.model, inline_fields)
def __init__(self, *args, **kwargs): super(VersionAdmin, self).__init__(*args, **kwargs) # Automatically register models if required. if not is_registered(self.model): inline_fields = () for inline in self.inlines: inline_model, follow_field = self._reversion_introspect_inline_admin(inline) if inline_model: self._reversion_autoregister(inline_model, ()) if follow_field: inline_fields += (follow_field,) self._reversion_autoregister(self.model, inline_fields)
def test_initial_state(self): self.assertTrue(reversion.is_registered(SimpleModel)) self.assertEqual(SimpleModel.objects.count(), 2) self.assertEqual(SimpleModel.objects.all()[0].text, "version two") self.assertEqual(reversion.get_for_object(self.item1).count(), 2) self.assertEqual(reversion.get_for_object(self.item2).count(), 5) self.assertEqual(Revision.objects.all().count(), 7) self.assertEqual(Version.objects.all().count(), 7) # query.ValuesListQuerySet() -> list(): self.assertEqual(list(self.version_ids1), [2, 1]) self.assertEqual(list(self.version_ids2), [7, 6, 5, 4, 3])
def testInlineProxyAdmin(self): self.assertTrue(is_registered(InlineTestParentModelProxy)) # make sure model is following the child FK self.assertTrue('children' in get_adapter(InlineTestParentModelProxy).follow) parent_pk = self.createInlineProxyObjects() # Check that the current version includes the inlines. versions = list(get_for_object_reference(InlineTestParentModelProxy, parent_pk)) response = self.client.get(reverse("admin:test_reversion_inlinetestparentmodelproxy_revision", args=(parent_pk, versions[0].pk))) self.assertContains(response, "parent version2") # Check parent model. self.assertContains(response, "non-generic child version 1") # Check inline child model. # Check that the first version does not include the inlines. response = self.client.get(reverse("admin:test_reversion_inlinetestparentmodelproxy_revision", args=(parent_pk, versions[1].pk))) self.assertContains(response, "parent version1") # Check parent model. self.assertNotContains(response, "non-generic child version 1") # Check inline child model.
def register_concept_reversions(concept_class, *args, **kwargs): from reversion import revisions as reversion follows = kwargs.get('reversion', {}).get('follow', []) # Register the concept with reversion reversion.register(concept_class, follow=follows, format='aristotle_mdr_json') follow_classes = kwargs.get('reversion', {}).get('follow_classes', []) for cls in follow_classes: reversion.register(cls) if reversion.is_registered(_concept): reversion.unregister(_concept)
def __init__(self, *args, **kwargs): super(VersionAdmin, self).__init__(*args, **kwargs) # Check that database transactions are supported. if not connection.features.uses_savepoints: raise ImproperlyConfigured("Cannot use VersionAdmin with a database that does not support savepoints.") # Automatically register models if required. if not is_registered(self.model): inline_fields = () for inline in self.inlines: inline_model, follow_field = self._reversion_introspect_inline_admin(inline) if inline_model: self._reversion_autoregister(inline_model, ()) if follow_field: inline_fields += (follow_field,) self._reversion_autoregister(self.model, inline_fields)
def log_object_removal(sender, instance, **kwargs): """Custom post-delete hook. We want to know who was responsible for an object deletion. """ from reversion.models import Version if not reversion.is_registered(sender): return del_list = reversion.get_deleted(sender) try: version = del_list.get(object_id=instance.id) except Version.DoesNotExist: return logger = logging.getLogger("modoboa.admin") msg = _("%(object)s '%(name)s' %(action)s by user %(user)s") % { "object": smart_text(version.content_type).capitalize(), "name": version.object_repr, "action": _("deleted"), "user": get_request().user.username } logger.critical(msg)
def log_object_removal(sender, instance, **kwargs): """Custom post-delete hook. We want to know who was responsible for an object deletion. """ from reversion.models import Version from modoboa.lib.signals import get_request if not reversion.is_registered(sender): return del_list = reversion.get_deleted(sender) try: version = del_list.get(object_id=instance.id) except Version.DoesNotExist: return logger = logging.getLogger("modoboa.admin") msg = _("%(object)s '%(name)s' %(action)s by user %(user)s") % { "object": unicode(version.content_type).capitalize(), "name": version.object_repr, "action": _("deleted"), "user": get_request().user.username } logger.critical(msg)
def log_object_removal(sender, instance, **kwargs): """Custom post-delete hook. We want to know who was responsible for an object deletion. """ if not reversion.is_registered(sender): return del_list = Version.objects.get_deleted(sender) try: version = del_list.get(object_id=instance.id) except Version.DoesNotExist: return logger = logging.getLogger("modoboa.admin") msg = _("%(object)s '%(name)s' %(action)s by ") % { "object": smart_text(version.content_type).capitalize(), "name": version.object_repr, "action": _("deleted") } request = get_request() if request: msg += _("user {}").format(request.user.username) else: msg += _("management command") logger.critical(msg)
def testInlineProxyAdmin(self): self.assertTrue(is_registered(InlineTestParentModelProxy)) # make sure model is following the child FK self.assertTrue( 'children' in get_adapter(InlineTestParentModelProxy).follow) parent_pk = self.createInlineProxyObjects() # Check that the current version includes the inlines. versions = list( get_for_object_reference(InlineTestParentModelProxy, parent_pk)) response = self.client.get( reverse("admin:test_reversion_inlinetestparentmodelproxy_revision", args=(parent_pk, versions[0].pk))) self.assertContains(response, "parent version2") # Check parent model. self.assertContains( response, "non-generic child version 1") # Check inline child model. # Check that the first version does not include the inlines. response = self.client.get( reverse("admin:test_reversion_inlinetestparentmodelproxy_revision", args=(parent_pk, versions[1].pk))) self.assertContains(response, "parent version1") # Check parent model. self.assertNotContains( response, "non-generic child version 1") # Check inline child model.
def is_registered(*args, **kwargs): return revisions.is_registered(*args, **kwargs)
def testAutoRegisterWorks(self): self.assertTrue(is_registered(ChildTestAdminModel)) self.assertTrue(is_registered(ParentTestAdminModel)) self.assertTrue(is_registered(InlineTestChildModel)) self.assertTrue(is_registered(InlineTestChildGenericModel)) self.assertTrue(is_registered(InlineTestParentModel))
def _reversion_autoregister(self, model, follow): if not is_registered(model): for parent_model, field in model._meta.concrete_model._meta.parents.items(): follow += (field.name,) self._reversion_autoregister(parent_model, ()) self.reversion_register(model, follow=follow)
def can_etag(self, obj): return hasattr(obj, "_meta") and revisions.is_registered(type(obj))