def clean(self, value):
clean_data = []
errors = ErrorList()
if not value or isinstance(value, (list, tuple)):
if not value or not [v for v in value if v not in self.empty_values]:
if self.required:
raise ValidationError(self.error_messages['required'])
else:
return []
else:
raise ValidationError(self.error_messages['invalid'])
field = self.field_type(required=self.required)
for field_value in value:
try:
clean_data.append(field.clean(field_value))
except ValidationError as e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter.
errors.extend(e.messages)
if field.required:
field.required = False
if errors:
raise ValidationError(errors)
self.validate(clean_data)
self.run_validators(clean_data)
return clean_data
def clean(self, value):
'''\
value is assumed to be a dictionary of values with keys corresponding
to the ones in self.subfields. Each value is validated against it's
corresponding field.
'''
clean_data = {}
errors = ErrorList()
if value is None:
return value
if not isinstance(value, dict):
raise ValidationError(self.error_messages['invalid'])
for fieldname, field in self.subfields.items():
if not fieldname in value.keys():
if field.required:
raise ValidationError(field.error_messages['required'])
else:
continue
try:
clean_data[fieldname] = field.clean(value[fieldname])
except ValidationError, e:
errors.extend(e.messages)
def clean(self, value):
clean_data = []
errors = ErrorList()
if value in validators.EMPTY_VALUES and self.required:
raise ValidationError(self.error_messages['required'])
for i, field in enumerate(self.fields):
try:
field_value = value[i]
except IndexError:
field_value = None
if field_value in validators.EMPTY_VALUES:
if (self.required and not self.optional):
raise ValidationError(self.error_messages['required'])
else:
field_value = field_value
try:
clean_data.append(field.clean(field_value))
except ValidationError, e:
errors.extend(e.messages)
if i == len(self.fields) and len(clean_data) == 0:
raise ValidationError(self.error_messages['optional_required'])
def clean(self, value):
"""
Only the default language should be required.
"""
clean_data = []
errors = ErrorList()
if not value or isinstance(value, (list, tuple)):
if not value or not [v for v in value if v not in validators.EMPTY_VALUES]:
if self.required:
raise ValidationError(self.error_messages['required'])
else:
return self.compress([])
else:
raise ValidationError(self.error_messages['invalid'])
for i, field in enumerate(self.fields):
try:
field_value = value[i]
except IndexError:
field_value = None
if i == 0 and self.required and field_value in validators.EMPTY_VALUES:
raise ValidationError(self.error_messages['required'])
try:
clean_data.append(field.clean(field_value))
except ValidationError as e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter.
errors.extend(e.messages)
if errors:
raise ValidationError(errors)
out = self.compress(clean_data)
self.validate(out)
self.run_validators(out)
return out
def clean(self, value):
clean_data = []
errors = ErrorList()
if value in validators.EMPTY_VALUES and self.required:
raise ValidationError(self.error_messages['required'])
for i, field in enumerate(self.fields):
try:
field_value = value[i]
except IndexError:
field_value = None
if field_value in validators.EMPTY_VALUES:
if (self.required and not self.optional):
raise ValidationError(self.error_messages['required'])
else:
field_value = field_value
try:
clean_data.append(field.clean(field_value))
except ValidationError, e:
errors.extend(e.messages)
if i == len(self.fields) and len(clean_data) == 0:
raise ValidationError(self.error_messages['optional_required'])
def clean_sub_fields(self, value):
"""'value' being the list of the values of the subfields, validate
each subfield."""
clean_data = []
errors = ErrorList()
# Remove the field corresponding to the SKIP_CHECK_NAME boolean field
# if required.
fields = self.fields if not self.skip_check else self.fields[:-1]
for index, field in enumerate(fields):
try:
field_value = value[index]
except IndexError:
field_value = None
# Check the field's 'required' field instead of the global
# 'required' field to allow subfields to be required or not.
if field.required and field_value in validators.EMPTY_VALUES:
errors.append(
'%s: %s' % (field.label, self.error_messages['required']))
continue
try:
clean_data.append(field.clean(field_value))
except ValidationError, e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter.
errors.extend(
['%s: %s' % (field.label, message)
for message in e.messages])
def clean(self, value):
clean_data = []
errors = ErrorList()
if not value or isinstance(value, (list, tuple)):
if not value or not [
v for v in value if v not in self.empty_values
]:
if self.required:
raise ValidationError(self.error_messages['required'])
else:
return []
else:
raise ValidationError(self.error_messages['invalid'])
field = self.field_type(required=self.required)
for field_value in value:
try:
clean_data.append(field.clean(field_value))
except ValidationError as e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter.
errors.extend(e.messages)
if field.required:
field.required = False
if errors:
raise ValidationError(errors)
self.validate(clean_data)
self.run_validators(clean_data)
return clean_data
def clean(self, value):
"""
Validates every value in the given list. A value is validated against
the corresponding Field in self.fields.
For example, if this MultiValueField was instantiated with
fields=(DateField(), TimeField()), clean() would call
DateField.clean(value[0]) and TimeField.clean(value[1]).
"""
clean_data = []
errors = ErrorList()
if not value or isinstance(value, (list, tuple)):
if not value or not [
v for v in value if v not in validators.EMPTY_VALUES
]:
if self.required:
raise ValidationError(self.error_messages['required'])
else:
return self.compress([])
else:
raise ValidationError(self.error_messages['invalid'])
for i, field in enumerate(self.fields):
try:
field_value = value[i]
except IndexError:
field_value = None
if self.required and field_value in validators.EMPTY_VALUES:
raise ValidationError(self.error_messages['required'])
try:
clean_data.append(field.clean(field_value))
except ValidationError, e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter.
errors.extend(e.messages)
def clean_sub_fields(self, value):
"""'value' being the list of the values of the subfields, validate
each subfield."""
clean_data = []
errors = ErrorList()
# Remove the field corresponding to the SKIP_CHECK_NAME boolean field
# if required.
fields = self.fields if not self.skip_check else self.fields[:-1]
for index, field in enumerate(fields):
try:
field_value = value[index]
except IndexError:
field_value = None
# Check the field's 'required' field instead of the global
# 'required' field to allow subfields to be required or not.
if field.required and field_value in validators.EMPTY_VALUES:
errors.append('%s: %s' %
(field.label, self.error_messages['required']))
continue
try:
clean_data.append(field.clean(field_value))
except ValidationError, e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter.
errors.extend('%s: %s' % (field.label, message)
for message in e.messages)
def clean(self, value):
# Get the value
# Totally replaced validation.
clean_data = []
errors = ErrorList()
# Only the visible field is required.
radio_value = value[0]
field_visible = [False] * len(self.fields)
field_visible[0] = True
field_visible[self.url_type_registry.index(radio_value) + 1] = True
# The validators only fire for visible fields.
for i, field in enumerate(self.fields):
try:
field_value = value[i]
except IndexError:
field_value = None
if not field_visible[i]:
clean_data.append(None)
continue
if self.required and field_value in validators.EMPTY_VALUES:
raise ValidationError(self.error_messages['required'])
try:
clean_data.append(field.clean(field_value))
except ValidationError, e:
errors.extend(e.messages) # Collect all widget errors
def clean(self, value):
"""
Validates every value in the given list. A value is validated against
the corresponding Field in self.fields.
For example, if this MultiValueField was instantiated with
fields=(DateField(), TimeField()), clean() would call
DateField.clean(value[0]) and TimeField.clean(value[1]).
"""
clean_data = []
errors = ErrorList()
if not value or isinstance(value, (list, tuple)):
if not value or not [v for v in value if v not in validators.EMPTY_VALUES]:
if self.required:
raise ValidationError(self.error_messages["required"])
else:
return self.compress([])
else:
raise ValidationError(self.error_messages["invalid"])
for i, field in enumerate(self.fields):
try:
field_value = value[i]
except IndexError:
field_value = None
if self.required and field_value in validators.EMPTY_VALUES:
raise ValidationError(self.error_messages["required"])
try:
clean_data.append(field.clean(field_value))
except ValidationError, e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter.
errors.extend(e.messages)
def lib_main(request):
albums = []
errors = ErrorList()
pager = Paginator([], 1)
selected_page = 1
form = None # it's our search form
# If a form was just submitted
if request.method == 'POST':
form = SearchForm(request.POST) # A form bound to the POST data
if form.is_valid():
# Use the form fields to search and filter albums from the db
albums = lib_main_filter_albums(form)
pager = Paginator(albums, form.cleaned_data['items_per_page'])
selected_page = int(form.cleaned_data['selected_page'])
page_list = [(str(x), str(x)) for x in pager.page_range][:100]
if len(page_list) is 0:
form.fields['selected_page'][('1', '1')]
else:
form.fields['selected_page'].choices = page_list
form.fields['selected_page'].initial = selected_page
else:
# Add all of the errors in the form.errors dict to our error list
errors.extend(chain.from_iterable(form.errors.values()))
form.save()
else:
form = SearchForm(
initial={
'artist': request.GET.get('artist'),
'album': request.GET.get('album'),
'label': request.GET.get('label'),
'year': request.GET.get('year'),
'genre': request.GET.get('genre'),
'stack': request.GET.get('stack'),
'selected_page': "1",
'items_per_page': "25",
})
form.fields['selected_page'].choices = [
(str(x), str(x)) for x in pager.page_range
][:100]
albums_page = []
try:
albums_page = pager.page(selected_page).object_list
except EmptyPage:
albums_page = pager.page(1).object_list
errors.append("That page is empty.")
return render_to_response('library.html', {
'form': form,
'albums': albums_page,
'errors': errors,
},
context_instance=RequestContext(request))
def clean(self, value):
"""
Validates every value in the given list. A value is validated against
the corresponding Field in self.fields.
For example, if this MultiValueField was instantiated with
fields=(DateField(), TimeField()), clean() would call
DateField.clean(value[0]) and TimeField.clean(value[1]).
"""
clean_data = []
errors = ErrorList()
if not value or isinstance(value, (list, tuple)):
if not value or not [
v for v in value if v not in self.empty_values
]:
if self.required:
raise ValidationError(self.error_messages['required'],
code='required')
else:
return self.compress([])
else:
raise ValidationError(self.error_messages['invalid'],
code='invalid')
for i, field in enumerate(self.fields):
try:
field_value = value[i]
except IndexError:
field_value = None
if field_value in self.empty_values:
if self.require_all_fields:
# Raise a 'required' error if the MultiValueField is
# required and any field is empty.
if self.required:
raise ValidationError(self.error_messages['required'],
code='required')
elif field.required:
# Otherwise, add an 'incomplete' error to the list of
# collected errors and skip field cleaning, if a required
# field is empty.
if field.error_messages['incomplete'] not in errors:
errors.append(field.error_messages['incomplete'])
continue
try:
clean_data.append(field.clean(field_value))
except ValidationError as e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter. Skip duplicates.
errors.extend(m for m in e.error_list if m not in errors)
if errors:
raise ValidationError(errors)
out = self.compress(clean_data)
self.validate(out)
self.run_validators(out)
return out
def clean(self, value):
"""
Validates every value in the given list. A value is validated against
the corresponding Field in self.fields.
For example, if this MultiValueField was instantiated with
fields=(DateField(), TimeField()), clean() would call
DateField.clean(value[0]) and TimeField.clean(value[1]).
"""
clean_data = {}
errors = ErrorList()
if not value or isinstance(value, dict):
if not value or not [v for v in value.values() if v not in self.empty_values]:
if self.required:
raise ValidationError(self.error_messages['required'])
else:
return {}
else:
raise ValidationError(self.error_messages['invalid'])
# sort out required => at least one element must be in there
data_field = self.field_type(**self.field_kwargs)
for key, val in value.items():
# ignore empties. Can they even come up here?
if key in self.empty_values and val in self.empty_values:
continue
try:
val = data_field.clean(val)
except ValidationError as e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter.
errors.extend(e.messages)
try:
self._validate_key(key)
except ValidationError as e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter.
errors.extend(e.messages)
clean_data[key] = val
if data_field.required:
data_field.required = False
if errors:
raise ValidationError(errors)
self.validate(clean_data)
self.run_validators(clean_data)
return clean_data
def post(self, request, *args, **kwargs):
if self.async_response is not None:
return self.async_response
if self.subscription_form.is_valid():
try:
subscription = self.subscription_form.create_subscription()
return HttpResponseRedirect(reverse(ManageBillingAccountView.urlname, args=(subscription.account.id,)))
except NewSubscriptionError as e:
errors = ErrorList()
errors.extend([e.message])
self.subscription_form._errors.setdefault(NON_FIELD_ERRORS, errors)
return self.get(request, *args, **kwargs)
def lib_main(request):
albums = []
errors = ErrorList()
pager = Paginator([], 1)
selected_page = 1
form = None # it's our search form
# If a form was just submitted
if request.method == 'POST':
form = SearchForm(request.POST) # A form bound to the POST data
if form.is_valid():
# Use the form fields to search and filter albums from the db
albums = lib_main_filter_albums(form)
pager = Paginator(albums, form.cleaned_data['items_per_page'])
selected_page = int(form.cleaned_data['selected_page'])
page_list = [(str(x), str(x)) for x in pager.page_range][:100]
if len(page_list) is 0:
form.fields['selected_page'][('1', '1')]
else:
form.fields['selected_page'].choices = page_list
form.fields['selected_page'].initial = selected_page
else:
# Add all of the errors in the form.errors dict to our error list
errors.extend(chain.from_iterable(form.errors.values()))
form.save()
else:
form = SearchForm(initial={'artist': request.GET.get('artist'),
'album': request.GET.get('album'),
'label': request.GET.get('label'),
'year': request.GET.get('year'),
'genre': request.GET.get('genre'),
'stack': request.GET.get('stack'),
'selected_page': "1",
'items_per_page': "25",
})
form.fields['selected_page'].choices = [(str(x), str(x)) for x in pager.page_range][:100]
albums_page = []
try:
albums_page = pager.page(selected_page).object_list
except EmptyPage:
albums_page = pager.page(1).object_list
errors.append("That page is empty.")
return render_to_response('library.html', {
'form': form,
'albums': albums_page,
'errors': errors,
}, context_instance=RequestContext(request))
def clean(self, value):
"""
Validates every value in the given list. A value is validated against
the corresponding Field in self.fields.
For example, if this MultiValueField was instantiated with
fields=(DateField(), TimeField()), clean() would call
DateField.clean(value[0]) and TimeField.clean(value[1]).
"""
clean_data = []
errors = ErrorList()
if not value or isinstance(value, (list, tuple)):
if not value or not [v for v in value if v not in self.empty_values]:
if self.required:
raise ValidationError(self.error_messages['required'], code='required')
else:
return self.compress([])
else:
raise ValidationError(self.error_messages['invalid'], code='invalid')
for i, field in enumerate(self.fields):
try:
field_value = value[i]
except IndexError:
field_value = None
if field_value in self.empty_values:
if self.require_all_fields:
# Raise a 'required' error if the MultiValueField is
# required and any field is empty.
if self.required:
raise ValidationError(self.error_messages['required'], code='required')
elif field.required:
# Otherwise, add an 'incomplete' error to the list of
# collected errors and skip field cleaning, if a required
# field is empty.
if field.error_messages['incomplete'] not in errors:
errors.append(field.error_messages['incomplete'])
continue
try:
clean_data.append(field.clean(field_value))
except ValidationError as e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter. Skip duplicates.
errors.extend(m for m in e.error_list if m not in errors)
if errors:
raise ValidationError(errors)
out = self.compress(clean_data)
self.validate(out)
self.run_validators(out)
return out
def clean(self, value):
"""
Validates every value in the given list. A value is validated against
the corresponding Field in self.fields.
Only allows for exactly 1 valid value to be submitted, this is what
gets returned by compress.
example to use directy (instead of using FileOrURLField):
MutuallyExclusiveValueField(
fields=(forms.IntegerField(), forms.IntegerField()),
widget=MutuallyExclusiveRadioWidget(widgets=[
forms.Select(choices=[(1,1), (2,2)]),
forms.TextInput(attrs={'placeholder':
'Enter a number'}),
]))
"""
clean_data = []
errors = ErrorList()
if not value or isinstance(value, (list, tuple)):
if not value or not [
v for v in value if v not in self.empty_values]:
if self.required:
raise ValidationError(
self.error_messages['required'], code='required')
else:
return self.compress([])
else:
raise ValidationError(
self.error_messages['invalid'], code='invalid')
for i, field in enumerate(self.fields):
try:
field_value = value[i]
except IndexError:
field_value = None
try:
clean_data.append(field.clean(field_value))
except ValidationError as e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter.
errors.extend(e.messages)
if errors:
raise ValidationError(errors)
out = self.compress(clean_data)
self.validate(out)
self.run_validators(out)
return out
def clean(self, value):
clean_data = {}
errors = ErrorList()
if not value or isinstance(value, dict):
if not value or not [
v for v in value.values() if v not in self.empty_values
]:
if self.required:
raise ValidationError(self.error_messages['required'])
else:
return {}
else:
raise ValidationError(self.error_messages['invalid'])
# sort out required => at least one element must be in there
data_field = self.field_type(**self.field_kwargs)
for key, val in value.items():
# ignore empties. Can they even come up here?
if key in self.empty_values and val in self.empty_values:
continue
try:
val = data_field.clean(val)
except ValidationError as e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter.
errors.extend(e.messages)
try:
self._validate_key(key)
except ValidationError as e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter.
errors.extend(e.messages)
clean_data[key] = val
if data_field.required:
data_field.required = False
if errors:
raise ValidationError(errors)
self.validate(clean_data)
self.run_validators(clean_data)
return clean_data
def post(self, request, *args, **kwargs):
if self.async_response is not None:
return self.async_response
if self.subscription_form.is_valid():
try:
subscription = self.subscription_form.create_subscription()
return HttpResponseRedirect(
reverse(ManageBillingAccountView.urlname,
args=(subscription.account.id, )))
except NewSubscriptionError as e:
errors = ErrorList()
errors.extend([e.message])
self.subscription_form._errors.setdefault(
NON_FIELD_ERRORS, errors)
return self.get(request, *args, **kwargs)
def clean(self, value):
clean_data = {}
errors = ErrorList()
if not value or isinstance(value, dict):
if not value or not [v for v in value.values() if v not in self.empty_values]:
if self.required:
raise ValidationError(self.error_messages['required'])
else:
return {}
else:
raise ValidationError(self.error_messages['invalid'])
# sort out required => at least one element must be in there
data_field = self.field_type(**self.field_kwargs)
for key, val in value.items():
# ignore empties. Can they even come up here?
if key in self.empty_values and val in self.empty_values:
continue
try:
val = data_field.clean(val)
except ValidationError as e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter.
errors.extend(e.messages)
try:
self._validate_key(key)
except ValidationError as e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter.
errors.extend(e.messages)
clean_data[key] = val
if data_field.required:
data_field.required = False
if errors:
raise ValidationError(errors)
self.validate(clean_data)
self.run_validators(clean_data)
return clean_data
def clean(self, value):
"""
Validates every value in the given list. A value is validated against
the corresponding Field in self.fields.
Only allows for exactly 1 valid value to be submitted, this is what
gets returned by compress.
example to use directy (instead of using FileOrURLField):
MutuallyExclusiveValueField(
fields=(forms.TypedChoiceField(choices=[(1,1), (2,2)], coerce=int),
forms.IntegerField()))
"""
clean_data = []
errors = ErrorList()
if not value or isinstance(value, (list, tuple)):
if not value or not [
v for v in value if v not in self.empty_values
]:
if self.required:
raise ValidationError(self.error_messages['required'],
code='required')
else:
return self.compress([])
else:
raise ValidationError(self.error_messages['invalid'],
code='invalid')
for i, field in enumerate(self.fields):
try:
field_value = value[i]
except IndexError:
field_value = None
try:
clean_data.append(field.clean(field_value))
except ValidationError as e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter.
errors.extend(e.messages)
if errors:
raise ValidationError(errors)
out = self.compress(clean_data)
self.validate(out)
self.run_validators(out)
return out
def clean(self, value):
"""
This is a copy of MultiValueField.clean() with a BUGFIX:
- if self.required and field_value in validators.EMPTY_VALUES:
+ if field.required and field_value in validators.EMPTY_VALUES:
"""
from django.forms.util import ErrorList
from django.core import validators
from django.core.exceptions import ValidationError
clean_data = []
errors = ErrorList()
if not value or isinstance(value, (list, tuple)):
if not value or not [
v for v in value if v not in validators.EMPTY_VALUES
]:
if self.required:
raise ValidationError(self.error_messages['required'])
else:
return self.compress(value)
else:
raise ValidationError(self.error_messages['invalid'])
for i, field in enumerate(self.fields):
try:
field_value = value[i]
except IndexError:
field_value = None
if field.required and field_value in validators.EMPTY_VALUES:
raise ValidationError(self.error_messages['required'])
try:
clean_data.append(field.clean(field_value))
except ValidationError as e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter.
errors.extend(e.messages)
if errors:
raise ValidationError(errors)
out = self.compress(clean_data)
self.validate(out)
self.run_validators(out)
return out
def clean(self, value):
"""
This is a copy of MultiValueField.clean() with a BUGFIX:
- if self.required and field_value in validators.EMPTY_VALUES:
+ if field.required and field_value in validators.EMPTY_VALUES:
"""
from django.forms.util import ErrorList
from django.core import validators
from django.core.exceptions import ValidationError
clean_data = []
errors = ErrorList()
if not value or isinstance(value, (list, tuple)):
if not value or not [v for v in value if v not in validators.EMPTY_VALUES]:
if self.required:
raise ValidationError(self.error_messages['required'])
else:
return self.compress(value)
else:
raise ValidationError(self.error_messages['invalid'])
for i, field in enumerate(self.fields):
try:
field_value = value[i]
except IndexError:
field_value = None
if field.required and field_value in validators.EMPTY_VALUES:
raise ValidationError(self.error_messages['required'])
try:
clean_data.append(field.clean(field_value))
except ValidationError as e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter.
errors.extend(e.messages)
if errors:
raise ValidationError(errors)
out = self.compress(clean_data)
self.validate(out)
self.run_validators(out)
return out
def clean_product_rates(self):
original_data = self.cleaned_data['product_rates']
rates = json.loads(original_data)
rate_instances = []
errors = ErrorList()
for rate_data in rates:
rate_form = ProductRateForm(rate_data)
if not rate_form.is_valid():
errors.extend(list(self._get_errors_from_subform(rate_data['name'], rate_form)))
else:
rate_instances.append(self._retrieve_product_rate(rate_form))
if errors:
self._errors.setdefault('product_rates', errors)
self.new_product_rates = rate_instances
rate_ids = lambda x: set([r.id for r in x])
if (not self.is_update
and (self.plan_version is None
or rate_ids(rate_instances).symmetric_difference(rate_ids(self.plan_version.product_rates.all())))):
self.is_update = True
return original_data
def _validate_fields(self):
"""
Validate individual field values, like django's clean_<fieldname> with
less magic ( no setattr('clean_'+field_name) junk) just loop over
the fields and apply the validators specified in the
field spec (self._get_expected_fields_for_row(row))
"""
cleaned_data = {}
errors = ErrorList()
for row_num, row in enumerate(self.rows):
expected_fields = self._get_validators_for_row(row)
if len(row) != len(expected_fields):
raise serializers.ValidationError(
"Row: %s - Incorrect number of columns should be %s "
"actually %s" %
(row_num + 1, len(expected_fields), len(row)))
for idx, field_name in enumerate(expected_fields):
field_value = row[idx]
validators = expected_fields[field_name]
try:
cleaned_data[field_name] = self._validate_field(
field_name, field_value.strip(), idx, row_num,
validators)
except serializers.ValidationError as ve:
errors.append(ve)
except (AssertionError, TypeError) as e:
errors.append(e)
try:
# Global Validation
applicable_contract = self._get_applicable_contract_for_row(
row)
self.cleaned_data.append(
self._validate_data(cleaned_data, row_num,
applicable_contract))
except serializers.ValidationError as ve:
errors.extend(ve.error_list)
if len(errors):
raise serializers.ValidationError(errors)
def clean(self, value):
# Get the value
# Totally replaced validation.
clean_data = []
errors = ErrorList()
# Only the visible field is required.
radio_value = value[0]
field_visible = [False] * len(self.fields)
field_visible[0] = True
if radio_value is None:
# radio_value is None when models are deleted in formsets
out = ''
else:
field_visible[self.url_type_registry.index(radio_value) + 1] = True
# The validators only fire for visible fields.
for i, field in enumerate(self.fields):
try:
field_value = value[i]
except IndexError:
field_value = None
if not field_visible[i]:
clean_data.append(None)
continue
if self.required and field_value in validators.EMPTY_VALUES:
raise ValidationError(self.error_messages['required'])
try:
clean_data.append(field.clean(field_value))
except ValidationError as e:
errors.extend(e.messages) # Collect all widget errors
if errors:
raise ValidationError(errors)
out = self.compress(clean_data)
self.validate(out)
return out
def clean(self, value):
"""
Validates every value in the given list. A value is validated against
the corresponding Field in self.fields.
For example, if this MultiValueField was instantiated with
fields=(DateField(), TimeField()), clean() would call
DateField.clean(value[0]) and TimeField.clean(value[1]).
"""
clean_data = []
errors = ErrorList()
# Currently no file is uploaded so we continue validation.
# If a file is already updated is and you haven't
# if not value or isinstance(value, (list, tuple)):
# if not value or not [v for v in value if v not in validators.EMPTY_VALUES]:
# if self.required:
# raise ValidationError(self.error_messages['required'])
# else:
# return self.compress([])
# else:
# raise ValidationError(self.error_messages['invalid'])
if value[0]:
try:
field_value = value[0]
except IndexError:
field_value = None
if self.required and field_value in validators.EMPTY_VALUES:
raise ValidationError(self.error_messages['required'])
try:
clean_data.append(self.fields[0].clean(field_value))
except ValidationError, e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter.
errors.extend(e.messages)
clean_data.extend([None for i in range(6)])
def clean(self, value):
"""
Validates every value in the given list. A value is validated against
the corresponding Field in self.fields.
For example, if this MultiValueField was instantiated with
fields=(DateField(), TimeField()), clean() would call
DateField.clean(value[0]) and TimeField.clean(value[1]).
"""
clean_data = []
errors = ErrorList()
if not value or isinstance(value, (list, tuple)):
if not value or not [v for v in value if v not in self.empty_values]:
if self.required:
raise ValidationError(self.error_messages['required'])
else:
return []
else:
raise ValidationError(self.error_messages['invalid'])
field = self.field_type(required=self.required)
for field_value in value:
if self.required and field_value in self.empty_values:
raise ValidationError(self.error_messages['required'])
try:
clean_data.append(field.clean(field_value))
except ValidationError as e:
# Collect all validation errors in a single list, which we'll
# raise at the end of clean(), rather than raising a single
# exception for the first error we encounter.
errors.extend(e.messages)
if field.required:
field.required = False
if errors:
raise ValidationError(errors)
self.validate(clean_data)
self.run_validators(clean_data)
return clean_data
def _validate_fields(self):
"""
Validate individual field values, like django's clean_<fieldname> with
less magic ( no setattr('clean_'+field_name) junk) just loop over
the fields and apply the validators specified in the
field spec (self._get_expected_fields_for_row(row))
"""
cleaned_data = {}
errors = ErrorList()
for row_num, row in enumerate(self.rows):
expected_fields = self._get_validators_for_row(row)
if len(row) != len(expected_fields):
raise serializers.ValidationError(
"Row: %s - Incorrect number of columns should be %s "
"actually %s" % (row_num + 1, len(expected_fields), len(row))
)
for idx, field_name in enumerate(expected_fields):
field_value = row[idx]
validators = expected_fields[field_name]
try:
cleaned_data[field_name] = self._validate_field(
field_name, field_value.strip(), idx, row_num, validators
)
except serializers.ValidationError as ve:
errors.append(ve)
except (AssertionError, TypeError) as e:
errors.append(e)
try:
# Global Validation
applicable_contract = self._get_applicable_contract_for_row(row)
self.cleaned_data.append(self._validate_data(cleaned_data, row_num, applicable_contract))
except serializers.ValidationError as ve:
errors.extend(ve.error_list)
if len(errors):
raise serializers.ValidationError(errors)
class Field(object):
value = None
error_messages = {
'required': _(u'This field is required.'),
'invalid': _(u'Enter a valid value.'),
}
def __init__(self, label, help_text, html, required, default_value=None, attrs={}):
self.label_text = label
self.help_text = help_text
self.html = html
self.required = required
self.default_value = default_value
self.attrs = attrs
self.errors = ErrorList()
@property
def label(self):
return mark_safe(u'<label for="%s" class="label-text">%s</label>' % (self.first_name, self.label_text))
@property
def type(self):
return self.__class__.__name__
def render(self, value):
self._set_attrs(self.attrs)
if self.default_value:
self._set_value(self.default_value)
if value:
self._set_value(value)
return mark_safe(' '.join([unicode(tag) for tag in self.html.contents]))
def __unicode__(self):
return self.render(self.value)
def clean(self, value):
self.errors = ErrorList()
self.value = value
try:
self.validate(value)
except ValidationError as e:
self.errors.extend(e.messages)
if self.errors:
raise ValidationError(self.errors)
return value
def validate(self, value):
if value in validators.EMPTY_VALUES and self.required:
raise ValidationError(self.error_messages['required'])
@property
def names(self):
duplicated_names = [el['name'] for el in self.html.find_all('input') + self.html.find_all('textarea') + self.html.find_all('select')]
names = []
for name in duplicated_names:
if not name in names:
names.append(name)
return names
@property
def first_name(self):
if not self.names:
return ''
return self.names[0]
def _set_attrs(self, attrs):
pass
def _set_value(self, value):
pass
class Field(object):
value = None
error_messages = {
'required': _(u'This field is required.'),
'invalid': _(u'Enter a valid value.'),
}
def __init__(self,
label,
help_text,
html,
required,
default_value=None,
attrs={}):
self.label_text = label
self.help_text = help_text
self.html = html
self.required = required
self.default_value = default_value
self.attrs = attrs
self.errors = ErrorList()
@property
def label(self):
return mark_safe(u'<label for="%s" class="label-text">%s</label>' %
(self.first_name, self.label_text))
@property
def type(self):
return self.__class__.__name__
def render(self, value):
self._set_attrs(self.attrs)
if self.default_value:
self._set_value(self.default_value)
if value:
self._set_value(value)
return mark_safe(' '.join([unicode(tag)
for tag in self.html.contents]))
def __unicode__(self):
return self.render(self.value)
def clean(self, value):
self.errors = ErrorList()
self.value = value
try:
self.validate(value)
except ValidationError as e:
self.errors.extend(e.messages)
if self.errors:
raise ValidationError(self.errors)
return value
def validate(self, value):
if value in validators.EMPTY_VALUES and self.required:
raise ValidationError(self.error_messages['required'])
@property
def names(self):
duplicated_names = [
el['name'] for el in self.html.find_all('input') +
self.html.find_all('textarea') + self.html.find_all('select')
]
names = []
for name in duplicated_names:
if not name in names:
names.append(name)
return names
@property
def first_name(self):
if not self.names:
return ''
return self.names[0]
def _set_attrs(self, attrs):
pass
def _set_value(self, value):
pass
def hidden_field_errors(form):
hidden_field_errors = ErrorList()
for field in form.hidden_fields():
hidden_field_errors.extend(field.errors)
return hidden_field_errors
def hidden_field_errors(form):
hidden_field_errors = ErrorList()
for field in form.hidden_fields():
hidden_field_errors.extend(field.errors)
return hidden_field_errors
