Python reversion.is_registered函数代码示例

 def tearDown(self):
     super(AdminRegisterInlineTest, self).tearDown()
     if reversion.is_registered(TestModelInline):
         reversion.unregister(TestModelInline)
     if reversion.is_registered(TestModelGenericInline):
         reversion.unregister(TestModelGenericInline)
     admin.site.unregister(TestModelParent)

    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 test_initial_state(self):
        self.assertTrue(reversion.is_registered(Pet))
        self.assertTrue(reversion.is_registered(Person))

        self.assertEqual(Pet.objects.count(), 3)

        self.assertEqual(reversion.get_for_object(self.pet1).count(), 2)
        self.assertEqual(Revision.objects.all().count(), 2)

    def test_initial_state(self):
        self.assertTrue(is_registered(Factory))
        self.assertTrue(is_registered(Car))

        self.assertEqual(Factory.objects.all().count(), 0)
        self.assertEqual(Car.objects.all().count(), 0)

        self.assertEqual(Revision.objects.all().count(), 0)
        self.assertEqual(Version.objects.all().count(), 0)

 def testRegistration(self):
     # Register the model and test.
     reversion.register(ReversionTestModel1)
     self.assertTrue(reversion.is_registered(ReversionTestModel1))
     self.assertRaises(RegistrationError, lambda: reversion.register(ReversionTestModel1))
     self.assertTrue(ReversionTestModel1 in reversion.get_registered_models())
     self.assertTrue(isinstance(reversion.get_adapter(ReversionTestModel1), reversion.VersionAdapter))
     # Unregister the model and text.
     reversion.unregister(ReversionTestModel1)
     self.assertFalse(reversion.is_registered(ReversionTestModel1))
     self.assertRaises(RegistrationError, lambda: reversion.unregister(ReversionTestModel1))
     self.assertTrue(ReversionTestModel1 not in reversion.get_registered_models())
     self.assertRaises(RegistrationError, lambda: isinstance(reversion.get_adapter(ReversionTestModel1)))

 def testInlineAdmin(self):
     self.assertTrue(reversion.is_registered(InlineTestParentModel))
     # make sure model is following the child FK
     self.assertTrue('children' in reversion.get_adapter(InlineTestParentModel).follow)
     self.createInlineObjects()
     # unregister model
     reversion.unregister(InlineTestParentModel)
     self.assertFalse(reversion.is_registered(InlineTestParentModel))
     # re-register without following
     reversion.register(InlineTestParentModel)
     self.assertTrue(reversion.is_registered(InlineTestParentModel))
     # make sure model is NOT following the child FK
     self.assertFalse('children' in reversion.get_adapter(InlineTestParentModel).follow)
     self.createInlineObjects()

 def __new__(cls, name, bases, attrs):
     if name in cls.plugins_with_extra_fields:
         ExtraFieldsMixin.media = media_property(ExtraFieldsMixin)
         bases = (ExtraFieldsMixin,) + bases
     if name in cls.plugins_with_sharables:
         SharableGlossaryMixin.media = media_property(SharableGlossaryMixin)
         bases = (SharableGlossaryMixin,) + bases
         attrs['fields'] += (('save_shared_glossary', 'save_as_identifier'), 'shared_glossary',)
         attrs['sharable_fields'] = cls.plugins_with_sharables[name]
         base_model = SharableCascadeElement
     else:
         base_model = CascadeElement
     if name in settings.CMSPLUGIN_CASCADE['plugins_with_extra_render_templates'].keys():
         RenderTemplateMixin.media = media_property(RenderTemplateMixin)
         bases = (RenderTemplateMixin,) + bases
     model_mixins = attrs.pop('model_mixins', ())
     if name == 'SegmentPlugin':
         # SegmentPlugin shall additionally inherit from configured mixin classes
         model_mixins += tuple(import_string(mc[0]) for mc in settings.CMSPLUGIN_CASCADE['segmentation_mixins'])
     module = attrs.get('__module__')
     app_label = attrs.get('app_label', module.split('.')[0])
     attrs['model'] = create_proxy_model(name, app_label, model_mixins, base_model, module=module)
     if is_installed('reversion'):
         import reversion
         if not reversion.is_registered(base_model):
             reversion.register(base_model)
     # handle ambiguous plugin names by appending a symbol
     if 'name' in attrs and settings.CMSPLUGIN_CASCADE['plugin_prefix']:
         attrs['name'] = mark_safe_lazy(string_concat(
             settings.CMSPLUGIN_CASCADE['plugin_prefix'], " ", attrs['name']))
     return super(CascadePluginBaseMetaclass, cls).__new__(cls, name, bases, attrs)

def register_model(model, follow = None):
    if not reversion.is_registered(model) and settings.USE_REVERSION:
        #print "registering model with reversion: ", model
        if follow is None:
            reversion.register(model)
        else:
            reversion.register(model, follow = follow)

 def __new__(cls, name, bases, attrs):
     if name in cls.plugins_with_extrafields:
         ExtraFieldsMixin.media = media_property(ExtraFieldsMixin)
         bases = (ExtraFieldsMixin,) + bases
     if name in cls.plugins_with_sharables:
         SharableGlossaryMixin.media = media_property(SharableGlossaryMixin)
         bases = (SharableGlossaryMixin,) + bases
         attrs['fields'] += (('save_shared_glossary', 'save_as_identifier'), 'shared_glossary',)
         attrs['sharable_fields'] = cls.plugins_with_sharables[name]
         base_model = SharableCascadeElement
     else:
         base_model = CascadeElement
     if name in getattr(settings, 'CASCADE_PLUGINS_WITH_EXTRA_RENDER_TEMPLATES').keys():
         RenderTemplateMixin.media = media_property(RenderTemplateMixin)
         bases = (RenderTemplateMixin,) + bases
     model_mixins = attrs.pop('model_mixins', ())
     if name == 'SegmentPlugin':
         # SegmentPlugin shall additionally inherit from configured mixin classes
         model_mixins += tuple(import_string(mc[0]) for mc in settings.CASCADE_SEGMENTATION_MIXINS)
     attrs['model'] = create_proxy_model(name, model_mixins, base_model)
     if is_installed('reversion'):
         import reversion
         if not reversion.is_registered(base_model):
             reversion.register(base_model)
     return super(CascadePluginBaseMetaclass, cls).__new__(cls, name, bases, attrs)

 def check_deregistration(self, test_model):
     # Unregister the model and text.
     reversion.unregister(test_model)
     self.assertFalse(reversion.is_registered(test_model))
     self.assertRaises(RegistrationError, lambda: reversion.unregister(test_model))
     self.assertTrue(test_model not in reversion.get_registered_models())
     self.assertRaises(RegistrationError, lambda: isinstance(reversion.get_adapter(test_model)))

 def setUp(self):
     # Register the test models.
     reversion.register(ReversionTestModel1)
     reversion.register(ReversionTestModel2)
     # Create some test data.
     self.test11 = ReversionTestModel1.objects.create(
         name = "model1 instance1 version1",
     )
     self.test12 = ReversionTestModel1.objects.create(
         name = "model1 instance2 version1",
     )
     self.test21 = ReversionTestModel2.objects.create(
         name = "model2 instance1 version1",
     )
     self.test22 = ReversionTestModel2.objects.create(
         name = "model2 instance2 version1",
     )
     self.user = User.objects.create(
         username = "user1",
     )
     
     # Since we're creating a user, we need to bias our assertions
     # depending on whether or not it will create versions/revisions for
     # self.user.
     self.registered_instance_offset = 0
     if reversion.is_registered(User):
         self.registered_instance_offset = 1

    def testDecoratorArgs(self):
        # Test a decorator with arguments
        @reversion.register(format="yaml")
        class DecoratorArgsModel(models.Model):
            pass

        self.assertTrue(reversion.is_registered(DecoratorArgsModel))

 def __init__(self, *args, **kwargs):
     """Initializes the VersionAdmin"""
     super(VersionAdmin, self).__init__(*args, **kwargs)
     # Automatically register models if required.
     if not reversion.is_registered(self.model):
         inline_fields = []
         for inline in self.inlines:
             inline_model = inline.model
             self._autoregister(inline_model)
             if issubclass(inline, (admin.TabularInline, admin.StackedInline)):
                 fk_name = inline.fk_name
                 if not fk_name:
                     for field in inline_model._meta.fields:
                         if isinstance(field, (models.ForeignKey, models.OneToOneField)) and issubclass(
                             self.model, field.rel.to
                         ):
                             fk_name = field.name
                 accessor = (
                     inline_model._meta.get_field(fk_name).rel.related_name or inline_model.__name__.lower() + "_set"
                 )
                 inline_fields.append(accessor)
             elif issubclass(inline, GenericInlineModelAdmin):
                 ct_field = inline.ct_field
                 ct_fk_field = inline.ct_fk_field
                 for field in self.model._meta.many_to_many:
                     if (
                         isinstance(field, GenericRelation)
                         and field.object_id_field_name == ct_fk_field
                         and field.content_type_field_name == ct_field
                     ):
                         inline_fields.append(field.name)
         self._autoregister(self.model, inline_fields)

 def check_registration(self, test_model):
     # Register the model and test.
     reversion.register(test_model)
     self.assertTrue(reversion.is_registered(test_model))
     self.assertRaises(RegistrationError, lambda: reversion.register(test_model))
     self.assertTrue(test_model in reversion.get_registered_models())
     self.assertTrue(isinstance(reversion.get_adapter(test_model), reversion.VersionAdapter))

    def testDecorator(self):
        # Test the use of register as a decorator
        @reversion.register
        class DecoratorModel(models.Model):
            pass

        self.assertTrue(reversion.is_registered(DecoratorModel))