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 setUp(self):
     super(MultiTableInheritanceApiTest, self).setUp()
     register(ReversionTestModel1Child, follow=("reversiontestmodel1_ptr",))
     with create_revision():
         self.testchild1 = ReversionTestModel1Child.objects.create(
             name = "modelchild1 instance1 version 1",
         )

 def tearDown(self):
     # Unregister the test models.
     unregister(ReversionTestModel1)
     unregister(ReversionTestModel2)
     unregister(ReversionTestModel3)
     # Delete the test models.
     ReversionTestModel1.objects.all().delete()
     ReversionTestModel2.objects.all().delete()
     ReversionTestModel3.objects.all().delete()
     User.objects.all().delete()
     del self.test11
     del self.test12
     del self.test21
     del self.test22
     del self.test31
     del self.test32
     del self.user
     # Delete the revisions index.
     Revision.objects.all().delete()
     # Unregister all remaining models.
     for registered_model in get_registered_models():
         unregister(registered_model)
     # Re-register initial registered models.
     for initial_model, adapter in self.initial_registered_models:
         register(initial_model, adapter_cls=adapter)
     del self.initial_registered_models

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 register_concept_reversions(concept_class, *args, **kwargs):
    from reversion import revisions as reversion
    follows = kwargs.get('reversion', {}).get('follow', [])
    follows.append('_concept_ptr')
    follow_classes = kwargs.get('reversion', {}).get('follow_classes', [])

    reversion.register(concept_class, follow=follows)

    for cls in follow_classes:
        reversion.register(cls)

 def tearDown(self):
     # Unregister the test models.
     unregister(ReversionTestModel1)
     unregister(ReversionTestModel2)
     unregister(ReversionTestModel3)
     # Unregister all remaining models.
     for registered_model in get_registered_models():
         unregister(registered_model)
     # Re-register initial registered models.
     for initial_model, adapter in self.initial_registered_models:
         register(initial_model, adapter_cls=adapter)
     del self.initial_registered_models

def register_concept_reversions(concept_class, *args, **kwargs):
    from reversion import revisions as reversion
    follows = kwargs.get('reversion', {}).get('follow', [])
    follows += [
        '_concept_ptr',
        'statuses',
        'workgroup',
    ]
    follow_classes = kwargs.get('reversion', {}).get('follow_classes', [])

    reversion.register(concept_class, follow=follows)

    for cls in follow_classes:
        reversion.register(cls)

        def register_with_reversion(cls):
            try:
                from reversion.revisions import register
            except ImportError:
                try:
                    from reversion import register
                except ImportError:
                    raise EnvironmentError("django-reversion is not installed")

            follow = []
            for content_type in cls._feincms_content_types:
                follow.append('%s_set' % content_type.__name__.lower())
                register(content_type)
            register(cls, follow=follow)

 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 testMultiTableInheritanceProxyModel(self):
        register(ReversionTestModel1Child, follow=("reversiontestmodel1_ptr",))
        register(ReversionTestModel1ChildProxy, follow=("reversiontestmodel1_ptr",))

        with create_revision():
            concrete = ReversionTestModel1Child.objects.create(name="modelchild1 instance1 version 1")

        proxy = ReversionTestModel1ChildProxy.objects.get(pk=concrete.pk)
        with create_revision():
            proxy.name = "proxy model"
            proxy.save()

        proxy_versions = get_for_object(proxy)

        self.assertEqual(proxy_versions[0].field_dict["name"], proxy.name)
        self.assertEqual(proxy_versions[1].field_dict["name"], concrete.name)

 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 setUp(self):
        unregister(Person)
        unregister(Car)
        unregister(Factory)
        revisions.register(Factory, follow=["building_ptr", "cars", "workers"])
        revisions.register(Car)
        revisions.register(Person, follow=["pets"])
        super(FactoryCarReverseRelationModelTest, self).setUp()

        test_data = TestData(verbose=False)
        self.factory = test_data.create_Factory_reverse_relation_data()
        queryset = Version.objects.get_for_object(self.factory)
        self.version_ids = queryset.values_list("pk", flat=True)

        verbose_name_plural = "Addresses"
        unique_together = ("address_line1", "address_line2", "postal_code",
                           "city", "state_province", "country")


class ContactRequest(models.Model):
    """
    Model to store contact request information
    """
    name = models.CharField(max_length=200)
    email = models.EmailField()
    message = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __unicode__(self):
        return "%s (%s)" % (self.name, self.email)


class AccountRequest(models.Model):
    """
    Model to store account requests.
    """
    email = models.EmailField(unique=True)
    created_at = models.DateTimeField(auto_now_add=True)
    user = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, blank=True)

    def __unicode__(self):
        return "%s (%s)" % (self.email, self.created_at)

reversion.register(Address)

        help_text="Analyses other than excavation that were carried out to research the site.")
    reference = models.ManyToManyField(Book, blank=True,
        help_text="Bibliographic and/or web-based reference(s) to publications and other relevant resources related to the project.")
    comment = models.TextField(blank=True, null=True,
        help_text="Additional information on the research history not covered in any other field.")

    class Meta:
        ordering =( 'id',)

    def __str__(self):
        return str("/".join([str(x) for x in self.research_type.all()])+"_"+str(self.project_name)+'_'+"/".join([str(x) for x in self.institution.all()]))+'_'+str(self.year_of_activity_start_year)

    def get_absolute_url(self):
        return reverse('defcdb:researchevent_list')

reversion.register(ResearchEvent)


class Site(TrackChanges):
    EXACT_LOCATION_CHOICES = (("yes", "yes"), ("no", "no"),)
    name = models.CharField(
        max_length=255, blank=True, null=True,
        help_text="Name of a place in which evidence of past activity is preserved and which represents a part of the archaeological record.")
    alias_name = models.ManyToManyField(
        Name, blank=True, help_text="Other name of the site.", related_name="aliasName")
    alternative_name = models.ManyToManyField(
        Name, blank=True,
        help_text="Different spelling of the name of the site.",
        related_name="alternativeName")
    province = models.ForeignKey(
        DC_province, blank=True, null=True,

            "endpoint_group-NOEL",
            "endpoint_group-LOEL",
            "endpoint_group-FEL",
        )

    @classmethod
    def flat_complete_data_row(cls, ser, endpoint):
        return (
            ser['id'],
            ser['dose_group_id'],
            ser['n'],
            ser['incidence'],
            ser['response'],
            ser['variance'],
            ser['lower_ci'],
            ser['upper_ci'],
            ser['significant'],
            ser['significance_level'],
            ser['dose_group_id'] == endpoint['NOEL'],
            ser['dose_group_id'] == endpoint['LOEL'],
            ser['dose_group_id'] == endpoint['FEL'],
        )


reversion.register(Experiment)
reversion.register(AnimalGroup)
reversion.register(DosingRegime)
reversion.register(DoseGroup)
reversion.register(Endpoint, follow=('groups', ))
reversion.register(EndpointGroup, follow=('endpoint', ))

    class Meta:
        verbose_name = _('Building')
        verbose_name_plural = _('Buildings')
        permissions = (
            ("read_building", _("Can read Building")),
        )

    def get_absolute_url(self):
        return reverse('building-detail', kwargs={'pk': self.pk})

    def get_edit_url(self):
        return reverse('building-edit', kwargs={'pk': self.pk})


reversion.register(Building)


class Room(models.Model):
    name = models.CharField(_('Name'), max_length=200)
    building = models.ForeignKey(Building, null=True, on_delete=models.SET_NULL)
    section = models.ForeignKey(Section, null=True, on_delete=models.SET_NULL, related_name="rooms", blank=True)

    def __unicode__(self):
        if self.building:
            return self.name + " (" + self.building.__unicode__() + ")"
        else:
            return self.name

    class Meta:
        verbose_name = _('Room')

            additionalspeaker__status=AdditionalSpeaker.SPEAKING_STATUS_DECLINED)
        for speaker in speakers:
            yield speaker

    def notification_email_context(self):
        return {
            "title": self.title,
            "speaker": self.speaker.name,
            "speakers": ', '.join([x.name for x in self.speakers()]),
            "kind": self.kind.name,
        }

    def __str__(self):
        return self.title

reversion.register(ProposalBase)


@python_2_unicode_compatible
class AdditionalSpeaker(models.Model):

    SPEAKING_STATUS_PENDING = 1
    SPEAKING_STATUS_ACCEPTED = 2
    SPEAKING_STATUS_DECLINED = 3

    SPEAKING_STATUS = [
        (SPEAKING_STATUS_PENDING, _("Pending")),
        (SPEAKING_STATUS_ACCEPTED, _("Accepted")),
        (SPEAKING_STATUS_DECLINED, _("Declined")),
    ]

    def resend_invite(self):
        if self.invite is not None:
            code = self.invite.signup_code
            code.expiry = timezone.now() + datetime.timedelta(days=5)
            code.save()
            code.send()
            signals.resent_invite.send(sender=self, membership=self)

    def remove(self):
        if self.invite is not None:
            self.invite.signup_code.delete()
            self.invite.delete()
        self.delete()
        signals.removed_membership.send(sender=Membership, team=self.team, user=self.user)

    @property
    def invitee(self):
        return self.user or self.invite.to_user_email

    def __str__(self):
        return "{0} in {1}".format(self.user, self.team)

    class Meta:
        unique_together = [("team", "user", "invite")]
        verbose_name = _("Team")
        verbose_name_plural = _("Teams")


reversion.register(Membership)

        return repr('%s, %s' % (self.__class__.__name__, self.value))


class Industry(models.Model):

    name = models.CharField(max_length=100)

    class Meta:
        ordering = ('name',)
        verbose_name = 'Industry'
        verbose_name_plural = 'Industries'

    def __str__(self):
        return '{}'.format(self.name)

reversion.register(Industry)


class CrmContact(TimeStampedModel):

    contact = models.OneToOneField(settings.CONTACT_MODEL)
    industry = models.ForeignKey(Industry, blank=True, null=True)

    class Meta:
        verbose_name = 'CRM Contact'
        verbose_name_plural = 'CRM Contacts'

    def __str__(self):
        result = '{}'.format(self.contact.get_full_name)
        if self.industry:
            result = '{}: {}'.format(result, self.industry.name)

    def delete(self, keepdir=False):
        """Custom delete method

        We try to delete the associated quota in the same time (it may
        has already been removed if we're deleting a domain).

        :param bool keepdir: delete the mailbox home dir on the
                             filesystem or not

        """
        Quota.objects.filter(username=self.full_address).delete()
        if not keepdir:
            self.delete_dir()
        super(Mailbox, self).delete()

reversion.register(Mailbox)


class MailboxOperation(models.Model):

    """An operation on a mailbox."""

    mailbox = models.ForeignKey(Mailbox, blank=True, null=True)
    type = models.CharField(
        max_length=20, choices=(('rename', 'rename'), ('delete', 'delete'))
    )
    argument = models.TextField()

    class Meta:
        app_label = "admin"