152 lines
5.2 KiB
Python
152 lines
5.2 KiB
Python
from django.core import validators
|
|
from django.core.exceptions import ValidationError
|
|
from django.utils.translation import gettext_lazy as _
|
|
|
|
# NOTE: As this module may be imported by configuration.py, we cannot import
|
|
# anything from NetBox itself.
|
|
|
|
|
|
class IsEqualValidator(validators.BaseValidator):
|
|
"""
|
|
Employed by CustomValidator to require a specific value.
|
|
"""
|
|
message = _("Ensure this value is equal to %(limit_value)s.")
|
|
code = "is_equal"
|
|
|
|
def compare(self, a, b):
|
|
return a != b
|
|
|
|
|
|
class IsNotEqualValidator(validators.BaseValidator):
|
|
"""
|
|
Employed by CustomValidator to exclude a specific value.
|
|
"""
|
|
message = _("Ensure this value does not equal %(limit_value)s.")
|
|
code = "is_not_equal"
|
|
|
|
def compare(self, a, b):
|
|
return a == b
|
|
|
|
|
|
class IsEmptyValidator:
|
|
"""
|
|
Employed by CustomValidator to enforce required fields.
|
|
"""
|
|
message = _("This field must be empty.")
|
|
code = 'is_empty'
|
|
|
|
def __init__(self, enforce=True):
|
|
self._enforce = enforce
|
|
|
|
def __call__(self, value):
|
|
if self._enforce and value not in validators.EMPTY_VALUES:
|
|
raise ValidationError(self.message, code=self.code)
|
|
|
|
|
|
class IsNotEmptyValidator:
|
|
"""
|
|
Employed by CustomValidator to enforce prohibited fields.
|
|
"""
|
|
message = _("This field must not be empty.")
|
|
code = 'not_empty'
|
|
|
|
def __init__(self, enforce=True):
|
|
self._enforce = enforce
|
|
|
|
def __call__(self, value):
|
|
if self._enforce and value in validators.EMPTY_VALUES:
|
|
raise ValidationError(self.message, code=self.code)
|
|
|
|
|
|
class CustomValidator:
|
|
"""
|
|
This class enables the application of user-defined validation rules to NetBox models. It can be instantiated by
|
|
passing a dictionary of validation rules in the form {attribute: rules}, where 'rules' is a dictionary mapping
|
|
descriptors (e.g. min_length or regex) to values.
|
|
|
|
A CustomValidator instance is applied by calling it with the instance being validated:
|
|
|
|
validator = CustomValidator({'name': {'min_length: 10}})
|
|
site = Site(name='abcdef')
|
|
validator(site) # Raises ValidationError
|
|
|
|
:param validation_rules: A dictionary mapping object attributes to validation rules
|
|
"""
|
|
VALIDATORS = {
|
|
'eq': IsEqualValidator,
|
|
'neq': IsNotEqualValidator,
|
|
'min': validators.MinValueValidator,
|
|
'max': validators.MaxValueValidator,
|
|
'min_length': validators.MinLengthValidator,
|
|
'max_length': validators.MaxLengthValidator,
|
|
'regex': validators.RegexValidator,
|
|
'required': IsNotEmptyValidator,
|
|
'prohibited': IsEmptyValidator,
|
|
}
|
|
|
|
def __init__(self, validation_rules=None):
|
|
self.validation_rules = validation_rules or {}
|
|
assert type(self.validation_rules) is dict, "Validation rules must be passed as a dictionary"
|
|
|
|
def __call__(self, instance):
|
|
# Validate instance attributes per validation rules
|
|
for attr_name, rules in self.validation_rules.items():
|
|
attr = self._getattr(instance, attr_name)
|
|
for descriptor, value in rules.items():
|
|
validator = self.get_validator(descriptor, value)
|
|
try:
|
|
validator(attr)
|
|
except ValidationError as exc:
|
|
# Re-package the raised ValidationError to associate it with the specific attr
|
|
raise ValidationError({attr_name: exc})
|
|
|
|
# Execute custom validation logic (if any)
|
|
self.validate(instance)
|
|
|
|
@staticmethod
|
|
def _getattr(instance, name):
|
|
# Attempt to resolve many-to-many fields to their stored values
|
|
m2m_fields = [f.name for f in instance._meta.local_many_to_many]
|
|
if name in m2m_fields:
|
|
if name in getattr(instance, '_m2m_values', []):
|
|
return instance._m2m_values[name]
|
|
if instance.pk:
|
|
return list(getattr(instance, name).all())
|
|
return []
|
|
|
|
# Raise a ValidationError for unknown attributes
|
|
if not hasattr(instance, name):
|
|
raise ValidationError(_('Invalid attribute "{name}" for {model}').format(
|
|
name=name,
|
|
model=instance.__class__.__name__
|
|
))
|
|
|
|
return getattr(instance, name)
|
|
|
|
def get_validator(self, descriptor, value):
|
|
"""
|
|
Instantiate and return the appropriate validator based on the descriptor given. For
|
|
example, 'min' returns MinValueValidator(value).
|
|
"""
|
|
if descriptor not in self.VALIDATORS:
|
|
raise NotImplementedError(
|
|
f"Unknown validation type for {self.__class__.__name__}: '{descriptor}'"
|
|
)
|
|
validator_cls = self.VALIDATORS.get(descriptor)
|
|
return validator_cls(value)
|
|
|
|
def validate(self, instance):
|
|
"""
|
|
Custom validation method, to be overridden by the user. Validation failures should
|
|
raise a ValidationError exception.
|
|
"""
|
|
return
|
|
|
|
def fail(self, message, field=None):
|
|
"""
|
|
Raise a ValidationError exception. Associate the provided message with a form/serializer field if specified.
|
|
"""
|
|
if field is not None:
|
|
raise ValidationError({field: message})
|
|
raise ValidationError(message)
|