def setUp(self): """Sets up the TestModel.""" # Clear the database. Version.objects.all().delete() TestModel.objects.all().delete() # Register the model. reversion.register(TestModel)
def reversion_register(model_class, fields=None, follow=(), format="xml", exclude_fields=None): """CMS interface to reversion api - helper function. Registers model for reversion only if reversion is available. Auto excludes publisher fields. """ if not 'reversion' in settings.INSTALLED_APPS: return if fields and exclude_fields: raise ValueError("Just one of fields, exclude_fields arguments can be passed.") opts = model_class._meta local_fields = opts.local_fields + opts.local_many_to_many if fields is None: fields = [field.name for field in local_fields] exclude_fields = exclude_fields or [] if 'publisher' in settings.INSTALLED_APPS: from publisher import Publisher if issubclass(model_class, Publisher): # auto exclude publisher fields exclude_fields += ['publisher_is_draft', 'publisher_public', 'publisher_state'] import reversion #if exclude_fields: fields = filter(lambda name: not name in exclude_fields, fields) reversion.register(model_class, fields, follow, format)
def setUp(self): super(FollowModelsTest, self).setUp() reversion.unregister(ReversionTestModel1) reversion.register(ReversionTestModel1, follow=("testfollowmodel_set",)) reversion.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 __new__(cls, name, bases, attrs): if name in cls.plugins_with_extrafields: ExtraFieldsMixin.media = media_property(ExtraFieldsMixin) bases = (ExtraFieldsMixin,) + bases if name in cls.plugins_with_sharables: SharableGlossaryMixin.media = media_property(SharableGlossaryMixin) bases = (SharableGlossaryMixin,) + bases attrs['fields'] += (('save_shared_glossary', 'save_as_identifier'), 'shared_glossary',) attrs['sharable_fields'] = cls.plugins_with_sharables[name] base_model = SharableCascadeElement else: base_model = CascadeElement if name in getattr(settings, 'CASCADE_PLUGINS_WITH_EXTRA_RENDER_TEMPLATES').keys(): RenderTemplateMixin.media = media_property(RenderTemplateMixin) bases = (RenderTemplateMixin,) + bases model_mixins = attrs.pop('model_mixins', ()) if name == 'SegmentPlugin': # SegmentPlugin shall additionally inherit from configured mixin classes model_mixins += tuple(import_string(mc[0]) for mc in settings.CASCADE_SEGMENTATION_MIXINS) attrs['model'] = create_proxy_model(name, model_mixins, base_model) if is_installed('reversion'): import reversion if not reversion.is_registered(base_model): reversion.register(base_model) return super(CascadePluginBaseMetaclass, cls).__new__(cls, name, bases, attrs)
def __new__(cls, name, bases, attrs): if name in cls.plugins_with_extra_fields: ExtraFieldsMixin.media = media_property(ExtraFieldsMixin) bases = (ExtraFieldsMixin,) + bases if name in cls.plugins_with_sharables: SharableGlossaryMixin.media = media_property(SharableGlossaryMixin) bases = (SharableGlossaryMixin,) + bases attrs['fields'] += (('save_shared_glossary', 'save_as_identifier'), 'shared_glossary',) attrs['sharable_fields'] = cls.plugins_with_sharables[name] base_model = SharableCascadeElement else: base_model = CascadeElement if name in settings.CMSPLUGIN_CASCADE['plugins_with_extra_render_templates'].keys(): RenderTemplateMixin.media = media_property(RenderTemplateMixin) bases = (RenderTemplateMixin,) + bases model_mixins = attrs.pop('model_mixins', ()) if name == 'SegmentPlugin': # SegmentPlugin shall additionally inherit from configured mixin classes model_mixins += tuple(import_string(mc[0]) for mc in settings.CMSPLUGIN_CASCADE['segmentation_mixins']) module = attrs.get('__module__') app_label = attrs.get('app_label', module.split('.')[0]) attrs['model'] = create_proxy_model(name, app_label, model_mixins, base_model, module=module) if is_installed('reversion'): import reversion if not reversion.is_registered(base_model): reversion.register(base_model) # handle ambiguous plugin names by appending a symbol if 'name' in attrs and settings.CMSPLUGIN_CASCADE['plugin_prefix']: attrs['name'] = mark_safe_lazy(string_concat( settings.CMSPLUGIN_CASCADE['plugin_prefix'], " ", attrs['name'])) return super(CascadePluginBaseMetaclass, cls).__new__(cls, name, bases, attrs)
def register_model(model, follow = None): if not reversion.is_registered(model) and settings.USE_REVERSION: #print "registering model with reversion: ", model if follow is None: reversion.register(model) else: reversion.register(model, follow = follow)
def check_registration(self, test_model): # Register the model and test. reversion.register(test_model) self.assertTrue(reversion.is_registered(test_model)) self.assertRaises(RegistrationError, lambda: reversion.register(test_model)) self.assertTrue(test_model in reversion.get_registered_models()) self.assertTrue(isinstance(reversion.get_adapter(test_model), reversion.VersionAdapter))
def testFieldDictFieldFields(self): reversion.register(TestModel, fields=("name",)) with reversion.create_revision(): obj = TestModel.objects.create() self.assertEqual(Version.objects.get_for_object(obj).get().field_dict, { "name": "v1", })
def tearDown(self): # Unregister the test models. reversion.unregister(ReversionTestModel1) reversion.unregister(ReversionTestModel2) reversion.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 reversion.get_registered_models(): reversion.unregister(registered_model) # Re-register initial registered models. for initial_model, adapter in self.initial_registered_models: reversion.register(initial_model, adapter_cls=adapter) del self.initial_registered_models
def setUp(self): super(MultiTableInheritanceApiTest, self).setUp() reversion.register(ReversionTestModel1Child, follow=("reversiontestmodel1_ptr",)) with reversion.create_revision(): self.testchild1 = ReversionTestModel1Child.objects.create( name = "modelchild1 instance1 version 1", )
def setUp(self): # Unregister all registered models. self.initial_registered_models = [] for registered_model in reversion.get_registered_models(): self.initial_registered_models.append((registered_model, reversion.get_adapter(registered_model).__class__)) reversion.unregister(registered_model) # Register the test models. reversion.register(ReversionTestModel1) reversion.register(ReversionTestModel2) # 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.user = User() if CUSTOM_USER_MODEL: setattr(self.user, User.USERNAME_FIELD, '1') else: self.user.username = "******"
def testCreateRevisionIgnoreDuplicates(self): reversion.register(TestModel, ignore_duplicates=True) with reversion.create_revision(): obj = TestModel.objects.create() with reversion.create_revision(): obj.save() self.assertSingleRevision((obj,))
def setUp(self): # Register the test models. reversion.register(ReversionTestModel1) reversion.register(ReversionTestModel2) # 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.user = User.objects.create( username = "******", ) # Since we're creating a user, we need to bias our assertions # depending on whether or not it will create versions/revisions for # self.user. self.registered_instance_offset = 0 if reversion.is_registered(User): self.registered_instance_offset = 1
def main(): options = get_options() if not options.app: app = pick_app() else: app = get_app(options.app) if not options.model: model = pick_model(app) else: model = get_model(app, options.model) try: reversion.register(model) except: pass if options.num: object = get_object(model, options.num) elif options.search: object = search_object(model, options.search) else: object = pick_object(model) ''' field = options.field if not field: field = pick_field(object) edit_object_old(object,field) ''' edit_object(model, object)
def testCreateRevisionFollow(self): reversion.unregister(TestModel) reversion.register(TestModel, follow=("related_instances",)) obj_2 = TestModel.objects.create() with reversion.create_revision(): obj_1 = TestModel.objects.create() obj_1.related_instances.add(obj_2) self.assertSingleRevision((obj_1, obj_2))
def testFieldDictFieldExclude(self): reversion.register(TestModel, exclude=("name",)) with reversion.create_revision(): obj = TestModel.objects.create() self.assertEqual(Version.objects.get_for_object(obj).get().field_dict, { "id": obj.pk, "related": [], })
def testCreateRevisionFollow(self): reversion.register(TestModel, follow=("related",)) reversion.register(TestModelRelated) obj_related = TestModelRelated.objects.create() with reversion.create_revision(): obj = TestModel.objects.create() obj.related.add(obj_related) self.assertSingleRevision((obj, obj_related))
def testCanUnregisterModel(self): """Tests that a model can be unregistered.""" reversion.unregister(TestModel) self.assertFalse(reversion.is_registered(TestModel)) # Check that duplicate unregistration is disallowed. self.assertRaises(RegistrationError, lambda: reversion.unregister(TestModel)) # Re-register the model. reversion.register(TestModel)
def setUp(self): """Sets up the TestModel.""" # Clear the database. Version.objects.all().delete() TestModel.objects.all().delete() TestManyToManyModel.objects.all().delete() # Register the models. reversion.register(TestModel, follow=("testmanytomanymodel_set",)) reversion.register(TestManyToManyModel, follow=("relations",))
def setUp(self): super(ProxyModelApiTest, self).setUp() reversion.register(ReversionTestModel1Proxy) self.concrete = self.test11 self.proxy = ReversionTestModel1Proxy.objects.get(pk=self.concrete.pk) with reversion.create_revision(): self.proxy.name = "proxy model" self.proxy.save()
def setUp(self): """Sets up a versioned site model to test.""" reversion.register(Site) with reversion.revision: site = Site.objects.create(name="site", domain="www.site-rev-1.com") with reversion.revision: site.domain = "www.site-rev-2.com" site.save() self.site = site
def setUp(self): """Sets up the ReversionTestModel.""" # Clear the database. Revision.objects.all().delete() ReversionTestModel.objects.all().delete() TestRelatedModel.objects.all().delete() # Register the models. reversion.register(ReversionTestModel, follow=("testrelatedmodel_set",)) reversion.register(TestRelatedModel, follow=("relation",))
def setUp(self): """Sets up the ReversionTestModel.""" # Clear the database. Revision.objects.all().delete() self.model.objects.all().delete() # Register the model. reversion.register(self.model) # Create some initial revisions. self.test = self.model.objects.create(name="test1.0")
def register_with_reversion(cls): if not reversion: raise EnvironmentError("django-reversion is not installed") follow = [] for content_type_model in cls._feincms_content_types: related_manager = "%s_set" % content_type_model.__name__.lower() follow.append(related_manager) reversion.register(content_type_model) reversion.register(cls, follow=follow)
def _autoregister(self, model, follow=None): """Registers a model with reversion, if required.""" if not reversion.is_registered(model): follow = follow or [] for parent_cls, field in model._meta.parents.items(): if field: # Proxy models do not have a parent field. follow.append(field.name) self._autoregister(parent_cls) reversion.register(model, follow=follow, format=self.reversion_format)
def setUp(self): # Register the test models. reversion.register(ReversionTestModel1) reversion.register(ReversionTestModel2) # 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.user = User.objects.create(username="******")
def register_with_reversion(cls): try: import reversion 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()) reversion.register(content_type) reversion.register(cls, follow=follow)
def setUp(self): reversion.unregister(Car) reversion.unregister(Factory) reversion.register(Factory, follow=["cars"]) reversion.register(Car) super(FactoryCarReverseRelationModelTest, self).setUp() test_data = TestData(verbose=False) self.factory = test_data.create_Factory_reverse_relation_data() queryset = get_for_object(self.factory) self.version_ids = queryset.values_list("pk", flat=True)
def tearDown(self): # Unregister the test models. reversion.unregister(ReversionTestModel1) reversion.unregister(ReversionTestModel2) reversion.unregister(ReversionTestModel3) # Unregister all remaining models. for registered_model in reversion.get_registered_models(): reversion.unregister(registered_model) # Re-register initial registered models. for initial_model, adapter in self.initial_registered_models: reversion.register(initial_model, adapter_cls=adapter) del self.initial_registered_models
def setUp(self): self.table_types = [ ReversionTestModelPKAutoInt, ReversionTestModelPKBigInt, ReversionTestModelPKString, ReversionTestModelPKGuid, ReversionTestModelPKDecimal, ReversionTestModelPKFloat ] for table_type in self.table_types: reversion.register(table_type)
from django.db import models from django.conf import settings from django.dispatch import receiver from django.db.models.signals import post_save from taggit.managers import TaggableManager import mistune # bbcode import reversion User = settings.AUTH_USER_MODEL import taggit reversion.register(taggit.models.Tag) class Profile(models.Model): user = models.OneToOneField(User, on_delete=models.CASCADE) long_name = models.TextField(max_length=500, default="",blank=True) bio = models.TextField(max_length=500, default="",blank=True) @receiver(post_save, sender=User) def create_user_profile(sender, instance, created, **kwargs): if created: Profile.objects.create(user=instance) @receiver(post_save, sender=User) def save_user_profile(sender, instance, **kwargs): instance.profile.save() renderer = mistune.Renderer(escape=True) markdown = mistune.Markdown(renderer=renderer) from core.mdRenderer import markdown, toc
"""Return overrwriten url, or None """ if self.has_url_overwrite: return self.path return None class EmptyTitle(object): """Empty title object, can be returned from Page.get_title_obj() if required title object doesn't exists. """ title = "" slug = "" path = "" meta_description = "" meta_keywords = "" redirect = "" has_url_overwite = False application_urls = "" menu_title = "" page_title = "" @property def overwrite_url(self): return None if 'reversion' in settings.INSTALLED_APPS: import reversion reversion.register(Title)
:returns: The type of ballot that is used in this subconstituency. """ if self.ballot_women: return _('Women') elif self.ballot_general: if self.ballot_component: return _('General and Component') return _('General') else: return _('Undefined') def get_ballot(self): """Return the form type of ballots used in this subconstituency. :returns: The type of ballot that is used in this subconstituency. """ if self.ballot_women: return self.ballot_women elif self.ballot_general: if self.ballot_component: return self.ballot_component return self.ballot_general else: return None reversion.register(SubConstituency)
from django.contrib.auth.models import User from django.db import models import reversion from tally_ho.apps.tally.models.result_form import ResultForm from tally_ho.libs.models.base_model import BaseModel class Archive(BaseModel): class Meta: app_label = 'tally' result_form = models.ForeignKey(ResultForm) user = models.ForeignKey(User) reversion.register(Archive)
def testCanRegisterModel(self): """Tests that a model can be registered.""" self.assertTrue(reversion.is_registered(TestModel)) # Check that duplicate registration is disallowed. self.assertRaises(RegistrationError, lambda: reversion.register(TestModel))
if data.get('prefilter_effect_tag') is True: prefilters["effects__in"] = data.get("effect_tags", []) if self.getFormName() == "CrossviewForm" and data.get('published_only') is True: prefilters["animal_group__experiment__study__published"] = True return json.dumps(prefilters) def getChoices(self, field_name): assessment_id = self.form.instance.assessment_id choices = None if field_name == "systems": choices = list(Endpoint.get_system_choices(assessment_id)) elif field_name == "effects": choices = list(Endpoint.get_effect_choices(assessment_id)) elif field_name == "effect_tags": choices = EffectTag.get_choices(assessment_id) elif field_name == "studies": choices = Study.get_choices(assessment_id) else: raise ValueError("Unknown field name: {}".format(field_name)) return choices reversion.register(SummaryText) reversion.register(DataPivotUpload) reversion.register(DataPivotQuery) reversion.register(Visual)
if self.addressNumber: r += u' %s' % self.addressNumber if self.addressLine2: r += u' %s' % self.addressLine2 if self.zipCode: r += u' CEP %s' % self.zipCode if self.neighborhood: r += u' - %s' % self.neighborhood if self.city: r += u' - %s' % self.city.name if hasattr(self.city, 'state') and self.city.state: r += u' / %s' % self.city.state.shortName if hasattr(self.city.state, 'country') and self.city.state.country: r += u' / %s' % self.city.state.country.name if self.addressType: r += u' - (%s)' % self.addressType return r reversion.register(Address)
def testRegister(self): reversion.register(TestModel) self.assertTrue(reversion.is_registered(TestModel))
def testCreateRevisionInheritance(self): reversion.register(TestModelParent, follow=("testmodel_ptr", )) with reversion.create_revision(): obj = TestModelParent.objects.create() self.assertSingleRevision((obj, obj.testmodel_ptr))
def testCreateRevisionFollowInvalid(self): reversion.register(TestModel, follow=("name", )) with reversion.create_revision(): with self.assertRaises(reversion.RegistrationError): TestModel.objects.create()
null=True, blank=True, default=0) # Comments team_comment = models.TextField(null=True, blank=True) supervisor_comment = models.TextField(null=True, blank=True) def get_problems(self): problem_fields = { _('Center Name Missing'): self.center_name_missing, _('Center Name Mismatching'): self.center_name_mismatching, _('Center Code Missing'): self.center_code_missing, _('Station Number Mismatching'): self.center_code_mismatching, _('Form Already in System'): self.form_already_in_system, _('Form Incorrectly Entered into the System'): self.form_incorrectly_entered_into_system, _('Other'): self.other, } return keys_if_value(problem_fields) def action_prior_name(self): return ActionsPrior.label(self.action_prior_to_recommendation) def resolution_recommendation_name(self): return ClearanceResolution.label(self.resolution_recommendation) reversion.register(Clearance)
def setUp(self): super(TestModelParentMixin, self).setUp() reversion.register(TestModelParent, follow=("testmodel_ptr", ))
except CustomGroup.DoesNotExist: return False @property def is_county_level(self): try: return CustomGroup.objects.get(group=self).county_level except CustomGroup.DoesNotExist: return False @property def is_sub_county_level(self): try: return CustomGroup.objects.get(group=self).sub_county_level except CustomGroup.DoesNotExist: return False class Meta: proxy = True def __str__(self): return self.name # model registration done here reversion.register(MFLOAuthApplication, follow=['user']) reversion.register(Permission) reversion.register(Group, follow=['permissions']) reversion.register(MflUser, follow=['groups', 'user_permissions']) reversion.register(CustomGroup, follow=['group'])
for rol in membership.roles.all(): for perm in rol.permissions.all(): if perm in permisos_us: assign_perm(perm.codename, self.desarrollador, self) class Meta: verbose_name_plural = 'user stories' default_permissions = () permissions = (('edit_my_userstory', 'editar mis userstories'), ('registraractividad_my_userstory', 'registrar avances en mis userstories')) reversion.register(UserStory, fields=[ 'nombre', 'descripcion', 'prioridad', 'valor_negocio', 'valor_tecnico', 'tiempo_estimado' ]) #importamos recién acá la señal para que no haya la dependencia circular entre la señal y UserStory from definicion.signals import add_permissions_team_member m2m_changed.connect(add_permissions_team_member, sender=MiembroEquipo.roles, dispatch_uid='add_permissions_signal') class Nota(models.Model): """ Manejo de notas adjuntas relacionadas a un User Story, estás entradas representan constancias de los cambios, como cantidad de horas trabajadas, en un user story. """ estado_choices = (
:param csvwriter: csv object """ row = [ "account", self.username.encode("utf-8"), self.password.encode("utf-8"), self.first_name.encode("utf-8"), self.last_name.encode("utf-8"), self.is_active, self.group, self.email.encode("utf-8") ] row += events.raiseQueryEvent("AccountExported", self) csvwriter.writerow(row) reversion.register(User) def populate_callback(user, group='SimpleUsers'): """Populate callback If the LDAP authentication backend is in use, this callback will be called each time a new user authenticates succesfuly to Modoboa. This function is in charge of creating the mailbox associated to the provided ``User`` object. :param user: a ``User`` instance """ from modoboa.lib.permissions import grant_access_to_object sadmins = User.objects.filter(is_superuser=True)
from django.db import models from django.contrib.auth.models import User import reversion class Box(models.Model): label = models.CharField(max_length=100, db_index=True) content = models.TextField(blank=True) created_by = models.ForeignKey(User, related_name="boxes") last_updated_by = models.ForeignKey(User, related_name="updated_boxes") def __unicode__(self): return self.label class Meta: verbose_name_plural = "boxes" reversion.register(Box)
class Meta: app_label = 'tally' def save(self, *args, **kwargs): """For the user to set their password if `reset_password` is True. """ if self.reset_password: self.set_password(self.username) super(UserProfile, self).save(*args, **kwargs) @property def get_edit_link(self): return getEditUserLink(self) if self else None @property def get_edit_tally_link(self): return getEditUserLink(self, True) if self else None @property def is_administrator(self): return groups.SUPER_ADMINISTRATOR in self.groups.values_list('name', flat=True) def __unicode__(self): return '%s - %s %s' % (self.username, self.first_name, self.last_name) reversion.register(UserProfile)
from django.contrib.auth.models import User from django.db import models from django.utils.translation import ugettext as _ import reversion from tally_ho.libs.models.base_model import BaseModel class QuarantineCheck(BaseModel): class Meta: app_label = 'tally' user = models.ForeignKey(User, null=True) name = models.CharField(max_length=256, unique=True) method = models.CharField(max_length=256, unique=True) value = models.FloatField() percentage = models.FloatField(default=100) def local_name(self): return _(self.name) reversion.register(QuarantineCheck)
def setUp(self): super().setUp() reversion.register(TestModelParent)
'full_name': self.guest.get_full_name() }) message_template = fo_get_template( host, 'enterprise/emails/acceptation.txt', True) message_context = Context({ 'invited': self.get_full_name(), 'guest': self.guest.get_full_name(), 'company': self.company.name, 'revocation_url': "%s%s" % (host, reverse('revoke_invitation', kwargs={'token': self.revocation_token})), 'EMAIL_BASE_TEMPLATE': select_template(fo_get_template(host, settings.EMAIL_BASE_TEMPLATE)), 'ADDRESS_TEMPLATE': select_template(fo_get_template(host, settings.COMPANY_ADDRESS)), }) message = message_template.render(message_context) send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [self.guest.email]) try: reversion.register(Clients) except reversion.revisions.RegistrationError: pass
return "{0} {1} {2}".format(self.fqdn, self.record_type(), str(self.ip_str)) def __repr__(self): return "<Address Record '{0}'>".format(str(self)) class AddressRecord(BaseAddressRecord, LabelDomainMixin): """ AddressRecord is the class that generates A and AAAA records >>> AddressRecord(label=label, domain=domain_object, ip_str=ip_str, ... ip_type=ip_type) """ ############################ # See Ip for all ip fields # ############################ id = models.AutoField(primary_key=True) template = ("{bind_name:$lhs_just} {ttl_} {rdclass:$rdclass_just} " "{rdtype:$rdtype_just} {ip_str:$rhs_just}") class Meta: db_table = "address_record" unique_together = ("label", "domain", "fqdn", "ip_upper", "ip_lower", "ip_type") reversion.register(AddressRecord)
def speakers(self): yield self.speaker for speaker in self.additional_speakers.exclude( additionalspeaker__status=AdditionalSpeaker. SPEAKING_STATUS_DECLINED): yield speaker def notification_email_context(self): return { "title": self.title, "speaker": self.speaker.name, "kind": self.kind.name, } reversion.register(ProposalBase) 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")), ] speaker = models.ForeignKey("speakers.Speaker")
def setUp(self): """Sets up the TestModel.""" reversion.register(TestModel)
def _name_parts(self): empty = "" return { 'position': "{}".format(self.position) if self.position else empty, 'title': "{} ".format(self.TITLES.get(self.title)) if self.title else empty, 'maiden': "{} ".format(self.maiden_name.upper()) if self.maiden_name else empty, 'first': "{} ".format(self.first_name.title()) if self.first_name else empty, 'first_i': "{}. ".format(self.first_name[0].title()) if self.first_name else empty, 'middle': "{} ".format(self.middle_name.title()) if self.middle_name else empty, 'middle_i': "{} ".format(self.middle_name[0].title()) if self.middle_name else empty, 'last': "{} ".format(self.last_name.upper()) if self.last_name else empty, 'access': self.get_access(), } reversion.register(Provider)
def testRegisterAlreadyRegistered(self): reversion.register(TestModel) with self.assertRaises(reversion.RegistrationError): reversion.register(TestModel)
class InstitutionType(models.Model): """ This class represents an institution type. @author: Danilo S. Sanches @version: 1.0 """ description = models.CharField(max_length=50, null=True) def __unicode__(self): return u"%s" % self.description class Meta: ordering = ['description'] reversion.register(InstitutionType) class PostGraduate(models.Model): """ An instance of this class represents the postgraduate of careprofessional. This instance is relation on with careprofessional's academic resume @author: Danilo S. Sanches @version: 1.0 """ description = models.CharField(max_length=50, null=True) def __unicode__(self): return u"%s" % self.description class Meta: ordering = ['description']
comments = models.CharField(max_length=200) durability = models.CharField(max_length=1, choices=DURABILITY_TYPE) prof_restriction = models.ForeignKey(Profession, null=True) mobility = models.CharField(max_length=1, choices=MOBILITY_TYPE) place = models.ForeignKey(Place, null=True) room = models.ForeignKey(Room, null=True) device = models.ForeignKey(Device) active = models.BooleanField(default=True) objects = DeviceDetailsManager() class Meta: ordering = ['brand'] permissions = (("devicedetails_write", "Can write device details"), ) def __unicode__(self): device_type = _("Type") device_model = _("Model") device_part_number = _("Part number") return u"%s: %s - %s: %s - %s: %s" % \ (device_type, self.device.description, device_model, self.model, device_part_number, self.part_number) def revision(self): return reversion.get_for_object(self).order_by( '-revision__date_created').latest( 'revision__date_created').revision reversion.register(DeviceDetails, follow=['device']) reversion.register(Device)
class Meta: app_label = 'disturbance' ordering = ('-when', ) @classmethod def log_action(cls, approval, action, user): return cls.objects.create(approval=approval, who=user, what=str(action)) approval = models.ForeignKey(Approval, related_name='action_logs') @receiver(pre_delete, sender=Approval) def delete_documents(sender, instance, *args, **kwargs): for document in instance.documents.all(): try: document.delete() except: pass import reversion reversion.register(Approval, follow=['documents', 'approval_set', 'action_logs']) reversion.register(ApprovalDocument) reversion.register(ApprovalLogDocument, follow=['documents']) reversion.register(ApprovalLogEntry) reversion.register(ApprovalUserAction)
has already been removed if we're deleting a domain). :param bool keepdir: delete the mailbox home dir on the filesystem or not """ try: q = Quota.objects.get(username=self.full_address) except Quota.DoesNotExist: pass else: q.delete() if not keepdir: self.delete_dir() super(Mailbox, self).delete() reversion.register(Mailbox) @receiver(pre_delete, sender=Mailbox) def mailbox_deleted_handler(sender, **kwargs): """``Mailbox`` pre_delete signal receiver In order to properly handle deletions (ie. we don't want to leave orphan records into the db), we define this custom receiver. It manually removes the mailbox from the aliases it is linked to and then remove all empty aliases. """ from modoboa.lib.permissions import ungrant_access_to_object mb = kwargs['instance']
def setUp(self): super(TestModelMixin, self).setUp() reversion.register(TestModel)