def clean(self):
"""Validate that the form is valid and that the destinations can accept
the storage and/or interfaces configuration from the source."""
cleaned_data = super().clean()
source = self.cleaned_data.get("source")
if not source:
# Django should be placing this automatically, but it does not
# occur. So we force the setting of this error here.
set_form_error(self, "source", "This field is required.")
destinations = self.cleaned_data.get("destinations")
destination_field = self.fields["destinations"]
item_invalid = destination_field.error_messages["item_invalid"]
storage = self.cleaned_data.get("storage", False)
interfaces = self.cleaned_data.get("interfaces", False)
if source and destinations:
for index, dest in enumerate(destinations):
if source == dest:
error = prefix_validation_error(
ValidationError(
"Source machine cannot be a destination machine."
),
prefix=item_invalid,
code="item_invalid",
params={"nth": index},
)
set_form_error(self, "destinations", error)
else:
if storage:
try:
dest._get_storage_mapping_between_nodes(source)
except ValidationError as exc:
error = prefix_validation_error(
exc,
prefix=item_invalid,
code="item_invalid",
params={"nth": index},
)
set_form_error(self, "destinations", error)
if interfaces:
try:
dest._get_interface_mapping_between_nodes(source)
except ValidationError as exc:
error = prefix_validation_error(
exc,
prefix=item_invalid,
code="item_invalid",
params={"nth": index},
)
set_form_error(self, "destinations", error)
if not storage and not interfaces:
set_form_error(
self, "__all__", "Either storage or interfaces must be true."
)
return cleaned_data
def clean(self, value):
LOGGER.debug("clean: > %s", value)
if all(
value.get(name) in field.empty_values
for name, field in self.fields.items()):
if self.required:
raise forms.ValidationError("This section is required",
code='incomplete')
else:
value = None
else:
cleaned_data = {}
errors = []
for name, field in self.fields.items():
try:
cleaned_data[name] = field.clean(value.get(name))
except forms.ValidationError as error:
errors.append(
prefix_validation_error(error,
code='field_invalid',
prefix='%(label)s: ',
params={'label': field.label}))
if errors:
raise forms.ValidationError(errors)
value = self.model(**cleaned_data)
LOGGER.debug("clean: < %s", value)
return value
def clean(self, value):
cleaned_data = []
errors = []
if value is not None:
value = [x for x in value if x]
for index, item in enumerate(value):
try:
cleaned_data.append(self.base_field.clean(item))
except forms.ValidationError as error:
errors.append(
prefix_validation_error(
error,
self.error_messages["item_invalid"],
code="item_invalid",
params={"nth": index}))
if not value:
cleaned_data = self.default() if callable(
self.default) else self.default
if cleaned_data is None and self.initial is not None:
cleaned_data = self.initial() if callable(
self.initial) else self.initial
if errors:
raise forms.ValidationError(list(chain.from_iterable(errors)))
if not cleaned_data and self.required:
raise forms.ValidationError(self.error_messages["required"])
return cleaned_data
def clean(self, value):
LOGGER.debug("clean: > %s", value)
if all(value.get(name) in field.empty_values
for name, field in self.fields.items()):
if self.required:
raise forms.ValidationError("This section is required",
code='incomplete')
else:
value = None
else:
cleaned_data = {}
errors = []
for name, field in self.fields.items():
try:
cleaned_data[name] = field.clean(value.get(name))
except forms.ValidationError as error:
if DJANGO21:
prefix = '%(label)s:'
else:
prefix = '%(label)s: '
errors.append(prefix_validation_error(
error, code='field_invalid',
prefix=prefix, params={'label': field.label}))
if errors:
raise forms.ValidationError(errors)
value = self.model(**cleaned_data)
LOGGER.debug("clean: < %s", value)
return value
def run_validators(self, value: Any) -> None:
super().run_validators(value)
errors = []
for index, item in enumerate(value):
try:
self.base_field.run_validators(item)
except ValidationError as error:
errors.append(
prefix_validation_error(
error,
prefix=self.error_messages["item_invalid"],
code="item_invalid",
params={"nth": index + 1},
))
if errors:
raise ValidationError(errors)
def validate(self, value):
# don't call SimpleArrayField validate method!
super(SimpleArrayField, self).validate(value)
errors = []
for index, item in enumerate(value):
try:
self.base_field.validate(item)
except ValidationError as error:
errors.append(
prefix_validation_error(
error,
prefix=self.error_messages['item_invalid'],
code='item_invalid',
params={'nth': index + 1},
))
if errors:
raise ValidationError(errors)
def clean(self, value):
cleaned_data = []
errors = []
value = filter(None, value)
for index, item in enumerate(value):
try:
cleaned_data.append(self.base_field.clean(item))
except forms.ValidationError as error:
errors.append(
prefix_validation_error(
error, self.error_messages["item_invalid"], code="item_invalid", params={"nth": index}
)
)
if errors:
raise forms.ValidationError(list(chain.from_iterable(errors)))
if not cleaned_data and self.required:
raise forms.ValidationError(self.error_messages["required"])
return cleaned_data
def run_validators(self, value):
# don't call SimpleArrayField run_validators method!
super(SimpleArrayField, self).run_validators(value)
errors = []
for index, item in enumerate(value):
try:
self.base_field.run_validators(item)
except ValidationError as error:
errors.append(
prefix_validation_error(
error,
prefix=self.error_messages['item_invalid'],
code='item_invalid',
params={'nth': index + 1},
))
if len(set(value)) < len(value):
errors.append(self.error_messages['items_occur_multiple'])
if errors:
raise ValidationError(errors)
def to_python(self, value):
if value is None:
return None
if isinstance(value, list):
errors = []
values = []
for index, item in enumerate(value):
try:
values.append(self.base_field.to_python(item))
except ValidationError as error:
errors.append(prefix_validation_error(
error,
prefix=self.error_messages['item_invalid'],
code='item_invalid',
params={'nth': index},
))
if errors:
raise ValidationError(errors)
else:
raise ValidationError(ugettext('Enter a list.'))
return values
def to_python(self, value):
if isinstance(value, list):
items = value
elif value:
items = value.split(self.delimiter)
else:
items = []
errors = []
values = []
range_pattern = re.compile('^(\d+)-(\d+)$')
range_items = []
for index, item in enumerate(items):
is_range = range_pattern.match(item.strip())
if is_range:
range_items += self.expand_range(item.strip())
# removing item decreases index used in errors,
# so we pop an item off range_items in its place
items.remove(item)
items.insert(index, range_items.pop())
# extend items so the index into the original input is not disturbed.
items.extend(range_items)
for index, item in enumerate(items):
try:
values.append(self.base_field.to_python(item))
except ValidationError as error:
errors.append(
prefix_validation_error(
error,
prefix=self.error_messages['item_invalid'],
code='item_invalid',
params={'nth': index + 1},
))
if errors:
raise ValidationError(errors)
return values
def to_python(self, value):
if value is None:
return None
if isinstance(value, list):
errors = []
values = []
for index, item in enumerate(value):
try:
values.append(self.base_field.to_python(item))
except ValidationError as error:
errors.append(
prefix_validation_error(
error,
prefix=self.error_messages['item_invalid'],
code='item_invalid',
params={'nth': index},
))
if errors:
raise ValidationError(errors)
else:
raise ValidationError(ugettext('Enter a list.'))
return values
def to_python(self, value: Any) -> List[Any]:
if isinstance(value, list):
items = value
elif value:
items = value.split(self.delimiter)
else:
items = []
errors = []
values = []
for index, item in enumerate(items):
try:
values.append(self.base_field.to_python(item))
except ValidationError as error:
errors.append(
prefix_validation_error(
error,
prefix=self.error_messages["item_invalid"],
code="item_invalid",
params={"nth": index + 1},
))
if errors:
raise ValidationError(errors)
return values
def prefix_validation_error(error, prefix, code, params):
"""
Prefix a validation error message while maintaining the existing
validation data structure.
"""
if error.error_list == [error]:
error_params = error.params or {}
return ValidationError(
# We can't simply concatenate messages since they might require
# their associated parameters to be expressed correctly which
# is not something `string_concat` does. For example, proxied
# ungettext calls require a count parameter and are converted
# to an empty string if they are missing it.
message=string_concat(
SimpleLazyObject(lambda: prefix % params),
SimpleLazyObject(lambda: error.message % error_params),
),
code=code,
params=dict(error_params, **params),
)
return ValidationError([
prefix_validation_error(e, prefix, code, params)
for e in error.error_list
])
def clean(self):
"""Validate that the form is valid and that the destinations can accept
the storage and/or interfaces configuration from the source."""
cleaned_data = super().clean()
source = self.cleaned_data.get("source")
if not source:
# Django should be placing this automatically, but it does not
# occur. So we force the setting of this error here.
self.add_error("source", "This field is required.")
destinations = self.cleaned_data.get("destinations")
destination_field = self.fields["destinations"]
storage = self.cleaned_data.get("storage", False)
interfaces = self.cleaned_data.get("interfaces", False)
if source and destinations:
for dest in destinations:
if source == dest:
error = ValidationError(
destination_field.error_messages["is-source"],
code="is-source",
params={
"machine": str(dest),
"system_id": dest.system_id,
},
)
self.add_error("destinations", error)
else:
if storage:
try:
dest._get_storage_mapping_between_nodes(source)
except ValidationError as exc:
error = prefix_validation_error(
exc,
prefix=destination_field.
error_messages["storage"],
code="storage",
params={
"machine": str(dest),
"system_id": dest.system_id,
},
)
self.add_error("destinations", error)
if interfaces:
try:
dest._get_interface_mapping_between_nodes(source)
except ValidationError as exc:
error = prefix_validation_error(
exc,
prefix=destination_field.
error_messages["networking"],
code="networking",
params={
"machine": str(dest),
"system_id": dest.system_id,
},
)
self.add_error("destinations", error)
if not storage and not interfaces:
self.add_error(
"__all__",
ValidationError(
"Either storage or interfaces must be true.",
code="required",
),
)
return cleaned_data
