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_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