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 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 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 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 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 ready(self):
super(ProfilesConfig, self).ready()
from reversion import revisions as reversion
from apps.profiles.models import Privacy
reversion.register(Privacy)
def register_processes():
try:
from reversion import revisions
except ImportError:
pass
else:
for model in utils.get_processes():
if not revisions.is_registered(model):
revisions.register(model)
def setUp(self):
super(ProxyModelApiTest, self).setUp()
register(ReversionTestModel1Proxy)
self.concrete = self.test11
self.proxy = ReversionTestModel1Proxy.objects.get(pk=self.concrete.pk)
with create_revision():
self.proxy.name = "proxy model"
self.proxy.save()
def register_workflows():
try:
from reversion import revisions
except ImportError:
pass
else:
for workflow in utils.get_workflows():
if not revisions.is_registered(workflow):
revisions.register(workflow)
def setUp(self):
super(ProxyModelApiTest, self).setUp()
register(ReversionTestModel1Proxy)
self.concrete = self.test11
self.proxy = ReversionTestModel1Proxy.objects.get(pk=self.concrete.pk)
with create_revision():
self.proxy.name = "proxy model"
self.proxy.save()
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 setUp(self):
super(FollowModelsTest, self).setUp()
unregister(ReversionTestModel1)
register(ReversionTestModel1, follow=("testfollowmodel_set",))
register(TestFollowModel, follow=("test_model_1", "test_model_2s",))
self.follow1 = TestFollowModel.objects.create(
name = "related instance1 version 1",
test_model_1 = self.test11,
)
self.follow1.test_model_2s.add(self.test21, self.test22)
def ready(self):
super(OfflineConfig, self).ready()
from chunks.models import Chunk
from reversion import revisions as reversion
import apps.offline.signals # noqa: F401
from apps.offline.models import Issue # noqa: F401
reversion.register(Chunk)
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 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 ready(self):
super(AuthenticationConfig, self).ready()
from reversion import revisions as reversion
from watson import search as watson
import apps.authentication.signals # noqa: F401
from apps.authentication.models import OnlineUser, RegisterToken
reversion.register(RegisterToken)
watson.register(OnlineUser,
fields=("first_name", "last_name", "ntnu_username",
"nickname"))
def setUp(self):
super(FollowModelsTest, self).setUp()
unregister(ReversionTestModel1)
register(ReversionTestModel1, follow=("testfollowmodel_set", ))
register(TestFollowModel, follow=(
"test_model_1",
"test_model_2s",
))
self.follow1 = TestFollowModel.objects.create(
name="related instance1 version 1",
test_model_1=self.test11,
)
self.follow1.test_model_2s.add(self.test21, self.test22)
def ready(self):
super(OfflineConfig, self).ready()
from reversion import revisions as reversion
# The following stops pycharm from nagging about unused import statement
# noinspection PyUnresolvedReferences
import apps.offline.signals # flake8: noqa
from chunks.models import Chunk
from apps.offline.models import Issue
reversion.register(Chunk)
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_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 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 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 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 ready(self):
super(AuthenticationConfig, self).ready()
# The following stops pycharm from nagging about unused import statement
# noinspection PyUnresolvedReferences
import apps.authentication.signals # noqa: F401
from reversion import revisions as reversion
from watson import search as watson
from apps.authentication.models import OnlineUser, RegisterToken
reversion.register(RegisterToken)
watson.register(OnlineUser,
fields=('first_name', 'last_name', 'ntnu_username',
'nickname'))
def register_concept_reversions(concept_class, *args, **kwargs):
from reversion import revisions as reversion
follows = kwargs.get('reversion', {}).get('follow', [])
# Register the concept with reversion
reversion.register(concept_class,
follow=follows,
format='aristotle_mdr_json')
follow_classes = kwargs.get('reversion', {}).get('follow_classes', [])
for cls in follow_classes:
reversion.register(cls)
if reversion.is_registered(_concept):
reversion.unregister(_concept)
def 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 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 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 ready(self):
super(FeedbackConfig, self).ready()
from reversion import revisions as reversion
from apps.feedback.models import (
FieldOfStudyAnswer,
MultipleChoiceAnswer,
RatingAnswer,
RegisterToken,
TextAnswer,
)
reversion.register(FieldOfStudyAnswer)
reversion.register(MultipleChoiceAnswer)
reversion.register(RatingAnswer)
reversion.register(RegisterToken)
reversion.register(TextAnswer)
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 icsw_register(model):
"""Registers model with reversion plus additional deletion log.
Also makes sure that a revision is created if save() is called manually outside of a revision contact
"""
reversion.register(model)
icsw_deletion_record.register(model)
icsw_register.REGISTERED_MODELS.append(model)
def create_save_with_reversion(original_save):
def save_with_reversion(*args, **kwargs):
if not reversion.is_active():
with reversion.create_revision():
original_save(*args, **kwargs)
else:
original_save(*args, **kwargs)
return save_with_reversion
model.save = create_save_with_reversion(model.save)
def setUp(self):
# Unregister all registered models.
self.initial_registered_models = []
for registered_model in get_registered_models():
self.initial_registered_models.append((registered_model, get_adapter(registered_model).__class__))
unregister(registered_model)
# Register the test models.
register(ReversionTestModel1)
register(ReversionTestModel2)
register(ReversionTestModel3, eager_signals=[pre_delete])
# 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.test31 = ReversionTestModel3.objects.create(
name = "model3 instance1 version1",
)
self.test32 = ReversionTestModel3.objects.create(
name = "model3 instance2 version1",
)
self.user = User.objects.create(
username = "******",
)
def setUp(self):
# Unregister all registered models.
self.initial_registered_models = []
for registered_model in get_registered_models():
self.initial_registered_models.append(
(registered_model, get_adapter(registered_model).__class__))
unregister(registered_model)
# Register the test models.
register(ReversionTestModel1)
register(ReversionTestModel2)
register(ReversionTestModel3, eager_signals=[pre_delete])
# 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.test31 = ReversionTestModel3.objects.create(
name="model3 instance1 version1", )
self.test32 = ReversionTestModel3.objects.create(
name="model3 instance2 version1", )
self.user = User.objects.create(username="******", )
def ready(self):
super().ready()
from reversion import revisions as reversion
from apps.feedback.models import (
FieldOfStudyAnswer,
MultipleChoiceAnswer,
RatingAnswer,
RegisterToken,
TextAnswer,
)
reversion.register(FieldOfStudyAnswer)
reversion.register(MultipleChoiceAnswer)
reversion.register(RatingAnswer)
reversion.register(RegisterToken)
reversion.register(TextAnswer)
# The following stops pycharm from nagging about unused import statement
# noinspection PyUnresolvedReferences
import apps.feedback.signals # noqa: F401
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)
def ready(self):
from workflow.receivers import * # noqa
from .models import (StateMachine,
State,
Transition,
TransitionTask,
AvailableTask,)
reversion.register(StateMachine)
reversion.register(State)
reversion.register(TransitionTask)
reversion.register(AvailableTask)
if hasattr(settings, 'WORKFLOW_AUTO_LOAD') and settings.WORKFLOW_AUTO_LOAD:
logging.debug('Autoloading tasks.')
try:
from .task_runner import AvailableTaskLoader
atl = AvailableTaskLoader()
atl.load()
except:
logging.debug('Autoloading failed. If this is a migration, dont worry')
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)
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")),
]
"""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)
@python_2_unicode_compatible
class SenderAddress(models.Model):
"""Extra sender address for Mailbox."""
address = models.EmailField()
mailbox = models.ForeignKey(Mailbox)
class Meta:
app_label = "admin"
unique_together = [
("address", "mailbox"),
]
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)
except:
return ''
def translation_edit_url(self):
return reverse('admin:add_edit_translation_'+self.parent._meta.model_name, kwargs={'page_id':self.parent.id, 'language_code':self.language_code})
def translation_revision_url(self):
return reverse('admin:translation_revision_'+self.parent._meta.model_name, kwargs={'page_id':self.parent.id, 'language_code':self.language_code, 'translation_id':self.id})
def translation_recover_url(self):
return '%stranslation/%s/%s/recover' % (reverse('admin:'+self.parent._meta.app_label+'_'+self.parent._meta.model_name+'_changelist'), self.parent.id, self.language_code)
class PageTranslation(BasePageTranslation):
parent = models.ForeignKey('Page', related_name='translations')
reversion.register(PageTranslation)
class BaseDataSet(models.Model):
name = models.CharField(max_length=50)
config = models.TextField()
class Meta:
verbose_name=_('Data set')
verbose_name_plural=_('Data sets')
abstract = True
def __str__(self):
return u'%s' % self.name
def get_fields(self):
from reversion import revisions as reversion
from devices.models import Device
from users.models import Department, Lageruser
@six.python_2_unicode_compatible
class IpAddress(models.Model):
address = models.GenericIPAddressField(unique=True)
device = models.ForeignKey(Device, blank=True, null=True, on_delete=models.SET_NULL)
user = models.ForeignKey(Lageruser, blank=True, null=True, on_delete=models.SET_NULL)
last_seen = models.DateTimeField(null=True, blank=True)
purpose = models.CharField(max_length=200, null=True, blank=True)
department = models.ForeignKey(Department, null=True, blank=True, on_delete=models.CASCADE)
def __str__(self):
return self.address
class Meta:
verbose_name = _('IP-Address')
verbose_name_plural = _('IP-Addresses')
permissions = (
("read_ipaddress", _("Can read IP-Address")),
)
def get_absolute_url(self):
return reverse('ipaddress-detail', kwargs={'pk': self.pk})
reversion.register(IpAddress, exclude=["last_seen"])
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)
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)
return self.choices.aggregate(Sum('votes')).get('votes__sum')
@property
def meta_information_html(self):
template = loader.get_template('polls_meta_information.html')
return template.render({'document': self})
def handle_edit(self, cleaned_data):
content_type = ContentType.objects.get_for_model(self)
groups = cleaned_data['vote_groups']
for group in groups:
assign_perm("{app}.view_{model}".format(app=content_type.app_label, model=content_type.model), group, self)
assign_perm("{app}.vote_{model}".format(app=content_type.app_label, model=content_type.model), group, self)
revisions.register(Poll, follow=["document_ptr"])
class Choice(models.Model):
poll = models.ForeignKey(Poll, related_name="choices")
text = models.CharField(max_length=255)
description = models.TextField(default="", blank=True)
votes = models.IntegerField(default=0)
index = models.IntegerField(verbose_name=_("ordering index"), default=0)
class Meta:
ordering = ['index']
def __str__(self):
return self.text
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,
self.street_address, self.postal_code, self.address_locality
])
return u', '.join(values)
@transaction.atomic
def save(self, *args, **kwargs):
super().save(*args, **kwargs)
if self.position:
self.divisions = AdministrativeDivision.objects.filter(
type__type__in=('district', 'sub_district', 'neighborhood', 'muni'),
geometry__boundary__contains=self.position)
else:
self.divisions.clear()
reversion.register(Place)
class OpeningHoursSpecification(models.Model):
GR_BASE_URL = "http://purl.org/goodrelations/v1#"
WEEK_DAYS = (
(1, "Monday"), (2, "Tuesday"), (3, "Wednesday"), (4, "Thursday"),
(5, "Friday"), (6, "Saturday"), (7, "Sunday"), (8, "PublicHolidays")
)
place = models.ForeignKey(Place, db_index=True,
related_name='opening_hours')
opens = models.TimeField(null=True, blank=True)
closes = models.TimeField(null=True, blank=True)
days_of_week = models.SmallIntegerField(choices=WEEK_DAYS, null=True,
blank=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')
)
self.enabled = (row[4].strip().lower() in ["true", "1", "yes", "y"])
core_signals.can_create_object.send(
sender=self.__class__, context=user, klass=Domain,
instance=self)
self.save(creator=user)
def to_csv(self, csvwriter):
"""Export domain and domain aliases to CSV format."""
csvwriter.writerow([
"domain",
force_text(self.name),
self.quota,
self.default_mailbox_quota,
self.enabled
])
for dalias in self.domainalias_set.all():
dalias.to_csv(csvwriter)
def post_create(self, creator):
"""Post creation actions.
:param ``User`` creator: user whos created this domain
"""
super(Domain, self).post_create(creator)
for domalias in self.domainalias_set.all():
domalias.post_create(creator)
reversion.register(Domain)
from django.db import models
from django.utils.translation import ugettext_lazy as _
from . import backends
class Transport(models.Model):
"""Transport table."""
pattern = models.CharField(_("pattern"), unique=True, max_length=254)
service = models.CharField(_("service"), max_length=30)
next_hop = models.CharField(_("next hop"), max_length=100, blank=True)
_settings = jsonfield.JSONField(default={})
class Meta:
ordering = ["pattern"]
def __str__(self):
return self.pattern
@property
def backend(self):
"""Shortcut to access backend."""
if not self.service:
return None
return backends.manager.get_backend(self.service)
reversion.register(Transport)
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"
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)
content = models.TextField()
authors = models.ManyToManyField(Profile, blank=True)
problem = models.ForeignKey(Problem, on_delete=models.SET_NULL, verbose_name=_('Associated problem'),
null=True, blank=True)
def get_absolute_url(self):
return reverse('solution', args=[self.url])
def __unicode__(self):
return self.title
class Meta:
permissions = (
('see_private_solution', 'See hidden solutions'),
)
verbose_name = _('solution')
verbose_name_plural = _('solutions')
revisions.register(Profile, exclude=['points', 'last_access', 'ip', 'rating'])
revisions.register(Problem, follow=['language_limits'])
revisions.register(LanguageLimit)
revisions.register(Contest, follow=['contest_problems'])
revisions.register(ContestProblem)
revisions.register(Organization)
revisions.register(BlogPost)
revisions.register(Solution)
revisions.register(Judge, fields=['name', 'created', 'auth_key', 'description'])
revisions.register(Language)
revisions.register(Comment, fields=['author', 'time', 'page', 'score', 'title', 'body', 'hidden', 'parent'])
return u', '.join(values)
@transaction.atomic
def save(self, *args, **kwargs):
super().save(*args, **kwargs)
if self.position:
self.divisions = AdministrativeDivision.objects.filter(
type__type__in=('district', 'sub_district', 'neighborhood',
'muni'),
geometry__boundary__contains=self.position)
else:
self.divisions.clear()
reversion.register(Place)
class OpeningHoursSpecification(models.Model):
GR_BASE_URL = "http://purl.org/goodrelations/v1#"
WEEK_DAYS = ((1, "Monday"), (2, "Tuesday"), (3, "Wednesday"),
(4, "Thursday"), (5, "Friday"), (6, "Saturday"),
(7, "Sunday"), (8, "PublicHolidays"))
place = models.ForeignKey(Place,
db_index=True,
related_name='opening_hours')
opens = models.TimeField(null=True, blank=True)
closes = models.TimeField(null=True, blank=True)
days_of_week = models.SmallIntegerField(choices=WEEK_DAYS,
null=True,
if Alias.objects.filter(address=address).exists():
raise Conflict
self.address = address
self.domain = domain
self.enabled = (row[2].strip().lower() in ["true", "1", "yes", "y"])
self.save()
self.set_recipients([raddress.strip() for raddress in row[3:]])
self.post_create(user)
def to_csv(self, csvwriter):
row = ["alias", force_str(self.address), self.enabled]
row += self.recipients
csvwriter.writerow(row)
reversion.register(Alias)
@python_2_unicode_compatible
class AliasRecipient(models.Model):
"""An alias recipient."""
address = models.EmailField()
alias = models.ForeignKey(Alias)
# if recipient is a local mailbox
r_mailbox = models.ForeignKey(Mailbox, blank=True, null=True)
# if recipient is a local alias
r_alias = models.ForeignKey(
Alias, related_name="alias_recipient_aliases", blank=True, null=True)
