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 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(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 _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 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 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 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')
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)