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)
