def test_min_length(self):
field = SimpleArrayField(forms.CharField(), min_length=4)
with self.assertRaises(exceptions.ValidationError) as cm:
field.clean('a,b,c')
self.assertEqual(
cm.exception.messages[0],
'List contains 3 items, it should contain no fewer than 4.')
def test_has_changed_empty(self):
field = SimpleArrayField(forms.CharField())
self.assertIs(field.has_changed(None, None), False)
self.assertIs(field.has_changed(None, ''), False)
self.assertIs(field.has_changed(None, []), False)
self.assertIs(field.has_changed([], None), False)
self.assertIs(field.has_changed([], ''), False)
class SalesLeadsDetailForm(forms.Form):
# 需求详细
from product.models import Category
from .models.leads import TYPE_CHOICES
start_time = forms.DateTimeField(
label='开始时间',
required=False,
widget=forms.DateTimeInput(attrs={'class': 'datepicker'}))
due_time = forms.DateTimeField(
label='截至时间',
required=False,
widget=forms.DateTimeInput(attrs={'class': 'datepicker'}))
type = forms.MultipleChoiceField(label='类型',
choices=TYPE_CHOICES,
required=False)
thickness = SimpleArrayField(label='厚度',
base_field=forms.DecimalField(
max_digits=4, decimal_places=2),
required=False)
quantity = forms.IntegerField(label='数量', required=False)
long_lt = forms.IntegerField(label='长度(最低)', required=False)
long_gt = forms.IntegerField(label='长度(最高)', required=False)
height_lt = forms.IntegerField(label='高度(最低)', required=False)
height_gt = forms.IntegerField(label='高度(最高)', required=False)
price_lt = forms.IntegerField(label='价格(起)', required=False)
price_gt = forms.IntegerField(label='价格(止)', required=False)
def test_validators_fail(self):
field = SimpleArrayField(forms.RegexField('[a-e]{2}'))
with self.assertRaises(exceptions.ValidationError) as cm:
field.clean('a,bc,de')
self.assertEqual(
cm.exception.messages[0],
'Item 1 in the array did not validate: Enter a valid value.')
class CustomFieldCSVForm(CSVModelForm):
content_types = CSVMultipleContentTypeField(
queryset=ContentType.objects.all(),
limit_choices_to=FeatureQuery('custom_fields'),
help_text="One or more assigned object types")
choices = SimpleArrayField(
base_field=forms.CharField(),
required=False,
help_text='Comma-separated list of field choices')
class Meta:
model = CustomField
fields = (
'name',
'label',
'type',
'content_types',
'required',
'description',
'weight',
'filter_logic',
'default',
'choices',
'weight',
)
class SymbolForm(FileFormMixin, forms.ModelForm):
METHODS = (
(0, "Suggested path"),
(1, "Upload linux packages"),
(2, "Upload symbol"),
)
method = forms.IntegerField(label="Method",
widget=forms.Select(choices=METHODS))
path = SimpleArrayField(forms.CharField(required=False))
packages = MultipleUploadedFileField(required=False)
symbol = UploadedFileField(required=False)
def __init__(self, *args, **kwargs):
super(SymbolForm, self).__init__(*args, **kwargs)
self.fields["banner"].widget.attrs["readonly"] = True
class Meta:
model = Dump
fields = (
"index",
"operating_system",
"banner",
"method",
"path",
"packages",
"symbol",
)
widgets = {
"index": forms.HiddenInput(),
"operating_system": forms.HiddenInput(),
}
def test_validate_fail_base_field_error_params(self):
field = SimpleArrayField(forms.CharField(max_length=2))
with self.assertRaises(exceptions.ValidationError) as cm:
field.clean('abc,c,defg')
errors = cm.exception.error_list
self.assertEqual(len(errors), 2)
first_error = errors[0]
self.assertEqual(
first_error.message,
'Item 0 in the array did not validate: Ensure this value has at most 2 characters (it has 3).'
)
self.assertEqual(first_error.code, 'item_invalid')
self.assertEqual(first_error.params, {
'nth': 0,
'value': 'abc',
'limit_value': 2,
'show_value': 3
})
second_error = errors[1]
self.assertEqual(
second_error.message,
'Item 2 in the array did not validate: Ensure this value has at most 2 characters (it has 4).'
)
self.assertEqual(second_error.code, 'item_invalid')
self.assertEqual(second_error.params, {
'nth': 2,
'value': 'defg',
'limit_value': 2,
'show_value': 4
})
class SiteForm(forms.ModelForm):
url = forms.URLField(max_length=1000,
required=True,
error_messages=default_url_errors)
aliases = SimpleArrayField(forms.CharField(),
required=False,
delimiter='\n',
widget=forms.Textarea)
class Meta:
model = Site
exclude = [
'active_end_date',
'github_fork',
'registered_user_count',
'active_learner_count',
'course_type',
]
# If the corresponding attribute in site form is uncommented above, these help messages won't show
help_texts = {
"language": "Select multiple languages with CMD+Click",
"geography": "Select multiple geo-zones with CMD+Click",
#'url': 'This text is not persistent on page, what gives!',
#'last_checked': 'This text is persistent on the page, conflicts with error help text provided by bootstrap',
}
widgets = {
'active_start_date':
DateTimeWidget(attrs={'id': 'active_start_date'},
bootstrap_version=3),
}
class PuzzleDataForm(forms.ModelForm):
required_constraints = SimpleArrayField(forms.CharField(), required=False)
screenshot = forms.FileField(required=False)
def clean_screenshot(self):
screenshot = self.cleaned_data.get('screenshot')
if screenshot:
saved = default_storage.save('screenshots/' + screenshot.name,
screenshot)
return default_storage.url(saved)
def clean(self):
if not self.request.user.is_staff:
raise ValidationError("Only staff are allowed to save puzzles")
def save(self, commit=True):
for attr, value in self.cleaned_data.items():
print('saving', attr, value)
if value:
self.instance.data[attr] = value
return super().save(commit=commit)
class Meta:
model = Puzzle
fields = ('required_constraints', 'screenshot')
class HQApiKeyForm(forms.Form):
name = forms.CharField()
ip_allowlist = SimpleArrayField(
forms.GenericIPAddressField(),
label=ugettext_lazy("Allowed IP Addresses (comma separated)"),
required=False)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.helper = HQFormHelper()
self.helper.layout = Layout(
crispy.Fieldset(
ugettext_lazy("Add New API Key"),
crispy.Field('name'),
crispy.Field('ip_allowlist'),
),
hqcrispy.FormActions(
StrictButton(mark_safe('<i class="fa fa-plus"></i> {}'.format(
ugettext_lazy("Generate New API Key"))),
css_class='btn btn-primary',
type='submit')))
def create_key(self, user):
try:
HQApiKey.objects.get(name=self.cleaned_data['name'], user=user)
raise DuplicateApiKeyName
except HQApiKey.DoesNotExist:
new_key = HQApiKey.objects.create(
name=self.cleaned_data['name'],
ip_allowlist=self.cleaned_data['ip_allowlist'],
user=user,
)
return new_key
class PostTextForm(PostForm):
title = forms.CharField(
label="Заголовок",
required=True,
max_length=128,
widget=forms.TextInput(attrs={"placeholder": "Заголовок 🤙"}),
)
text = forms.CharField(
label="Текст поста",
required=True,
max_length=500000,
widget=forms.Textarea(
attrs={
"maxlength": 500000,
"class": "markdown-editor-full",
"placeholder": "Дорогой Мартин Алексеевич…"
}),
)
coauthors = SimpleArrayField(
forms.CharField(max_length=32),
max_length=10,
label="Соавторы поста",
required=False,
)
class Meta:
model = Post
fields = ["title", "text", "topic", "is_public", "coauthors"]
def clean(self):
cleaned_data = super().clean()
self.validate_coauthors(cleaned_data)
return cleaned_data
def test_validate_fail(self):
field = SimpleArrayField(forms.CharField(required=True))
with self.assertRaises(exceptions.ValidationError) as cm:
field.clean('a,b,')
self.assertEqual(
cm.exception.messages[0],
'Item 2 in the array did not validate: This field is required.')
def test_to_python_fail(self):
field = SimpleArrayField(forms.IntegerField())
with self.assertRaises(exceptions.ValidationError) as cm:
field.clean('a,b,9')
self.assertEqual(
cm.exception.messages[0],
'Item 0 in the array did not validate: Enter a whole number.')
class OptInForm(forms.Form):
number = forms.CharField(required=True)
first_name = forms.CharField(required=False)
last_name = forms.CharField(required=False)
country = forms.CharField(required=False)
contact_book = forms.IntegerField()
user_email = forms.CharField(required=False)
groups = SimpleArrayField(forms.CharField(strip=True), required=False)
class RefundSearchForm(forms.Form):
q = forms.CharField(required=False)
status = forms.ChoiceField(choices=RefundStatus.choices + [("ALL", "All")],
required=False)
start_date = forms.DateField(required=False)
end_date = forms.DateField(required=False)
payment_types = SimpleArrayField(
forms.ChoiceField(choices=OrderPaymentType.choices), required=False)
class PostCreateForm(PostForm):
tags = SimpleArrayField(forms.CharField(
max_length=13,
validators=[validate_slug],
),
delimiter=' ',
required=False,
help_text='List of tags separated with " "')
def test_max_length(self):
field = SimpleArrayField(forms.CharField(), max_length=2)
with self.assertRaises(exceptions.ValidationError) as cm:
field.clean("a,b,c")
self.assertEqual(
cm.exception.messages[0],
"List contains 3 items, it should contain no more than 2.",
)
class ProctorForm(forms.ModelForm):
sem_pointers = SimpleArrayField(forms.IntegerField())
class Meta:
model = Student
exclude = [
'user',
]
class ExerciseForm(CustomModelForm):
sets = SimpleArrayField(forms.IntegerField(), required=False)
rest_duration = forms.IntegerField(initial=60, required=False)
name = forms.CharField(max_length=250, required=False)
exercise_type = forms.CharField(max_length=250, required=False)
class Meta:
model = Exercise
fields = ['sets', 'rest_duration', 'name', 'exercise_type']
class QuestionForm(forms.ModelForm):
choices = SimpleArrayField(forms.CharField())
def clean_choices(self):
return [x for x in self.cleaned_data['choices'][0].splitlines() if x]
class Meta:
model = models.ParticipationQuestion
fields = ('question_text', 'answer_type', 'mandatory')
class CountryAdminForm(forms.ModelForm):
italics_terms = SimpleArrayField(forms.CharField(max_length=1024, required=False), delimiter='\n', required=False, widget=forms.Textarea)
class Meta:
model = Country
fields = ('country', 'primary_language', 'italics_terms')
def clean_italics_terms(self):
# strip blanks and duplications
return sorted(list(set(x for x in self.cleaned_data['italics_terms'] if x)))
class LyricForm(ModelForm):
lines = SimpleArrayField(CharField(), delimiter='|', widget=Textarea())
def __init__(self, *args, **kwargs):
super(LyricForm, self).__init__(*args, **kwargs)
if self.instance.lines:
self.instance.lines = '\r\n'.join(self.instance.lines)
super(LyricForm, self).__init__(*args, **kwargs)
class GroupAccessControlForm(forms.Form):
overwrite_existing = forms.BooleanField(
help_text="Overwrite existing entries", required=False)
group = forms.ModelChoiceField(queryset=Group.objects.all())
policy = forms.ChoiceField(choices=AbstractAccessControl.POLICIES)
services = forms.ModelMultipleChoiceField(
queryset=Service.objects.all(),
widget=widgets.FilteredSelectMultiple('Services', False))
rate = forms.CharField(max_length=100)
serializers = SimpleArrayField(forms.CharField(), max_length=255)
class DestructionListForm(forms.ModelForm):
zaken = forms.CharField()
reviewer_1 = forms.ModelChoiceField(queryset=User.objects.reviewers().all())
reviewer_2 = forms.ModelChoiceField(
queryset=User.objects.reviewers().all(), required=False
)
zaken_identificaties = SimpleArrayField(forms.CharField(max_length=250))
class Meta:
model = DestructionList
fields = (
"name",
"zaken",
"reviewer_1",
"reviewer_2",
"zaken_identificaties",
"contains_sensitive_info",
)
def clean_zaken(self) -> List[str]:
return self.cleaned_data["zaken"].split(",")
def save_items(self, destruction_list):
zaken = self.cleaned_data["zaken"]
destruction_list_items = []
for zaak in zaken:
destruction_list_items.append(
DestructionListItem(destruction_list=destruction_list, zaak=zaak)
)
DestructionListItem.objects.bulk_create(destruction_list_items)
def save_assignees(self, destruction_list):
assignees = []
for i in range(1, 3):
reviewer = self.cleaned_data[f"reviewer_{i}"]
if reviewer:
assignees.append(
DestructionListAssignee(
destruction_list=destruction_list, order=i, assignee=reviewer,
)
)
destruction_list_assignees = DestructionListAssignee.objects.bulk_create(
assignees
)
if destruction_list_assignees:
destruction_list.assign(destruction_list.next_assignee())
destruction_list.save()
def save(self, **kwargs):
destruction_list = super().save(**kwargs)
self.save_items(destruction_list)
self.save_assignees(destruction_list)
return destruction_list
class MotorCircuitForm(forms.ModelForm):
volt = SimpleArrayField(CharField(), delimiter='|', widget=Textarea())
#def __init__(self, *args, **kwargs):
#super().__init__(*args, **kwargs)
#self.fields['volt'].delimiter = '|' # Or whichever other character you want.
class Meta:
model = MotorCircuit
fields = '__all__'
class UserGroupForm(forms.ModelForm):
users = SimpleArrayField(forms.CharField(required=False),
delimiter="\n",
widget=forms.Textarea(attrs={
"style": "width:80%",
"rows": 10
}),
help_text=get_help_text(UserGroup, "users"))
excluded_users = SimpleArrayField(forms.CharField(required=False),
delimiter="\n",
required=False,
widget=forms.Textarea(attrs={
"style": "width:80%",
"rows": 10
}),
help_text=get_help_text(
UserGroup, "excluded_users"))
class Meta:
model = UserGroup
fields = "__all__"
class GlossaryEntryModelForm(ModelForm):
examples = SimpleArrayField(
base_field=CharField(),
delimiter='|',
widget=Textarea,
help_text=
"When giving more than one example seperate them with a '|' ( Alt Gr + >-Button)."
)
class Meta:
model = GlossaryEntry
fields = '__all__'
class DomainsAddForm(forms.Form):
links = SimpleArrayField(forms.CharField(max_length=100),
min_length=1,
label=_('Список урлов'),
error_messages={
'required': _('Список урлов не задан.'),
'invalid': _('Список урлов некорректен.')
})
def save_urls(self) -> Optional[int]:
links: list = self.cleaned_data.get('links')
try:
timestamp: int = math.floor(timezone.now().timestamp())
unique_domains = self.collect_unique_domains(links)
redis_client = redis.Redis(host=settings.REDIS_HOST,
**settings.REDIS_CONFIG)
curr_id: int = redis_client.incr('curr_id')
urls = {
index: domain
for index, domain in enumerate(unique_domains, start=curr_id)
}
# set curr_id for next saving in 'sites' hash table
redis_client.incr('curr_id', len(urls))
# save sites in hash table -> pk:domain
redis_client.hmset('sites', urls)
# save timestamps in sorted set -> timestamps:sites_pk
redis_client.zadd('timestamps',
{pk: timestamp
for pk in urls.keys()},
nx=True)
except Exception:
print(f'Error: {format_exc()}')
return None
return timestamp
@classmethod
def collect_unique_domains(cls, urls: list) -> set:
unique_urls = set()
for url in urls:
url: str = get_base_domain(url)
if url:
unique_urls.add(url)
return unique_urls
class AdminCommuneForm(forms.ModelForm):
class Meta:
model = Commune
exclude = ("pk", )
code_postaux = SimpleArrayField(
forms.CharField(),
widget=widgets.Textarea(),
delimiter="\n",
required=False,
help_text="Un code postal par ligne",
)
class AdminActiviteForm(forms.ModelForm):
class Meta:
model = Activite
exclude = ("pk", )
mots_cles = SimpleArrayField(
forms.CharField(),
widget=widgets.Textarea(),
delimiter="\n",
required=False,
help_text="Un mots-clé par ligne",
)
