class TextValidator:
message = _('Введено недоступні символи.')
code = 'invalid'
text_regex = _lazy_re_compile(r"^[-!#$%& ',.\"*+/=?^_`{}\[\]|~0-9A-Z]+$", re.IGNORECASE)
name_regex = _lazy_re_compile(r"^[-!#%& ',.\"*+/=?^_`{}\[\]|~0-9A-Z]+$", re.IGNORECASE)
def __init__(self, message=None, code=None):
if message is not None:
self.message = message
if code is not None:
self.code = code
def __call__(self, text, min, max, name):
if (len(text) > max or min > len(text)) and max != -1:
raise ValidationError(_('%s повинен(-на) бути %d-%d символів.' % (name,min,max)), code=self.code)
if not self.text_regex.fullmatch(text):
raise ValidationError(message=self.message, code=self.code)
def ValidName(self, text, min, max, name):
if (len(text) > max or min > len(text)) and max != -1:
raise ValidationError(_('%s повинен(-на) бути %d-%d символів.' % (name,min,max)), code=self.code)
if not self.name_regex.fullmatch(text):
raise ValidationError(message=self.message, code=self.code)
def __eq__(self, other):
return (
isinstance(other, TextValidator) and
(self.message == other.message) and
(self.code == other.code)
)
class PhoneValidator(object):
message = u'Не верный формат номера телефона'
code = 'invalid'
code_city_regex = _lazy_re_compile(r'\d{3,5}')
phone_number_regex = _lazy_re_compile(r'\d{5,7}')
def __init__(self, message=None, code=None):
if message is not None:
self.message = message
if code is not None:
self.code = code
def __call__(self, value):
if not self.code_city_regex.match(self.find_all_numbers(value[1])):
raise ValidationError(self.message, code=self.code)
if not self.phone_number_regex.match(self.find_all_numbers(value[2])):
raise ValidationError(self.message, code=self.code)
def __eq__(self, other):
return (isinstance(other, PhoneValidator)
and (self.message == other.message)
and (self.code == other.code))
@staticmethod
def find_all_numbers(value):
return ''.join(re.findall('\d', value))
class NonStrictEmailValidator(validators.EmailValidator):
user_regex = validators._lazy_re_compile(
r"(^[-!#$%&'*+/=?^_`{}|~0-9A-Z]+(\.[-!#$%&'*+/=?^_`{}|~0-9A-Z]+)*\Z" # dot-atom
r"|^[-!#$%&.'*+/=?^_`{}|~0-9A-Z]+\Z" # docomoの古いアドレスなどである'.@'を許容する
r'|^"([\001-\010\013\014\016-\037!#-\[\]-\177]'
r'|\\[\001-\011\013\014\016-\177])*"\Z)', # quoted-string
re.IGNORECASE)
class Site(models.Model):
resource_group = models.ForeignKey(ResourceGroup, related_name="sites")
name = models.CharField(
max_length=100,
validators=[
validators.RegexValidator(
validators._lazy_re_compile(r"^[a-zA-Z0-9_-]+$"),
"Invalid name. (hint: ^[a-zA-Z0-9_-]+$)",
),
])
created = models.DateTimeField(default=timezone.now)
objects = SiteManager()
class Meta:
unique_together = [("resource_group", "name")]
def members(self):
member_set = set()
for member in self.resource_group.members():
member.role = {
"admin": "admin",
"technical": "ops",
}[member.role]
member_set.add(member)
for membership in SiteMembership.objects.filter(site=self):
member = membership.user
member.role = membership.role
member_set.add(member)
return member_set
class EnhancedURLValidator(URLValidator):
"""
Extends Django's built-in URLValidator to permit the use of hostnames with no domain extension.
"""
class AnyURLScheme(object):
"""
A fake URL list which "contains" all scheme names abiding by the syntax defined in RFC 3986 section 3.1
"""
def __contains__(self, item):
if not item or not re.match(r'^[a-z][0-9a-z+\-.]*$', item.lower()):
return False
return True
fqdn_re = URLValidator.hostname_re + URLValidator.domain_re + URLValidator.tld_re
host_res = [
URLValidator.ipv4_re, URLValidator.ipv6_re, fqdn_re,
URLValidator.hostname_re
]
regex = _lazy_re_compile(
r'^(?:[a-z0-9\.\-\+]*)://' # Scheme (previously enforced by AnyURLScheme or schemes kwarg)
r'(?:\S+(?::\S*)?@)?' # HTTP basic authentication
r'(?:' + '|'.join(host_res) + ')' # IPv4, IPv6, FQDN, or hostname
r'(?::\d{2,5})?' # Port number
r'(?:[/?#][^\s]*)?' # Path
r'\Z',
re.IGNORECASE)
schemes = AnyURLScheme()
class EnhancedURLValidator(URLValidator):
"""
Extends Django's built-in URLValidator to permit the use of hostnames with no domain extension and enforce allowed
schemes specified in the configuration.
"""
fqdn_re = URLValidator.hostname_re + URLValidator.domain_re + URLValidator.tld_re
host_res = [
URLValidator.ipv4_re, URLValidator.ipv6_re, fqdn_re,
URLValidator.hostname_re
]
regex = _lazy_re_compile(
r'^(?:[a-z0-9\.\-\+]*)://' # Scheme (enforced separately)
r'(?:\S+(?::\S*)?@)?' # HTTP basic authentication
r'(?:' + '|'.join(host_res) + ')' # IPv4, IPv6, FQDN, or hostname
r'(?::\d{2,5})?' # Port number
r'(?:[/?#][^\s]*)?' # Path
r'\Z',
re.IGNORECASE)
schemes = None
def __call__(self, value):
if self.schemes is None:
# We can't load the allowed schemes until the configuration has been initialized
self.schemes = get_config().ALLOWED_URL_SCHEMES
return super().__call__(value)
class LTreeLabelField(CharField):
description = _("PostgreSQL ltree label (up to %(max_length)s)")
default_validators = [
RegexValidator(
_lazy_re_compile(r'^[a-zA-Z0-9_]+\Z'),
_("Enter a valid 'ltree label' consisting of letters, numbers or underscores."
), 'invalid')
]
def __init__(self, *args, **kwargs):
kwargs['max_length'] = 255
kwargs['editable'] = False
kwargs['unique'] = True
self.allow_unicode = False
super().__init__(*args, **kwargs)
def deconstruct(self):
name, path, args, kwargs = super().deconstruct()
del kwargs['max_length']
del kwargs['editable']
del kwargs['unique']
return name, path, args, kwargs
def validate_url(url, schemes=('http', 'https')):
"""Validator for URLs.
Uses's django's URLValidator plumbing but isn't as restrictive and
URLs of the form http://foo are considered valid.
Built from:
`https://docs.djangoproject.com/en/2.1/_modules/django/
core/validators/#URLValidator`
:param url: Input value for a url.
:raise ValidationError: If the url is not valid.
"""
# Re-structure django's regex.
url_validator = URLValidator
host_re = ('(' + url_validator.hostname_re + url_validator.domain_re +
url_validator.tld_re + '|' + url_validator.hostname_re +
'|localhost)')
regex = _lazy_re_compile(
r'^(?:[a-z0-9\.\-\+]*)://' # scheme is validated separately
r'(?:\S+(?::\S*)?@)?' # user:pass authentication
r'(?:' + url_validator.ipv4_re + '|' + url_validator.ipv6_re + '|' +
host_re + ')'
r'(?::\d{2,5})?' # port
r'(?:[/?#][^\s]*)?' # resource path
r'\Z',
re.IGNORECASE)
url_validator.regex = regex
valid_url = url_validator(schemes=schemes)
# Validate the url.
return valid_url(url)
class CustomURLValidator(URLValidator):
ul = '\u00a1-\uffff' # unicode letters range (must not be a raw string)
# IP patterns
ipv4_re = r'(?:25[0-5]|2[0-4]\d|[0-1]?\d?\d)(?:\.(?:25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}'
ipv6_re = r'\[[0-9a-f:\.]+\]' # (simple regex, validated later)
# Host patterns
hostname_re = r'[a-z' + ul + r'0-9](?:[a-z' + ul + r'0-9-]{0,61}[a-z' + ul + r'0-9])?'
# Max length for domain name labels is 63 characters per RFC 1034 sec. 3.1
domain_re = r'(?:\.(?!-)[a-z' + ul + r'0-9-]{1,63}(?<!-))*'
tld_re = (
r'\.' # dot
r'(?!-)' # can't start with a dash
r'(?:[a-z' + ul + '-]{2,63}' # domain label
r'|xn--[a-z0-9]{1,59})' # or punycode label
r'(?<!-)' # can't end with a dash
r'\.?' # may have a trailing dot
)
host_re = '(' + hostname_re + domain_re + tld_re + ')'
loopbacks = r'localhost|127(?:\.[0-9]+){0,2}\.[0-9]+|(?:0*\:)*?:?0*1'
regex = _lazy_re_compile(
r'^(?:[a-z0-9\.\-\+]*)://' # scheme is validated separately
r'(?:\S+(?::\S*)?@)?' # user:pass authentication
r'(?!' + loopbacks + r')' # exclude loopbacks
r'(?:' + ipv4_re + '|' + ipv6_re + '|' + host_re + ')'
r'(?::\d{2,5})?' # port
r'(?:[/?#][^\s]*)?' # resource path
r'\Z',
re.IGNORECASE)
schemes = ['http', 'https']
class ExtendedUrlValidator(validators.URLValidator):
"""
Fully copied django default url validator, but allowed
urls with additional schemas and without dots extensions.
Django do not offer legal methods for partial overriding
of url regexp validator
"""
schemes = ['http', 'https', 'ftp', 'ftps', 'tg']
ul = '\u00a1-\uffff' # unicode letters range (must not be a raw string)
# IP patterns
ipv4_re = r'(?:25[0-5]|2[0-4]\d|[0-1]?\d?\d)(?:\.(?:25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}'
ipv6_re = r'\[[0-9a-f:\.]+\]' # (simple regex, validated later)
# Host patterns
hostname_re = r'[a-z' + ul + r'0-9](?:[a-z' + ul + r'0-9-]{0,61}[a-z' + ul + r'0-9])?'
# Max length for domain name labels is 63 characters per RFC 1034 sec. 3.1
domain_re = r'(?:\.(?!-)[a-z' + ul + r'0-9-]{1,63}(?<!-))*'
tld_re = (
r'\.?' # dot
r'(?!-)' # can't start with a dash
r'(?:[a-z' + ul + '-]{2,63}' # domain label
r'|xn--[a-z0-9]{1,59})' # or punycode label
r'(?<!-)' # can't end with a dash
r'\.?' # may have a trailing dot
)
host_re = '(' + hostname_re + domain_re + tld_re + '|localhost)'
regex = validators._lazy_re_compile(
r'^(?:[a-z0-9\.\-\+]*)://' # scheme is validated separately
r'(?:\S+(?::\S*)?@)?' # user:pass authentication
r'(?:' + ipv4_re + '|' + ipv6_re + '|' + host_re + ')'
r'(?::\d{2,5})?' # port
r'(?:[/?#][^\s]*)?' # resource path
r'\Z', re.IGNORECASE)
class ResourceGroup(models.Model):
name = models.CharField(
max_length=100,
unique=True,
validators=[
validators.RegexValidator(
validators._lazy_re_compile(r"^[a-zA-Z0-9_-]+$"),
"Invalid name. (hint: ^[a-zA-Z0-9_-]+$)",
),
])
created = models.DateTimeField(default=timezone.now)
objects = ResourceGroupManager()
def __str__(self):
return self.name
def set_owner(self, owner):
ResourceGroupMembership.objects.get_or_create(
resource_group=self,
user=owner,
defaults={
"role": "admin",
},
)
def members(self):
member_set = set()
for membership in ResourceGroupMembership.objects.filter(
resource_group=self):
member = membership.user
member.role = membership.role
member_set.add(member)
return member_set
def validate_foreign_key_field(value):
if not isinstance(value,
int) and not _lazy_re_compile('^\d+$').match(value):
raise ValidationError(
'ForeignKeyField字段数据, 必须为int类型或正整数字符串. 当前值为: {0}'.format(
value))
new_value = int(value)
return new_value
class UserValidator:
message = _('Невірно введені дані користувача.')
code = 'invalid'
names_regex = _lazy_re_compile(r'[A-z]{3,24}\Z', re.IGNORECASE)
password_regex = _lazy_re_compile(r"([-!#$%&'.*+/=?^_`{}|~0-9A-Z]+){6,32}", re.IGNORECASE)
password_alf_regex = _lazy_re_compile(r"[A-z]+", re.IGNORECASE)
password_num_regex = _lazy_re_compile(r"[0-9]+", re.IGNORECASE)
def __init__(self, message=None, code=None):
if message is not None:
self.message = message
if code is not None:
self.code = code
def __call__(self, name, surname, email, pass1, pass2):
self.ValidNames(name,surname)
self.ValidEmail(email)
self.ValidPasswords(pass1, pass2)
def ValidNames(self, name, surname):
if not self.names_regex.fullmatch(name) or not self.names_regex.match(surname):
raise ValidationError(_('Ім\'я та фамілія повинні містити тільки літери ( 3-24літ. )'), code='names')
def ValidEmail(self, emaila):
validate_email = EmailValidator('Невірно введена E-mail адреса.')
validate_email(emaila)
try:
User.objects.get(email=emaila)
raise ValidationError(_('E-mail адреса зайнята.'), code='resemail')
except User.DoesNotExist:
pass
def ValidPasswords(self, password, cpassword):
if password != cpassword:
raise ValidationError(_('Паролі повинні співпадати.'), code='notequals')
if not self.password_regex.fullmatch(password):
raise ValidationError(_('Недоступний пароль ( 6-32сим. )'), code='badpass')
if not self.password_num_regex.search(password):
raise ValidationError(_('Пароль повинен містити цифри.'), code='numpassword')
if not self.password_alf_regex.search(password):
raise ValidationError(_('Пароль повинен містити літери.'), code='alfpassword')
def __eq__(self, other):
return (
isinstance(other, UserValidator) and
(self.message == other.message) and
(self.code == other.code)
)
def validate_skype(value):
value = force_text(value)
skype_regex = _lazy_re_compile(r'[a-zA-Z][\w,.-]+$')
if skype_regex.match(value):
return True
raise ValidationError(_("Invalid Skype username"))
def validate_telegram(value):
value = force_text(value)
telegram_regex = _lazy_re_compile(r'@[a-zA-Z]\w+[a-zA-Z0-9]$')
if telegram_regex.match(value):
return True
raise ValidationError(_("Invalid Telegram username"))
class VariableSchemeUrlValidator(URLValidator):
""" Валидатор URL который не проверяет схему URL """
regex = _lazy_re_compile(
r'(?:\S+(?::\S*)?@)?' # user:pass authentication
r'(?:' + URLValidator.ipv4_re + '|' + URLValidator.ipv6_re + '|' +
URLValidator.host_re + ')'
r'(?::\d{2,5})?' # port
r'(?:[/?#][^\s]*)?' # resource path
r'\Z',
re.IGNORECASE)
def __call__(self, value):
if '://' in value:
scheme = value.split('://')[0].lower()
else:
scheme = None
# отключаю проверку схемы url
if scheme:
if scheme not in self.schemes:
raise ValidationError(self.message, code=self.code)
try:
super(URLValidator, self).__call__(value)
except ValidationError as e:
if value:
try:
scheme, netloc, path, query, fragment = urlsplit(value)
except ValueError: # for example, "Invalid IPv6 URL"
raise ValidationError(self.message, code=self.code)
try:
netloc = netloc.encode('idna').decode(
'ascii') # IDN -> ACE
except UnicodeError: # invalid domain part
raise e
url = urlunsplit((scheme, netloc, path, query, fragment))
super().__call__(url)
else:
raise
else:
# Now verify IPv6 in the netloc part
host_match = re.search(r'^\[(.+)\](?::\d{2,5})?$',
urlsplit(value).netloc)
if host_match:
potential_ip = host_match.groups()[0]
try:
validate_ipv6_address(potential_ip)
except ValidationError:
raise ValidationError(self.message, code=self.code)
# The maximum length of a full host name is 253 characters per RFC 1034
# section 3.1. It's defined to be 255 bytes or less, but this includes
# one byte for the length of the name and one byte for the trailing dot
# that's used to indicate absolute names in DNS.
if len(urlsplit(value).netloc) > 253:
raise ValidationError(self.message, code=self.code)
class UserProfileForm(forms.ModelForm):
validate_username = RegexValidator(
_lazy_re_compile(r'^[-a-z0-9_]+\Z'),
"Your username cannot include spaces, punctuation or capital letters.",
'invalid')
first_name = forms.CharField(label='First name')
last_name = forms.CharField(label='Last name')
username = forms.CharField(label='Username',
validators=[validate_username])
country = forms.ModelChoiceField(required=True,
queryset=Country.objects,
label='Country',
empty_label=None)
class Meta:
model = UserProfile
fields = (
# personal info (also includes first_name and last_name)
'profile_photo',
'bio',
# work
'organisations',
'skills',
'qualifications',
'specialisations',
'areas_of_law',
# social
'twitter_username',
'linkedin_profile',
)
def clean_twitter_username(self):
if self.cleaned_data['twitter_username']:
twitter_username = self.cleaned_data['twitter_username'].strip('@')
return twitter_username
def clean_username(self):
username = self.cleaned_data['username']
if User.objects.filter(username=username).exclude(
pk=self.instance.user.pk).exists():
raise forms.ValidationError("This username is already taken.")
return username
def save(self, commit=True):
super(UserProfileForm, self).save()
self.instance.user.first_name = self.cleaned_data['first_name']
self.instance.user.last_name = self.cleaned_data['last_name']
self.instance.user.username = self.cleaned_data['username']
self.instance.user.editor.country = self.cleaned_data['country']
self.instance.user.editor.save()
self.instance.user.save()
def test_create_with_validation_rule(self):
ValidationRule.objects.create(
field_reference=(EducationGroupYear._meta.db_table + ".acronym." +
self.education_group_type.external_id),
initial_value="yolo",
status_field=NOT_REQUIRED,
regex_rule="([A-Z]{2})(.*)")
form = GroupYearModelForm(
education_group_type=self.education_group_type, user=self.user)
self.assertEqual(form.fields["acronym"].initial, "yolo")
self.assertEqual(form.fields["acronym"].required, False)
self.assertEqual(form.fields["acronym"].validators[1].regex,
_lazy_re_compile("([A-Z]{2})(.*)"))
def validate_many_to_many_field(value):
assert isinstance(
value, (tuple, list)
), 'ManyToManyField字段数据, 必须为(list, tuple). 当前值为: {0}'.format(value)
new_value = list()
for fv in value:
if not isinstance(
value,
(int, Model)) and not _lazy_re_compile('^\d+$').match(fv):
raise ValidationError(
'ManyToManyField字段数据序列的值, 只能为(int, Model, 正整数字符串)类型. 当前值为: {0}'
.format(value))
new_value.append(int(fv))
new_value.sort()
return new_value
class Service(models.Model):
site = models.ForeignKey(Site, related_name="services")
name = models.CharField(
max_length=50,
validators=[
validators.RegexValidator(
validators._lazy_re_compile(r"^[a-zA-Z0-9-]+$"),
"Invalid name. (hint: ^[a-zA-Z0-9-]+$)",
),
])
created = models.DateTimeField(default=timezone.now)
class Meta:
unique_together = [("site", "name")]
class ResourceGroup(models.Model):
name = models.CharField(
max_length=100,
unique=True,
validators=[
validators.RegexValidator(
validators._lazy_re_compile(r"^[a-zA-Z0-9_-]+$"),
"Invaid name. (hint: ^[a-zA-Z0-9_-]+$)",
),
]
)
personal = models.BooleanField(default=False)
created = models.DateTimeField(default=timezone.now)
deleted = models.DateTimeField(null=True, blank=True)
objects = ResourceGroupManager()
def __str__(self):
return self.name
def delete(self, **kwargs):
for site in self.site_set.active():
site.delete()
self.deleted = timezone.now()
self.save()
def set_owner(self, owner):
ResourceGroupUser.objects.get_or_create(
resource_group=self,
user=owner,
defaults={
"role": "admin",
},
)
def users(self):
us = []
for membership in ResourceGroupUser.objects.filter(resource_group=self, resource_group__deleted__isnull=True):
user = membership.user
user.role = membership.role
us.append(user)
return us
class EnhancedURLValidator(URLValidator):
"""
Extends Django's built-in URLValidator to permit the use of hostnames with no domain extension and enforce allowed
schemes specified in the configuration.
"""
fqdn_re = URLValidator.hostname_re + URLValidator.domain_re + URLValidator.tld_re
host_res = [
URLValidator.ipv4_re, URLValidator.ipv6_re, fqdn_re,
URLValidator.hostname_re
]
regex = _lazy_re_compile(
r'^(?:[a-z0-9\.\-\+]*)://' # Scheme (enforced separately)
r'(?:\S+(?::\S*)?@)?' # HTTP basic authentication
r'(?:' + '|'.join(host_res) + ')' # IPv4, IPv6, FQDN, or hostname
r'(?::\d{2,5})?' # Port number
r'(?:[/?#][^\s]*)?' # Path
r'\Z',
re.IGNORECASE)
schemes = settings.ALLOWED_URL_SCHEMES
def __init__(self, **kwargs):
self.allow_blank = kwargs.pop('allow_blank', False)
self.trim_whitespace = False
self.max_length = 24
self.min_length = 24
super(serializers.CharField, self).__init__(**kwargs)
message = self.error_messages['max_length'].format(
max_length=self.max_length)
self.validators.append(
MaxLengthValidator(self.max_length, message=message))
message = self.error_messages['min_length'].format(
min_length=self.min_length)
self.validators.append(
MinLengthValidator(self.min_length, message=message))
self.validators.append(
RegexValidator(
_lazy_re_compile('^[\da-f]+$'),
message=_('Enter a valid id.'),
code='invalid',
))
class HostnameURLValidator(URLValidator):
"""
Custom URL Validator that support the presence of only the hostname (e.g.: "https://hostname/" is a valid value)
"""
tld_re = (
r'(\.' # dot
r'(?!-)' # can't start with a dash
r'(?:[a-z' + URLValidator.ul + '-]{2,63}' # domain label
r'|xn--[a-z0-9]{1,59})' # or punycode label
r'(?<!-)' # can't end with a dash
r'\.?)*' # may have a trailing dot
)
host_re = '(' + URLValidator.hostname_re + URLValidator.domain_re + tld_re + '|localhost)'
regex = _lazy_re_compile(
r'^(?:[a-z0-9\.\-\+]*)://' # scheme is validated separately
r'(?:\S+(?::\S*)?@)?' # user:pass authentication
r'(?:' + URLValidator.ipv4_re + '|' + URLValidator.ipv6_re + '|' + host_re + ')'
r'(?::\d{2,5})?' # port
r'(?:[/?#][^\s]*)?' # resource path
r'\Z', re.IGNORECASE)
class URLValidator(DjangoURLValidator):
"""
Set validation regex rules for URLs.
"""
ul = "\u00a1-\uffff" # unicode letters range (must not be a raw string)
# IP patterns
ipv4_re = (
r"(?:25[0-5]|2[0-4]\d|[0-1]?\d?\d)(?:\.(?:25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}"
)
ipv6_re = r"\[[0-9a-f:\.]+\]" # (simple regex, validated later)
# Host patterns
hostname_re = (r"[a-z" + ul + r"0-9](?:[a-z" + ul + r"0-9-]{0,61}[a-z" +
ul + r"0-9])?")
# Max length for domain name labels is 63 characters per RFC 1034 sec. 3.1
domain_re = r"(?:\.(?!-)[a-z" + ul + r"0-9-]{1,63}(?<!-))*"
tld_re = (
r"\." # dot
r"(?!-)" # can't start with a dash
r"(?:[a-z" + ul + "-]{2,63}" # domain label
r"|xn--[a-z0-9]{1,59})" # or punycode label
r"(?<!-)" # can't end with a dash
r"\.?" # may have a trailing dot
)
host_re = "(" + hostname_re + domain_re + tld_re + "|localhost|testserver)"
regex = _lazy_re_compile(
r"^(?:[a-z0-9\.\-\+]*)://" # scheme is validated separately
r"(?:\S+(?::\S*)?@)?" # user:pass authentication
r"(?:" + ipv4_re + "|" + ipv6_re + "|" + host_re + ")"
r"(?::\d{2,5})?" # port
r"(?:[/?#][^\s]*)?" # resource path
r"\Z",
re.IGNORECASE,
)
message = _("Enter a valid URL.")
schemes = ["http", "https", "ftp", "ftps"]
class UsernameField(forms.CharField):
validate_ckan = validators.RegexValidator(
validators._lazy_re_compile(r'^[-a-z0-9_]+\Z'), 'pas ok', 'invalid')
def __init__(self, *args, **kwargs):
kwargs.setdefault(
'error_messages', {
'invalid':
'Seuls les caractères alpha-numériques en minuscule et les caractères - et _ sont autorisés.'
})
kwargs.setdefault('label', "Nom d'utilisateur*")
kwargs.setdefault('max_length', 100)
kwargs.setdefault('min_length', 3)
kwargs.setdefault('required', True)
kwargs.setdefault('validators', [self.validate_ckan])
# TODO Le validateur ne voit pas les MAJ (à corriger..)
kwargs.setdefault(
'widget',
forms.TextInput(attrs={'placeholder': "Nom d'utilisateur"}))
super().__init__(*args, **kwargs)
def __init__(self,
regex=None,
message=None,
code=None,
inverse_match=None,
flags=None):
if regex is not None:
self.regex = regex
if message is not None:
self.message = message
if code is not None:
self.code = code
if inverse_match is not None:
self.inverse_match = inverse_match
if flags is not None:
self.flags = flags
if self.flags and not isinstance(self.regex, str):
raise TypeError(
"If the flags are set, regex must be a regular expression string."
)
self.regex = _lazy_re_compile(self.regex, self.flags)
class TmsUrlField(models.CharField):
ul = '\u00a1-\uffff' # unicode letters range (must not be a raw string)
# IP patterns
ipv4_re = r'(?:25[0-5]|2[0-4]\d|[0-1]?\d?\d)(?:\.(?:25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}'
ipv6_re = r'\[[0-9a-f:\.]+\]' # (simple regex, validated later)
# Host patterns
hostname_re = r'[a-z' + ul + r'0-9](?:[a-z' + ul + r'0-9-]{0,61}[a-z' + ul + r'0-9])?'
subdomain_switch_re = r'(\{switch:((?:\w+)(?:,\w+)*)\})'
hostname_with_switch_re = '(' + hostname_re + '|' + subdomain_switch_re + ')'
# Max length for domain name labels is 63 characters per RFC 1034 sec. 3.1
domain_re = r'(?:\.(?!-)[a-z' + ul + r'0-9-]{1,63}(?<!-))*'
tld_re = (
r'\.' # dot
r'(?!-)' # can't start with a dash
r'(?:[a-z' + ul + '-]{2,63}' # domain label
r'|xn--[a-z0-9]{1,59})' # or punycode label
r'(?<!-)' # can't end with a dash
r'\.?' # may have a trailing dot
)
host_re = '(' + hostname_with_switch_re + domain_re + tld_re + '|localhost)'
regex = validators._lazy_re_compile(
r'^(?:[a-z0-9\.\-\+]*)://' # scheme is validated separately
r'(?:\S+(?::\S*)?@)?' # user:pass authentication
r'(?:' + ipv4_re + '|' + ipv6_re + '|' + host_re + ')'
r'(?::\d{2,5})?' # port
r'(?:[/?#][^\s]*)?' # resource path
r'\Z',
re.IGNORECASE)
default_validators = [
validators.URLValidator(schemes=['http', 'https'],
regex=regex,
message=_('Enter a valid TMS URL.'))
]
class LDAPServerURIField(fields.URLField):
tld_re = (
r'\.' # dot
r'(?!-)' # can't start with a dash
r'(?:[a-z' + URLValidator.ul + r'0-9' +
'-]{2,63}' # domain label, this line was changed from the original URLValidator
r'|xn--[a-z0-9]{1,59})' # or punycode label
r'(?<!-)' # can't end with a dash
r'\.?' # may have a trailing dot
)
host_re = '(' + URLValidator.hostname_re + URLValidator.domain_re + tld_re + '|localhost)'
regex = _lazy_re_compile(
r'^(?:[a-z0-9\.\-\+]*)://' # scheme is validated separately
r'(?:[^\s:@/]+(?::[^\s:@/]*)?@)?' # user:pass authentication
r'(?:' + URLValidator.ipv4_re + '|' + URLValidator.ipv6_re + '|' +
host_re + ')'
r'(?::\d{2,5})?' # port
r'(?:[/?#][^\s]*)?' # resource path
r'\Z',
re.IGNORECASE)
def __init__(self, **kwargs):
kwargs.setdefault('schemes', ('ldap', 'ldaps'))
kwargs.setdefault('allow_plain_hostname', True)
kwargs.setdefault('regex', LDAPServerURIField.regex)
super(LDAPServerURIField, self).__init__(**kwargs)
def run_validators(self, value):
for url in filter(None, re.split(r'[, ]', (value or ''))):
super(LDAPServerURIField, self).run_validators(url)
return value
class IbanValidator(object):
IBAN_REGEX = _lazy_re_compile(r'^[A-Z0-9]{0,34}$')
LETTER_MAP = tuple(zip(string.ascii_uppercase, range(10, 36)))
message = _('IBAN is not valid')
def __init__(self, message=None):
if message is not None:
self.message = message
self.letter_map = dict(self.LETTER_MAP)
def __call__(self, value):
if not value or not self.IBAN_REGEX.match(value):
raise ValidationError(self.message)
iban = self._move_first_4_chars_to_the_end(value)
number = self._get_iban_number(iban)
if not self._is_mod_97_valid(number):
raise ValidationError(self.message)
def _get_iban_number(self, value):
return int(self._get_iban_number_as_str(value))
def _get_iban_number_as_str(self, value):
return ''.join([self._get_translated_number_as_str(s) for s in value])
def _get_translated_number_as_str(self, symbol):
return str(self.letter_map.get(symbol, symbol))
@staticmethod
def _move_first_4_chars_to_the_end(value):
return value[4:] + value[:4]
@staticmethod
def _is_mod_97_valid(number):
return number % 97 == 1
from django.core.validators import RegexValidator, _lazy_re_compile
from django.utils.translation import ugettext_lazy as _
key_validator = RegexValidator(
_lazy_re_compile("^[^\s/\.]+$"), message=_("Key must not contain spaces, dots or slashes."), code="invalid"
)
mac_address_validator = RegexValidator(
_lazy_re_compile("^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})"),
message=_("Must be a valid mac address."),
code="invalid",
)
def __init__(self, schemes=None, **kwargs):
self.schemes = schemes or ('http', 'https', 'ftp', 'sftp')
self.scheme_list = '|'.join(self.schemes)
self.regex = _lazy_re_compile(self.netloc_re)
from deployutils.crypt import decrypt, encrypt
from . import settings
from .utils import get_site_model
SUBDOMAIN_RE = r'^[-a-zA-Z0-9_]+\Z'
SUBDOMAIN_SLUG = RegexValidator(
SUBDOMAIN_RE,
_("Enter a valid subdomain consisting of letters, digits or hyphens."),
'invalid'
)
HOST_VALIDATOR = RegexValidator(
_lazy_re_compile(
r'(?:' + URLValidator.ipv4_re + '|' + URLValidator.ipv6_re + \
'|' + URLValidator.host_re + ')' # host
r'(?::\d{2,5})?' # port
r'(?:[/?#][^\s]*)?' # resource path
r'\Z', re.IGNORECASE),
_("Enter a valid host, optionally followed by a port and resource path."),
'invalid'
)
def domain_name_validator(value):
"""
Validates that the given value contains no whitespaces to prevent common
typos.
"""
if not value:
return
checks = ((s in value) for s in string.whitespace)
if any(checks):
from django.core.validators import RegexValidator, _lazy_re_compile
from django.utils.translation import ugettext_lazy as _
key_validator = RegexValidator(
_lazy_re_compile('^[^\s/\.]+$'),
message=_('Key must not contain spaces, dots or slashes.'),
code='invalid',
)
from django.forms import CharField
from django.forms.widgets import TextInput
from django.core.validators import RegexValidator, _lazy_re_compile
from django.forms.fields import EMPTY_VALUES
from django.forms.utils import ValidationError
from django.utils.translation import gettext_lazy as _
from netaddr import EUI, AddrFormatError
from . import MAC_ADDR_REGEX
mac_address_validator = RegexValidator(
_lazy_re_compile(MAC_ADDR_REGEX),
message=_('Enter a valid integer.'),
code='invalid',
)
class MACAddressField(CharField):
widget = TextInput
default_validators = [mac_address_validator]
default_error_messages = {
'invalid': _('Enter a valid MAC Address.'),
}
def clean(self, value):
"""
Validates that EUI() can be called on the input. Returns the result
of EUI(). Returns None for empty values.
"""
value = super(MACAddressField, self).clean(value)
if value in EMPTY_VALUES:
return None
from django.core.exceptions import ValidationError, PermissionDenied
from django.core.urlresolvers import reverse
from django.core.validators import RegexValidator, _lazy_re_compile
from django.utils.http import urlencode
from django.utils.translation import ugettext_lazy as _
from django.utils import timezone
from osf.models.admin_log_entry import (
update_admin_log,
EMBARGO_UPDATED
)
from website import settings
validate_slug = RegexValidator(
_lazy_re_compile(r'^[a-z]+\Z'),
_("Enter a valid 'slug' consisting only of lowercase letters."),
'invalid'
)
def reverse_qs(view, urlconf=None, args=None, kwargs=None, current_app=None, query_kwargs=None):
base_url = reverse(view, urlconf=urlconf, args=args, kwargs=kwargs, current_app=current_app)
if query_kwargs:
return '{}?{}'.format(base_url, urlencode(query_kwargs))
def osf_staff_check(user):
return user.is_authenticated and user.is_staff
def get_subject_rules(subjects_selected):
from django.core.validators import RegexValidator, _lazy_re_compile
from django.utils.translation import ugettext_lazy as _
key_validator = RegexValidator(
_lazy_re_compile("^[^\s/\.]+$"), message=_("Key must not contain spaces, dots or slashes."), code="invalid"
)
