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"