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'))
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"))
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 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
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)
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())
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
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)
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])
def test_registering_with_tracked_abstract_base(self): class TrackedWithAbstractBaseToRegister(TrackedAbstractBaseA): pass with self.assertRaises(exceptions.MultipleRegistrationsError): register(TrackedWithAbstractBaseToRegister)
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)
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()
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)
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="+")
'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)
""" 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()
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__)
def test_accessor_override(self): register(UserAccessorOverride, user_related_name='my_history_model_accessor') assert hasattr(User, 'my_history_model_accessor')
def test_reregister(self): with self.assertRaises(exceptions.MultipleRegistrationsError): register(Restaurant, manager_name='again')
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)
def test_registering_with_tracked_abstract_base(self): with self.assertRaises(exceptions.MultipleRegistrationsError): register(InheritTracking4)
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,
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)
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)
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:
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)
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)
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')
def ready(self): register(MyClass) register(MyClassAnother)
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)
def test_accessor_default(self): register(UserAccessorDefault) assert not hasattr(User, 'historicaluseraccessordefault_set')
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)
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')
from simple_history import register from tagme.models import Tag, TaggedEntity register(Tag) register(TaggedEntity)
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"),
@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
def actual_decorator(model): simple_history.register(model, **kwargs) return model
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)
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'. """
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"])
from simple_history import register from .models import * register(SourceMaterial) register(Transcription) register(DocumentScan)
#============================ # 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):
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', # )
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)
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)
@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)