class Subscription(StarterModel):
user = models.ForeignKey(settings.AUTH_USER_MODEL,
on_delete=models.CASCADE,
limit_choices_to=dict(is_staff=False,
is_superuser=False),
related_name='subscriptions')
payment_option = models.ForeignKey('payment.PaymentOption',
on_delete=models.PROTECT,
related_name='subscriptions')
status = EnumChoiceField(SubscriptionStatus,
default=SubscriptionStatus.ACTIVE,
max_length=32)
plan = EnumChoiceField(SubscriptionPlan, max_length=32)
cancelled_date = models.DateTimeField(null=True, blank=True)
payment_data = models.JSONField(default=dict)
objects = SubscriptionManager()
def get_period_item(self, date=None):
date = date or timezone.now()
try:
return self.subscription_period_items.get(
date_range__contains=date)
except self.DoesNotExist:
return None
@property
def last_use_date(self):
if self.status == SubscriptionStatus.ACTIVE:
period_item = self.get_period_item()
else:
period_item = self.subscription_period_items.get(
date_range__contains=self.cancelled_date)
return period_item.date_range.upper
def test_validate_raises_error_when_field_is_not_blank_and_value_is_empty(
self):
instance = EnumChoiceField(enum_class=CharTestEnum)
with self.assertRaisesMessage(ValidationError,
str(instance.error_messages['blank'])):
instance.validate('')
def test_validate_raises_error_when_value_is_not_from_enum_class(self):
instance = EnumChoiceField(enum_class=CharTestEnum)
expected = instance.error_messages['invalid_choice'] % {'value': 'foo'}
with self.assertRaisesMessage(ValidationError, expected):
instance.validate('foo')
def test_to_python_raises_exception_when_called_with_value_outside_enum_class(
self):
instance = EnumChoiceField(enum_class=CharTestEnum)
with self.assertRaisesMessage(
EnumChoiceFieldException,
f'Value NOT_EXISTING not found in {str(CharTestEnum)}'):
instance.to_python('NOT_EXISTING')
class CsvDialect(models.Model):
""" CSV file delimiter, quotechar and has_header information """
dataset = models.OneToOneField(Dataset,
on_delete=models.CASCADE,
related_name="csv_dialect")
delimiter = EnumChoiceField(Delimiter)
quotechar = EnumChoiceField(Quotechar)
has_header = models.BooleanField()
start_row = models.IntegerField(null=True)
class Occurrence(models.Model):
description = models.CharField(max_length=500)
# Couldn't install GDAL
location = models.CharField(max_length=200)
author = models.CharField(max_length=200)
date_creation = models.DateField()
date_update = models.DateField()
state = EnumChoiceField(State, default=State.A)
category = EnumChoiceField(Category)
def test_calculate_max_length_returns_longest_choice_length_if_length_not_provided_in_kwargs(
self):
class TestEnum(Enum):
FOO = 'foo'
BAR = 'A' * 100
field = EnumChoiceField(enum_class=TestEnum)
result = field._calculate_max_length(choices=field.build_choices())
self.assertEqual(100, result)
def test_build_choices_raises_exception_when_not_all_values_are_strings(
self):
instance = EnumChoiceField(enum_class=CharTestEnum)
instance.choice_builder = lambda x: (1, 1)
with self.assertRaisesMessage(
EnumChoiceFieldException,
'Received type {} on key inside choice: (1, 1).\n'.format(int)
+ 'All choices generated from {} must be strings.'.format(
CharTestEnum)):
instance.build_choices()
def test_calculate_max_length_returns_from_kwargs_if_provided_and_max_choice_length_is_less_than_provided(
self):
class TestEnum(Enum):
FOO = 'foo'
BAR = 'A' * 100
field = EnumChoiceField(enum_class=TestEnum)
result = field._calculate_max_length(choices=field.build_choices(),
max_length=150)
self.assertEqual(150, result)
def test_deconstruct_behaves_as_expected(self):
"""
Idea taken from:
https://docs.djangoproject.com/en/2.2/howto/custom-model-fields/#field-deconstruction
"""
instance = EnumChoiceField(enum_class=IntTestEnum)
name, path, args, kwargs = instance.deconstruct()
new_instance = EnumChoiceField(*args, **kwargs)
self.assertEqual(instance.enum_class, new_instance.enum_class)
self.assertEqual(instance.choices, new_instance.choices)
self.assertEqual(instance.max_length, new_instance.max_length)
def test_get_choice_builder_raises_exception_when_choice_builder_is_not_callable(
self):
class TestEnum(Enum):
A = 1
B = 2
choice_builder = 'choice_builder'
with self.assertRaisesMessage(
EnumChoiceFieldException,
'`TestEnum.choice_builder` must be a callable'):
instance = EnumChoiceField(enum_class=TestEnum)
instance._get_choice_builder(choice_builder)
class Setup(models.Model):
class Meta:
verbose_name = 'Setup'
verbose_name_plural = 'Setups'
title = models.CharField(max_length=70, blank=False)
status = EnumChoiceField(SetupStatus, default=SetupStatus.active)
created_at = models.DateTimeField(auto_now_add=True)
time_interval = EnumChoiceField(
TimeInterval, default=TimeInterval.five_mins)
task = models.OneToOneField(
PeriodicTask,
on_delete=models.CASCADE,
null=True,
blank=True
)
def delete(self, *args, **kwargs):
if self.task is not None:
self.task.delete()
return super(self.__class__, self).delete(*args, **kwargs)
def setup_task(self):
self.task = PeriodicTask.objects.create(
name=self.title,
task='computation_heavy_task',
interval=self.interval_schedule,
args=json.dumps([self.id]),
start_time=timezone.now()
)
self.save()
@property
def interval_schedule(self):
if self.time_interval == TimeInterval.five_secs:
return IntervalSchedule.objects.get(every=5, period='seconds')
if self.time_interval == TimeInterval.one_min:
return IntervalSchedule.objects.get(every=1, period='minutes')
if self.time_interval == TimeInterval.five_mins:
return IntervalSchedule.objects.get(every=5, period='minutes')
if self.time_interval == TimeInterval.one_hour:
return IntervalSchedule.objects.get(every=1, period='hours')
raise NotImplementedError(
'''Interval Schedule for {interval} is not added.'''.format(
interval=self.time_interval.value))
class Service(BaseModel):
class Meta:
app_label = 'core'
db_table = 'services'
default_permissions = ()
verbose_name = _('service')
verbose_name_plural = _('services')
class ServiceType(Enum):
POSTGRESQL = 'postgresql'
MYSQL = 'mysql'
MARIADB = 'mariadb'
LDAP = 'ldap'
REDIS = 'redis'
SSH = 'ssh'
ENV = 'env'
name = models.CharField(max_length=100,
unique=True,
null=False,
verbose_name=_('service_name'))
type = EnumChoiceField(ServiceType,
null=False,
default=ServiceType.SSH,
verbose_name=_('service_type'))
variables = AesJSONField(null=False,
default=dict,
verbose_name=_('service_variables'))
remote = models.ForeignKey('Remote',
null=False,
on_delete=models.CASCADE,
related_name='services',
verbose_name=_('service_remote'))
class ProfileSerializer(serializers.Serializer):
name = serializers.CharField(max_length=30, required=False)
surname = serializers.CharField(max_length=30, required=False)
city = serializers.CharField(max_length=30, required=False)
street = serializers.CharField(max_length=100, required=False)
flat_number = serializers.CharField(max_length=10, required=False)
postal_code = serializers.CharField(max_length=6, required=False)
sex = EnumChoiceField(Sex, null=True)
def update(self, instance, validated_data):
instance.name = validated_data.get('name', instance.name)
instance.surname = validated_data.get('surname', instance.surname)
instance.city = validated_data.get('city', instance.city)
instance.street = validated_data.get('street', instance.street)
instance.flat_number = validated_data.get('flat_number', instance.flat_number)
instance.postal_code = validated_data.get('postal_code', instance.postal_code)
instance.sex = validated_data.get('sex', instance.sex)
instance.save()
def is_valid(self, raise_exception=False, must_be_full_filled = False):
if must_be_full_filled:
if not (self.name and self.surname and self.city and self.street and self.flat_number and self.postal_code):
return False
return super().is_valid(raise_exception=raise_exception)
class Profile(models.Model):
name = models.CharField(null=True, max_length=30)
surname = models.CharField(null=True, max_length=30)
city = models.CharField(null=True, max_length=30)
street = models.CharField(null=True, max_length=100)
flat_number = models.CharField(null=True, max_length=10)
postal_code = models.CharField(null=True, max_length=6)
sex = EnumChoiceField(Sex)
#image = models.ImageField(null=True)
user = models.OneToOneField(User, on_delete=models.CASCADE)
@property
def is_filled(self):
if self.name == None:
return False
if self.surname == None:
return False
if self.city == None:
return False
if self.street == None:
return False
if self.flat_number == None:
return False
if self.postal_code == None:
return False
return True
objects = models.Manager()
def test_flatchoices_returns_enumerations_as_choice_keys(self):
instance = EnumChoiceField(enum_class=CharTestEnum)
result = instance.flatchoices
for choice, _ in result:
self.assertIsInstance(choice, CharTestEnum)
class SubscriptionPeriodItem(StarterModel):
subscription = models.ForeignKey(Subscription,
on_delete=models.CASCADE,
related_name='subscription_period_items')
date_range = DateTimeRangeField()
payment_status = EnumChoiceField(PaymentStatus,
default=PaymentStatus.PENDING,
max_length=32)
def test_display_for_field_returns_empty_display_when_value_is_none(self):
EMPTY_DISPLAY = 'EMPTY'
instance = EnumChoiceField(enum_class=CharTestEnum)
result = display_for_field(None, instance, EMPTY_DISPLAY)
self.assertEqual(EMPTY_DISPLAY, result)
def test_flatchoices_returns_readable_value_as_choice_value_when_autogenerated(
self):
instance = EnumChoiceField(enum_class=CharTestEnum)
result = instance.flatchoices
for choice, readable in result:
self.assertEqual(CharTestEnum(choice).value, readable)
class Column(models.Model):
""" Column datatypes, names and indexes associated with dataset """
dataset = models.ForeignKey(Dataset,
on_delete=models.CASCADE,
related_name="columns")
index = models.IntegerField()
name = models.CharField(max_length=50, blank=True)
datatype = EnumChoiceField(ColumnType)
def test_max_length_is_calculated_from_the_longest_element(self):
class TestEnum(Enum):
FOO = 'foo'
BAR = 'A' * 100
field = EnumChoiceField(enum_class=TestEnum)
self.assertEqual(100, field.max_length)
def test_custom_choice_builder_is_used_when_provided_and_callable(self):
def choice_builder(choice):
return choice.name, choice.value
instance = EnumChoiceField(enum_class=CharTestEnum,
choice_builder=choice_builder)
self.assertEqual(instance._original_choice_builder, choice_builder)
class OwfGroup(models.Model):
id = models.BigAutoField(primary_key=True)
version = models.BigIntegerField(default=0)
status = EnumChoiceField(GroupStatus, default=GroupStatus.active, max_length=8)
email = models.CharField(max_length=255, blank=True, null=True)
description = models.CharField(max_length=255, blank=True, null=True)
name = models.CharField(max_length=200, unique=True, blank=False)
automatic = models.BooleanField(default=True)
display_name = models.CharField(max_length=200, blank=True, null=True)
stack_default = models.BooleanField(default=False, blank=True, null=True)
people = models.ManyToManyField(Person, through='OwfGroupPeople', related_name='groups')
def __str__(self):
return self.name
def save(self, *args, **kwargs):
if self.display_name is None:
self.display_name = self.name
self.version = int(time.time())
super(OwfGroup, self).save(*args, **kwargs)
else:
self.version = int(time.time())
super(OwfGroup, self).save(*args, **kwargs)
def add_user(self, user):
payload = {
'person': user,
'group': self
}
new_group_people = OwfGroupPeople.objects.create(**payload)
return new_group_people
def add_widget(self, widget):
if not isinstance(widget, WidgetDefinition):
widget = WidgetDefinition.objects.get(pk=widget)
# based on the role update people to re-sync.
self.people.update(requires_sync=True)
return DomainMapping.create_group_widget_mapping(widget, self)
def remove_widget(self, widget):
if not isinstance(widget, WidgetDefinition):
widget = WidgetDefinition.objects.get(pk=widget)
# based on the role update people to re-sync.
self.people.update(requires_sync=True)
return DomainMapping.delete_group_widget_mapping(widget, self)
class Meta:
managed = True
db_table = 'owf_group'
def remove_user(self, user):
group_people = OwfGroupPeople.objects.get(person=user, group=self)
group_people.delete()
class PaymentOption(StarterModel):
name = models.CharField(max_length=64)
slug = models.CharField(max_length=16, unique=True)
gateway = EnumChoiceField(GatewayChoices, max_length=32)
is_active = models.BooleanField(default=True)
config = models.JSONField(default=dict)
def get_gateway(self):
return self.gateway.gateway_class(**self.config)
def test_field_raises_exception_when_enum_class_is_not_enumeration(self):
class FailingEnum:
FOO = 'foo'
BAR = 'bar'
with self.assertRaisesMessage(
EnumChoiceFieldException,
'`enum_class` argument must be a child of `Enum`'):
EnumChoiceField(enum_class=FailingEnum)
class post(models.Model):
title = models.CharField(max_length=200)
body = models.CharField(max_length=200)
status = EnumChoiceField(enum_status)
retrieves_count = models.IntegerField(default=0)
created_on = models.DateTimeField(auto_now_add=True)
updated_on = models.DateTimeField(auto_now=True)
author = models.ForeignKey(User, on_delete=models.CASCADE)
history = HistoricalRecords()
class JewelryCommon(AbstractModel):
title = models.CharField(max_length=120, unique=True)
brief = models.TextField(blank=True, null=True)
description = models.TextField(blank=True, null=True)
stone = EnumChoiceField(StoneEnum, default=StoneEnum.N)
macrame = models.BooleanField(default=False)
pcolor = EnumChoiceField(ColorEnum, default=ColorEnum.N) # Primary Color
def isRegistered(self):
theClass = type(self)
objList = theClass.objects.filter(title=self.title)
l = len(objList)
if l == 0:
return False
elif l == 1:
return True
else:
raise Exception(f"More that one instance of {self.title} @ {theClass.__name__}")
def clean(self):
if self.title == '':
raise ValidationError('Empty error message')
#@classmethod
#def compare(self, instance):
# pass
def getStone(self):
return self.stone
def getMacrame(self):
return self.macrame
def getCommonInfo(self):
info = dict()
info["stone"] = self.stone.getName()
info["macrame"] = self.macrame
return info
def __str__(self):
return f"{self.title}"
class Meta:
abstract = True
def test_get_readable_should_be_a_callable(self):
class TestEnum(Enum):
A = 1
B = 2
get_readable_value = 3
instance = EnumChoiceField(enum_class=TestEnum)
expected_choices = [('1', '1'), ('2', '2'), ('3', '3')]
self.assertEqual(expected_choices, instance.choices)
class Address(models.Model):
user = models.ForeignKey(User, on_delete=models.CASCADE)
name = models.TextField(max_length=100,blank=True)
location = models.TextField(max_length=500, blank=True)
type = EnumChoiceField(UserType)
uid = models.UUIDField(unique=True, default=uuid.uuid4, editable=False)
created = models.DateTimeField(auto_now_add=True)
updated = models.DateTimeField(auto_now_add=True)
def support(self):
items = Address.objects.filter(type=UserType.SUPPORT).values()
return items
class TenantUser(TenantBaseModel):
id = models.AutoField(primary_key=True)
user = models.OneToOneField(User, on_delete=models.CASCADE)
role = EnumChoiceField(UserRole,
choice_builder=attribute_value,
default=UserRole.USER)
def __str__(self):
return self.user.username
class Meta:
db_table = "tenantuser"