Ejemplo n.º 1
0
 def test_reregister(self):
     register(Restaurant, manager_name='again')
     register(User, manager_name='again')
     self.assertTrue(hasattr(Restaurant, 'updates'))
     self.assertFalse(hasattr(Restaurant, 'again'))
     self.assertTrue(hasattr(User, 'histories'))
     self.assertFalse(hasattr(User, 'again'))
Ejemplo n.º 2
0
 def test_reregister(self):
     register(Restaurant, manager_name="again")
     register(User, manager_name="again")
     self.assertTrue(hasattr(Restaurant, "updates"))
     self.assertFalse(hasattr(Restaurant, "again"))
     self.assertTrue(hasattr(User, "histories"))
     self.assertFalse(hasattr(User, "again"))
Ejemplo n.º 3
0
    def contribute_to_class(self, cls, name):
        self.manager_name = name
        self.module = cls.__module__
        models.signals.class_prepared.connect(self.finalize, sender=cls)
        setattr(cls, 'simple_history_manager', name)

        def save_without_historical_record(self, *args, **kwargs):
            """Caution! Make sure you know what you're doing before you use this method."""
            self.skip_history_when_saving = True
            ret = self.save(*args, **kwargs)
            del self.skip_history_when_saving
            return ret
        setattr(cls, 'save_without_historical_record', save_without_historical_record)

        # Injecting HistoricalRecords into ManyToManyFields' intermediate tables ('through' models)
        if hasattr(cls, 'm2m_history_fields'):
            m2m_history_fields = getattr(cls, 'm2m_history_fields', None)
            assert (isinstance(m2m_history_fields, list)
                or  isinstance(m2m_history_fields, tuple)), 'm2m_history_fields must be a list or tuple'
            for field_name in m2m_history_fields:
                field = getattr(cls, field_name).field
                assert isinstance(field, models.fields.related.ManyToManyField), ('%s must be a ManyToManyField' % field_name)
                if not sum([isinstance(item, HistoricalRecords) for item in field.rel.through.__dict__.values()]):
                    field.rel.through.history = HistoricalRecords()
                    simple_history.register(field.rel.through)
 def test_reregister(self):
     register(Restaurant, manager_name='again')
     register(User, manager_name='again')
     self.assertTrue(hasattr(Restaurant, 'updates'))
     self.assertFalse(hasattr(Restaurant, 'again'))
     self.assertTrue(hasattr(User, 'histories'))
     self.assertFalse(hasattr(User, 'again'))
Ejemplo n.º 5
0
 def setup_m2m_history(self, cls):
     m2m_history_fields = self.m2m_fields
     if m2m_history_fields is ALL_M2M_FIELDS:
         for field in cls._meta.many_to_many:
             field = getattr(cls, field.name).field
             assert isinstance(field, models.fields.related.ManyToManyField), \
                 ('%s must be a ManyToManyField' % field.name)
             if not sum([
                     isinstance(item, HistoricalRecords) for item in field.remote_field.through.__dict__.values()
             ]):
                 through_model = field.remote_field.through
                 if through_model._meta.auto_created and not_registered(through_model):
                     through_model.history = HistoricalRecords()
                     register(through_model)
     elif m2m_history_fields:
         assert (isinstance(m2m_history_fields, list) or isinstance(m2m_history_fields, tuple)), \
             'm2m_history_fields must be a list or tuple'
         for field_name in m2m_history_fields:
             field = getattr(cls, field_name).field
             assert isinstance(field, models.fields.related.ManyToManyField), \
                 ('%s must be a ManyToManyField' % field_name)
             if not sum([
                     isinstance(item, HistoricalRecords) for item in field.remote_field.through.__dict__.values()
             ]):
                 through_model = field.remote_field.through
                 if through_model._meta.auto_created and not_registered(through_model):
                     through_model.history = HistoricalRecords()
                     register(through_model)
 def setup_m2m_history(self, cls):
     m2m_history_fields = self.m2m_fields
     if m2m_history_fields is ALL_M2M_FIELDS:
         for field in cls._meta.many_to_many:
             field = getattr(cls, field.name).field
             assert isinstance(field, models.fields.related.ManyToManyField), \
                 ('%s must be a ManyToManyField' % field.name)
             if not sum([
                     isinstance(item, HistoricalRecords) for item in
                     field.remote_field.through.__dict__.values()
             ]):
                 through_model = field.remote_field.through
                 if through_model._meta.auto_created and not_registered(
                         through_model):
                     through_model.history = HistoricalRecords()
                     register(through_model)
     elif m2m_history_fields:
         assert (isinstance(m2m_history_fields, list) or isinstance(m2m_history_fields, tuple)), \
             'm2m_history_fields must be a list or tuple'
         for field_name in m2m_history_fields:
             field = getattr(cls, field_name).field
             assert isinstance(field, models.fields.related.ManyToManyField), \
                 ('%s must be a ManyToManyField' % field_name)
             if not sum([
                     isinstance(item, HistoricalRecords) for item in
                     field.remote_field.through.__dict__.values()
             ]):
                 through_model = field.remote_field.through
                 if through_model._meta.auto_created and not_registered(
                         through_model):
                     through_model.history = HistoricalRecords()
                     register(through_model)
    def finalize(self, sender, **kwargs):
        try:
            hint_class = self.cls
        except AttributeError:  # called via `register`
            pass
        else:
            if hint_class is not sender:  # set in concrete
                if not (self.inherit and issubclass(sender, hint_class)):
                    return  # set in abstract
        if hasattr(sender._meta, 'simple_history_manager_attribute'):
            raise exceptions.MultipleRegistrationsError(
                '{}.{} registered multiple times for history tracking.'.format(
                    sender._meta.app_label,
                    sender._meta.object_name,
                ))
        if sender._meta.proxy:
            original_class = [
                base_class for base_class in sender.__bases__
                if base_class._meta.abstract is False
            ][0]
            # Parent model must be registered before the proxy model is
            if not_registered(original_class):
                # Ignore the `app` kwarg, since the proxy model may be in a different app than the original model
                register_kwargs = {
                    'manager_name': self.manager_name,
                    'records_class': self.__class__,
                    'verbose_name': self.user_set_verbose_name,
                    'bases': self.bases,
                    'user_related_name': self.user_related_name,
                    'm2m_fields': self.m2m_fields,
                }
                register(original_class, **register_kwargs)
            # Proxy models use their parent's history model
            history_model = getattr(sender, self.manager_name).model
        else:
            history_model = self.create_history_model(sender)
            module = importlib.import_module(self.module)
            setattr(module, history_model.__name__, history_model)
        # The HistoricalRecords object will be discarded,
        # so the signal handlers can't use weak references.
        models.signals.post_save.connect(self.post_save,
                                         sender=sender,
                                         weak=False)
        models.signals.pre_delete.connect(self.pre_delete,
                                          sender=sender,
                                          weak=False)
        models.signals.post_delete.connect(self.post_delete,
                                           sender=sender,
                                           weak=False)
        models.signals.m2m_changed.connect(self.m2m_changed,
                                           sender=sender,
                                           weak=False)

        descriptor = HistoryDescriptor(history_model)
        setattr(sender, self.manager_name, descriptor)
        sender._meta.simple_history_manager_attribute = self.manager_name
Ejemplo n.º 8
0
 def setup_m2m_history(self, cls):
     m2m_history_fields = self.m2m_fields
     if m2m_history_fields:
         assert (isinstance(m2m_history_fields, list) or isinstance(m2m_history_fields, tuple)), 'm2m_history_fields must be a list or tuple'
         for field_name in m2m_history_fields:
             field = getattr(cls, field_name).field
             assert isinstance(field, models.fields.related.ManyToManyField), ('%s must be a ManyToManyField' % field_name)
             if not sum([isinstance(item, HistoricalRecords) for item in field.rel.through.__dict__.values()]):
                 field.rel.through.history = HistoricalRecords()
                 register(field.rel.through)
Ejemplo n.º 9
0
    def simple_history_custom_set_up(cls):
        """
        See note in class definition for explanation.

        This should be called in AppConfig.ready
        """
        register(cls)
        disconnect_simple_history_receiver_for_post_delete_signal(cls)
        audit_post_delete.connect(cls.post_delete,
                                  sender=cls,
                                  dispatch_uid=uuid4())
Ejemplo n.º 10
0
    def finalize(self, sender, **kwargs):
        try:
            hint_class = self.cls
        except AttributeError:  # called via `register`
            pass
        else:
            if hint_class is not sender:  # set in concrete
                if not (self.inherit and issubclass(sender, hint_class)):
                    return  # set in abstract
        if hasattr(sender._meta, 'simple_history_manager_attribute'):
            raise exceptions.MultipleRegistrationsError(
                '{}.{} registered multiple times for history tracking.'.format(
                    sender._meta.app_label,
                    sender._meta.object_name,
                )
            )
        if sender._meta.proxy:
            original_class = [base_class for base_class in sender.__bases__ if base_class._meta.abstract is False][0]
            # Parent model must be registered before the proxy model is
            if not_registered(original_class):
                # Ignore the `app` kwarg, since the proxy model may be in a different app than the original model
                register_kwargs = {
                    'manager_name': self.manager_name,
                    'records_class': self.__class__,
                    'verbose_name': self.user_set_verbose_name,
                    'bases': self.bases,
                    'user_related_name': self.user_related_name,
                    'm2m_fields': self.m2m_fields,
                }
                register(original_class, **register_kwargs)
            # Proxy models use their parent's history model
            history_model = getattr(sender, self.manager_name).model
        else:
            history_model = self.create_history_model(sender)
            module = importlib.import_module(self.module)
            setattr(module, history_model.__name__, history_model)
        # The HistoricalRecords object will be discarded,
        # so the signal handlers can't use weak references.
        models.signals.post_save.connect(self.post_save, sender=sender,
                                         weak=False)
        models.signals.pre_delete.connect(self.pre_delete, sender=sender,
                                          weak=False)
        models.signals.post_delete.connect(self.post_delete, sender=sender,
                                           weak=False)
        models.signals.m2m_changed.connect(self.m2m_changed, sender=sender, weak=False)

        descriptor = HistoryDescriptor(history_model)
        setattr(sender, self.manager_name, descriptor)
        sender._meta.simple_history_manager_attribute = self.manager_name
Ejemplo n.º 11
0
 def setup_m2m_history(self, cls):
     m2m_history_fields = [m2m.name for m2m in cls._meta.many_to_many]
     for attr in dir(cls):
         if hasattr(cls, attr) and hasattr(getattr(cls, attr), 'related') and getattr(cls,
                                                                                      attr).related.many_to_many:
             m2m_history_fields.append(attr)
     if m2m_history_fields:
         assert (isinstance(m2m_history_fields, list) or isinstance(m2m_history_fields,
                                                                    tuple)), 'm2m_history_fields must be a list or tuple'
     for field_name in m2m_history_fields:
         if hasattr(getattr(cls, field_name), 'field'):
             field = getattr(cls, field_name).field
         else:
             field = getattr(cls, field_name).related.field
         assert isinstance(field, models.fields.related.ManyToManyField), (
             '%s must be a ManyToManyField' % field_name)
         if field.rel.related_model._meta.db_table in registered_models \
             and field.rel.to._meta.db_table in registered_models:
             if not sum([isinstance(item, HistoricalRecords) for item in field.rel.through.__dict__.values()]) and \
                 not field.rel.through._meta.db_table in registered_models:
                 register(field.rel.through, is_m2m=True)
Ejemplo n.º 12
0
    def make_through_tables_of_followed_m2m_historical(self, cls, name):
        """
        Add HistoricalRecords to through tables of followed ManyToManyFields.
        """
        for attr_name in self.follow:
            try:
                field = getattr(cls, attr_name).field
            except AttributeError:
                # attr_name is a related_name, that follows backwards
                # a ForeignKey pointing to cls, not yet added to cls.
                continue

            if not isinstance(field, models.ManyToManyField):
                continue

            model = field.rel.through
            attrs = model.__dict__.values()
            historical = any([isinstance(a, HistoricalRecords) for a in attrs])

            if hasattr(model, name) or historical:
                continue

            setattr(model, name, HistoricalRecords(manual_trigger=True))
            simple_history.register(model, app=self.module.split('.')[0])
Ejemplo n.º 13
0
    def test_registering_with_tracked_abstract_base(self):
        class TrackedWithAbstractBaseToRegister(TrackedAbstractBaseA):
            pass

        with self.assertRaises(exceptions.MultipleRegistrationsError):
            register(TrackedWithAbstractBaseToRegister)
Ejemplo n.º 14
0
    date = models.DateTimeField()

    history = HistoricalRecords()

    @property
    def _history_date(self):
        return self.date


class Choice(models.Model):
    poll = models.ForeignKey(Poll)
    choice = models.CharField(max_length=200)
    votes = models.IntegerField()


register(Choice)


class Place(models.Model):
    name = models.CharField(max_length=100)


class Restaurant(Place):
    rating = models.IntegerField()

    updates = HistoricalRecords()


class Person(models.Model):
    name = models.CharField(max_length=100)
Ejemplo n.º 15
0
from simple_history import register


class Poll(models.Model):
    question = models.CharField(max_length=200)
    pub_date = models.DateTimeField('date published')

    history = HistoricalRecords()


class Choice(models.Model):
    poll = models.ForeignKey(Poll)
    choice = models.CharField(max_length=200)
    votes = models.IntegerField()

register(Choice)


class Place(models.Model):
    name = models.CharField(max_length=100)


class Restaurant(Place):
    rating = models.IntegerField()

    updates = HistoricalRecords()


class FileModel(models.Model):
    file = models.FileField(upload_to='files')
    history = HistoricalRecords()
Ejemplo n.º 16
0
import simple_history
from django.contrib.sites.models import Site
from modeltranslation.translator import translator, TranslationOptions
from core.models import SiteCustomization

simple_history.register(Site, app="core")


class SiteCustomizationTranslationOptions(TranslationOptions):
    fields = ("tagline", "description")


translator.register(SiteCustomization, SiteCustomizationTranslationOptions)
simple_history.register(SiteCustomization)
Ejemplo n.º 17
0
    class Meta:
        abstract = True
        app_label = "external"


class ExternalModel(models.Model):
    name = models.CharField(max_length=100)
    history = HistoricalRecords()


class ExternalModelRegistered(models.Model):
    name = models.CharField(max_length=100)


register(ExternalModelRegistered, app="simple_history.tests", manager_name="histories")


class ExternalModelWithCustomUserIdField(models.Model):
    name = models.CharField(max_length=100)
    history = HistoricalRecords(history_user_id_field=models.IntegerField(null=True))


class Poll(models.Model):
    """Test model for same-named historical models

    This model intentionally conflicts with the 'Polls' model in 'tests.models'.
    """

    history = HistoricalRecords(user_related_name="+")
Ejemplo n.º 18
0
        'title',
        'content',
        'autors',
        'priority',
        # 'types',
        'status',
        'File',
    )
    list_filter = ('data', )


@admin.register(ticketChat)
class ticketChatAdmin(admin.ModelAdmin):
    list_display = (
        'id',
        'post',
        'name',
        'body',
        'created',
        'updated',
    )
    list_filter = (
        'post',
        'created',
        'updated',
    )
    search_fields = ('name', )


register(dashBourdBd)
Ejemplo n.º 19
0
        """
        return not link.is_archive_eligible() and self.can_edit(link)

    def can_toggle_private(self, link):
        if not self.can_edit(link):
            return False
        if link.is_private and not self.is_staff and link.private_reason != 'user':
            return False
        return True

    def can_edit_registrar(self, registrar):
        return self.is_staff or self.registrar == registrar


# special history tracking for custom user object -- see http://django-simple-history.readthedocs.org/en/latest/reference.html
simple_history.register(LinkUser)

# This ugly business makes these functions available on logged-out users as well as logged-in,
# by monkeypatching Django's AnonymousUser object.
for func_name in ['can_view', 'can_edit', 'can_delete', 'can_toggle_private']:
    setattr(django.contrib.auth.models.AnonymousUser, func_name,
            getattr(LinkUser, func_name).__func__)


class FolderQuerySet(QuerySet):
    def user_access_filter(self, user):
        # personal folders
        filter = Q(owned_by=user)

        # folders owned by orgs in which the user a member
        orgs = user.get_orgs()
Ejemplo n.º 20
0
from simple_history.models import HistoricalRecords
from wagtail.documents.models import Document
from wagtail.snippets.models import register_snippet


@register_snippet
class SiteAlertBanner(models.Model):
    banner_text = models.CharField(max_length=255)
    banner_link = models.CharField(
        max_length=255,
        blank=True,
        null=True,
    )
    activated = models.BooleanField(default=False, )
    history = HistoricalRecords()

    def __str__(self):
        return self.banner_text

    def clean(self):
        activated_banner = SiteAlertBanner.objects.filter(
            activated=True, ).first()

        if activated_banner and self.id != activated_banner.id and self.activated:
            raise ValidationError(
                "You can only have one active banner at a time. "
                f"Currently the '{activated_banner}' banner is active")


register(Document, app=__package__)
Ejemplo n.º 21
0
 def test_accessor_override(self):
     register(UserAccessorOverride,
              user_related_name='my_history_model_accessor')
     assert hasattr(User, 'my_history_model_accessor')
Ejemplo n.º 22
0
 def test_reregister(self):
     with self.assertRaises(exceptions.MultipleRegistrationsError):
         register(Restaurant, manager_name='again')
Ejemplo n.º 23
0
            send_db_mail("TheArticlewaschangedin" +
                         str(datetime.now().date().strftime("%d%m%y")) + "" +
                         str(datetime.now().time().strftime("%H%M")),
                         users.email,
                         use_celery=False)
    else:
        MailTemplate.objects.create(
            name="The Article was created",
            subject="The Article was created in " +
            str(datetime.now().time().strftime("%H:%M")),
            message="The Article '" + str(field_value_name) +
            "' was created by " + str(field_value_user) + " in " +
            str(field_value_time) + ". The content of the '" +
            str(field_value_name) + "' is " + str(field_value_content),
            slug="The Article was created in " +
            str(datetime.now().date().strftime("%d/%m/%y")) + " " +
            str(datetime.now().time().strftime("%H:%M")),
            is_html=False,
        )
        for users in user_mails:
            send_db_mail("TheArticlewascreatedin" +
                         str(datetime.now().date().strftime("%d%m%y")) + "" +
                         str(datetime.now().time().strftime("%H%M")),
                         users.email,
                         use_celery=False)


signals.post_save.connect(check_model, sender=ArticleRevision)

register(ArticleRevision)
Ejemplo n.º 24
0
 def test_registering_with_tracked_abstract_base(self):
     with self.assertRaises(exceptions.MultipleRegistrationsError):
         register(InheritTracking4)
Ejemplo n.º 25
0
    date = models.DateTimeField()

    history = HistoricalRecords(cascade_delete_history=True)

    @property
    def _history_date(self):
        return self.date


class Choice(models.Model):
    poll = models.ForeignKey(Poll, on_delete=models.CASCADE)
    choice = models.CharField(max_length=200)
    votes = models.IntegerField()


register(Choice)


class Voter(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    choice = models.ForeignKey(Choice, on_delete=models.CASCADE, related_name="voters")

    def __str__(self):
        return "Voter object"


class HistoricalRecordsVerbose(HistoricalRecords):
    def get_extra_fields(self, model, fields):
        def verbose_str(self):
            return "%s changed by %s as of %s" % (
                self.history_object,
Ejemplo n.º 26
0
from django.db import models
from django.utils import timezone
from django.utils.http import urlquote
from django.utils.translation import ugettext_lazy as _
from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin, BaseUserManager
from django.contrib.auth.models import User

from django.core.urlresolvers import reverse
from django.template.defaultfilters import slugify

from .choices import SEX_TYPE 
from simple_history import register

register(User)


class CustomUserManager(BaseUserManager):

    def _create_user(self, email, password, is_staff, is_superuser, **extra_fields):
        now = timezone.now()
        if not email:
            raise ValueError('The given email must be set')
        email = self.normalize_email(email)
        user = self.model(email=email, is_staff=is_staff, is_superuser=is_superuser, last_login=now, date_joined=now, **extra_fields)
        user.set_password(password)
        user.save(using=self._db)
        return user

    def create_user(self,  password=None, **extra_fields):
        return self._create_user(email, password, False, False, **extra_fields)
Ejemplo n.º 27
0
    level = models.IntegerField()
    date = models.DateTimeField()

    history = HistoricalRecords()

    @property
    def _history_date(self):
        return self.date


class Choice(models.Model):
    poll = models.ForeignKey(Poll)
    choice = models.CharField(max_length=200)
    votes = models.IntegerField()

register(Choice)


class Voter(models.Model):
    user = models.ForeignKey(User)
    choice = models.ForeignKey(Choice, related_name='voters')


class HistoricalRecordsVerbose(HistoricalRecords):
    def get_extra_fields(self, model, fields):
        def verbose_str(self):
            return '%s changed by %s as of %s' % (
                self.history_object, self.history_user, self.history_date)

        extra_fields = super(
            HistoricalRecordsVerbose, self).get_extra_fields(model, fields)
Ejemplo n.º 28
0
            and it was created by a user or someone in the org.
        """
        return not link.is_archive_eligible() and self.can_edit(link)

    def can_toggle_private(self, link):
        if not self.can_edit(link):
            return False
        if link.is_private and not self.is_staff and link.private_reason != 'user':
            return False
        return True

    def can_edit_registrar(self, registrar):
        return self.is_staff or self.registrar == registrar

# special history tracking for custom user object -- see http://django-simple-history.readthedocs.org/en/latest/reference.html
simple_history.register(LinkUser)

# This ugly business makes these functions available on logged-out users as well as logged-in,
# by monkeypatching Django's AnonymousUser object.
for func_name in ['can_view', 'can_edit', 'can_delete', 'can_toggle_private']:
    setattr(django.contrib.auth.models.AnonymousUser, func_name, getattr(LinkUser, func_name).__func__)


class FolderQuerySet(QuerySet):
    def user_access_filter(self, user):
        # personal folders
        filter = Q(owned_by=user)

        # folders owned by orgs in which the user a member
        orgs = user.get_orgs()
        if orgs:
Ejemplo n.º 29
0
from simple_history import register


class Poll(models.Model):
    question = models.CharField(max_length=200)
    pub_date = models.DateTimeField('date published')

    history = HistoricalRecords()


class Choice(models.Model):
    poll = models.ForeignKey(Poll)
    choice = models.CharField(max_length=200)
    votes = models.IntegerField()

register(Choice)


class Place(models.Model):
    name = models.CharField(max_length=100)


class Restaurant(Place):
    rating = models.IntegerField()

    updates = HistoricalRecords()


class Person(models.Model):
    name = models.CharField(max_length=100)
Ejemplo n.º 30
0
import simple_history
from modeltranslation.translator import TranslationOptions, register

from . import models


@register(models.Retreat)
class RetreatTranslationOptions(TranslationOptions):
    fields = (
        'country',
        'state_province',
        'city',
        'address_line1',
        'address_line2',
    )


@register(models.Picture)
class PictureTranslationOptions(TranslationOptions):
    fields = ('name', )


simple_history.register(models.Retreat, inherit=True)
simple_history.register(models.Picture, inherit=True)
Ejemplo n.º 31
0
from django.db import models
from simple_history import register
from django.contrib.auth.models import User, Group

register(User)
register(Group)

# Create your models here.


class User(models.Model):
    username = models.CharField(max_length=16)
    avatar = models.FileField(upload_to='avatar')
Ejemplo n.º 32
0
 def ready(self):
     register(MyClass)
     register(MyClassAnother)
Ejemplo n.º 33
0
    date = models.DateTimeField()

    history = HistoricalRecords()

    @property
    def _history_date(self):
        return self.date


class Choice(models.Model):
    poll = models.ForeignKey(Poll)
    choice = models.CharField(max_length=200)
    votes = models.IntegerField()


register(Choice)


class Voter(models.Model):
    user = models.ForeignKey(User)
    choice = models.ForeignKey(Choice, related_name='voters')


class HistoricalRecordsVerbose(HistoricalRecords):
    def get_extra_fields(self, model, fields):
        def verbose_str(self):
            return '%s changed by %s as of %s' % (
                self.history_object, self.history_user, self.history_date)

        extra_fields = super(HistoricalRecordsVerbose,
                             self).get_extra_fields(model, fields)
Ejemplo n.º 34
0
 def test_accessor_override(self):
     register(UserAccessorOverride,
              user_related_name='my_history_model_accessor')
     assert hasattr(User, 'my_history_model_accessor')
Ejemplo n.º 35
0
 def test_accessor_default(self):
     register(UserAccessorDefault)
     assert not hasattr(User, 'historicaluseraccessordefault_set')
Ejemplo n.º 36
0
from django.contrib.auth.models import AbstractUser
from django.db import models
from simple_history import register
from baseapp.models import BaseModel

# Create your models here.


class LinkMan(BaseModel):
    user_real_name = models.CharField(max_length=20)

    def __str__(self):
        return str(self.user_real_name)


class MyUser(AbstractUser, LinkMan):
    online_hours = models.IntegerField(default=0)

    def __str__(self):
        return str(self.user_real_name)

register(LinkMan)
register(MyUser)
Ejemplo n.º 37
0
from __future__ import unicode_literals

from django.db import models
from simple_history import register


class ExternalModel4(models.Model):
    name = models.CharField(max_length=100)

    class Meta:
        app_label = 'external'

register(ExternalModel4, app='simple_history.tests',
         manager_name='histories')
Ejemplo n.º 38
0
from simple_history import register
from tagme.models import Tag, TaggedEntity

register(Tag)
register(TaggedEntity)
Ejemplo n.º 39
0
from kpc.models import Certificate, Licensee


class HistoryUser(get_user_model()):
    """
        Proxy User model here so we can register it
        with django-simple-history and necessary migrations
        are created within this app as opposed to within the
        Django auth app.
    """
    class Meta:
        proxy = True
        verbose_name = 'User'


register(HistoryUser)


class Profile(models.Model):
    """Store additional user information"""
    user = models.OneToOneField(
        settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    phone_number = models.CharField(max_length=32, blank=True)
    licensees = models.ManyToManyField(
        'kpc.Licensee', blank=True, related_name='contacts')

    history = HistoricalRecords()

    class Meta:
        permissions = (
            ('can_review_certificates', "Can Review all Certificates"),
Ejemplo n.º 40
0
    @property
    def recent_posts(self):
        try:
            recent_posts = self.posts.order_by("-id")[1:5]
        except IndexError:
            recent_posts = None
        return recent_posts

    @property
    def recent_comments(self):
        try:
            recent_comments = self.comments.all()[0:5]
        except IndexError:
            recent_comments = None
        return recent_comments

    @property
    def recent_results(self):
        try:
            recent_results = self.results.all()[1:5]
        except IndexError:
            recent_results = None
        return recent_results


register(User)

# ======================================================================================#
# enum help from
#   https://hackernoon.com/using-enum-as-model-field-choice-in-django-92d8b97aaa63
Ejemplo n.º 41
0
 def actual_decorator(model):
     simple_history.register(model, **kwargs)
     return model
Ejemplo n.º 42
0
 def test_reregister(self):
     with self.assertRaises(exceptions.MultipleRegistrationsError):
         register(Restaurant, manager_name='again')
Ejemplo n.º 43
0
    date = models.DateTimeField()

    history = HistoricalRecords(cascade_delete_history=True)

    @property
    def _history_date(self):
        return self.date


class Choice(models.Model):
    poll = models.ForeignKey(Poll, on_delete=models.CASCADE)
    choice = models.CharField(max_length=200)
    votes = models.IntegerField()


register(Choice)


class Voter(models.Model):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    choice = models.ForeignKey(Choice, on_delete=models.CASCADE, related_name="voters")

    def __str__(self):
        return "Voter object"


class HistoricalRecordsVerbose(HistoricalRecords):
    def get_extra_fields(self, model, fields):
        def verbose_str(self):
            return "%s changed by %s as of %s" % (
                self.history_object,
Ejemplo n.º 44
0
    level = models.IntegerField()
    date = models.DateTimeField()

    history = HistoricalRecords()

    @property
    def _history_date(self):
        return self.date


class Choice(models.Model):
    poll = models.ForeignKey(Poll)
    choice = models.CharField(max_length=200)
    votes = models.IntegerField()

register(Choice)


class Place(models.Model):
    name = models.CharField(max_length=100)


class Restaurant(Place):
    rating = models.IntegerField()

    updates = HistoricalRecords()


class Person(models.Model):
    name = models.CharField(max_length=100)
Ejemplo n.º 45
0
 def test_accessor_default(self):
     register(UserAccessorDefault)
     assert not hasattr(User, 'historicaluseraccessordefault_set')
Ejemplo n.º 46
0
    class Meta:
        abstract = True
        app_label = "external"


class ExternalModel(models.Model):
    name = models.CharField(max_length=100)
    history = HistoricalRecords()


class ExternalModelRegistered(models.Model):
    name = models.CharField(max_length=100)


register(ExternalModelRegistered,
         app="simple_history.tests",
         manager_name="histories")


class ExternalModelWithCustomUserIdField(models.Model):
    name = models.CharField(max_length=100)
    history = HistoricalRecords(history_user_id_field=models.IntegerField(
        null=True))


class Poll(models.Model):
    """Test model for same-named historical models

    This model intentionally conflicts with the 'Polls' model in 'tests.models'.
    """
Ejemplo n.º 47
0
 def test_registering_with_tracked_abstract_base(self):
     with self.assertRaises(exceptions.MultipleRegistrationsError):
         register(InheritTracking4)
Ejemplo n.º 48
0
import simple_history
from django.contrib.auth.models import Group
from modeltranslation.translator import translator, TranslationOptions
from accounts.models import User

simple_history.register(Group, app="accounts")


class UserTranslationOptions(TranslationOptions):
    pass


translator.register(User, UserTranslationOptions)
simple_history.register(
    User, excluded_fields=["date_joined", "last_login", "password"])
Ejemplo n.º 49
0
from simple_history import register
from .models import *

register(SourceMaterial)
register(Transcription)
register(DocumentScan)
Ejemplo n.º 50
0
#============================
# App imports
#----------------------------
from .helpers import *


#============================
# 3rd-party app imports
#----------------------------
from taggit.managers import TaggableManager
from taggit.models import Tag
from simple_history.models import HistoricalRecords
from simple_history import register

## register taggit for tracking its history
register(Tag)


#============================
# helpers
#----------------------------
# library_states = [
#     "not_ready",
#     "submission_ready",
#     "submitted",
#     "sequenced",
#     "resubmitted",
#     ]

class SequencingManager(models.Manager):
    def with_data(self):
Ejemplo n.º 51
0
from django.contrib import admin
from simple_history import register
from .models import *
from import_export.admin import ImportExportModelAdmin
# Register your models here.

register(User, app=__package__)
@admin.register(Student, Video, User, News, Video_Post, NoticeImage, Comment, videoF, FAQ_Answer, Stu_Task,NoteiceFire, Teach_Task, Feedback, MCQ_Post, MCQ_Question, MCQ_Answer, MCQ_Result)
class ViewAdmin(ImportExportModelAdmin):
    search_fields = ('userid', 'name','category', 'mobileNum')
    odering = ['name']
    # list_display = ( 
    # 			'regNum',
    # 			'name',
    # 			'mobileNum',
    #         	)
    
Ejemplo n.º 52
0
class institutionAdmin (SimpleHistoryAdmin):
    list_display = ('user', 'department')
    class Meta:
        model = Institution

class patientIdAdmin (SimpleHistoryAdmin):
    list_display = ('user', 'patient_id')
    class Meta:
        model = Patient_id

class aggregateAdmin (SimpleHistoryAdmin):
    list_display = ('center_id','name_of_center', 'author', 'pub_date')
    class Meta:
        model = Ext_centers

register(User, inherit=True)
register(Group, inherit=True)

#admin.site.register(User, SimpleHistoryAdmin)
admin.site.register(Institution, institutionAdmin)
admin.site.register(Patient_id, patientIdAdmin)
admin.site.register(Demographic, DemographicsAdmin)
admin.site.register(Diagnosis, DiagnosisAdmin)
admin.site.register(DiagnosisOption,diag_optAdmin)
admin.site.register(A_b_sickle_thal,a_b_sickle_Admin)
admin.site.register(Redcell_enzyme_dis,redcell_enzAdmin)
admin.site.register(Redcell_membrane_dis,redcell_memb_Admin)
admin.site.register(Cong_dyseryth_anaemia,cong_dyserAdmin)
admin.site.register(icd_10, icd10Admin)
admin.site.register(orphaCodes, orphaAdmin)
admin.site.register(Pregnancy,pregnancyAdmin)
Ejemplo n.º 53
0
from simple_history import register
from .models import *

register(Language)
register(BookFormat)
register(MaterialDetails)
register(Subject)
register(Work)
register(WorkSubject)
register(WorkAuthor)
register(Item)
register(ItemType)
register(ItemItemTypeRelation)
register(ItemAuthor)
register(ItemLanguageRelation)
register(ItemWorkRelation)
register(ItemMaterialDetailsRelation)
register(Edition)
register(Publisher)
register(PersonItemRelationRole)
register(PersonItemRelation)
Ejemplo n.º 54
0
@register(models.BaseProduct)
class BaseProductTranslationOptions(TranslationOptions):
    fields = (
        'name',
        'details',
    )


@register(models.Membership)
class MembershipTranslationOptions(TranslationOptions):
    fields = (
    )


@register(models.Package)
class PackageTranslationOptions(TranslationOptions):
    fields = (
    )


@register(models.OptionProduct)
class OptionProductTranslationOptions(TranslationOptions):
    fields = (
    )


simple_history.register(models.Membership, inherit=True)
simple_history.register(models.Package, inherit=True)
simple_history.register(models.BaseProduct, inherit=True)
simple_history.register(models.OptionProduct, inherit=True)