267 lines
10 KiB
Python
267 lines
10 KiB
Python
# Copyright The IETF Trust 2011-2019, All Rights Reserved
|
|
# -*- coding: utf-8 -*-
|
|
|
|
|
|
from __future__ import absolute_import, print_function, unicode_literals
|
|
|
|
import re
|
|
from unidecode import unidecode
|
|
|
|
from django import forms
|
|
from django.conf import settings
|
|
from django.core.exceptions import ValidationError
|
|
from django.db import models
|
|
from django.contrib.auth.models import User
|
|
from django.utils.html import mark_safe
|
|
from django.urls import reverse as urlreverse
|
|
|
|
from django_password_strength.widgets import PasswordStrengthInput, PasswordConfirmationInput
|
|
|
|
import debug # pyflakes:ignore
|
|
|
|
from ietf.person.models import Person, Email
|
|
from ietf.mailinglists.models import Whitelisted
|
|
from ietf.utils.text import isascii
|
|
|
|
class RegistrationForm(forms.Form):
|
|
email = forms.EmailField(label="Your email (lowercase)")
|
|
|
|
def clean_email(self):
|
|
email = self.cleaned_data.get('email', '')
|
|
if not email:
|
|
return email
|
|
if email.lower() != email:
|
|
raise forms.ValidationError('The supplied address contained uppercase letters. Please use a lowercase email address.')
|
|
if User.objects.filter(username=email).exists():
|
|
raise forms.ValidationError('An account with the email address you provided already exists.')
|
|
return email
|
|
|
|
|
|
class PasswordForm(forms.Form):
|
|
password = forms.CharField(widget=PasswordStrengthInput(attrs={'class':'password_strength'}))
|
|
password_confirmation = forms.CharField(widget=PasswordConfirmationInput(
|
|
confirm_with='password',
|
|
attrs={'class':'password_confirmation'}),
|
|
help_text="Enter the same password as above, for verification.",)
|
|
|
|
|
|
def clean_password_confirmation(self):
|
|
password = self.cleaned_data.get("password", "")
|
|
password_confirmation = self.cleaned_data["password_confirmation"]
|
|
if password != password_confirmation:
|
|
raise forms.ValidationError("The two password fields didn't match.")
|
|
return password_confirmation
|
|
|
|
def ascii_cleaner(supposedly_ascii):
|
|
outside_printable_ascii_pattern = r'[^\x20-\x7F]'
|
|
if re.search(outside_printable_ascii_pattern, supposedly_ascii):
|
|
raise forms.ValidationError("Only unaccented Latin characters are allowed.")
|
|
return supposedly_ascii
|
|
|
|
def prevent_at_symbol(name):
|
|
if "@" in name:
|
|
raise forms.ValidationError("Please fill in name - this looks like an email address (@ is not allowed in names).")
|
|
|
|
def prevent_system_name(name):
|
|
name_without_spaces = name.replace(" ", "").replace("\t", "")
|
|
if "(system)" in name_without_spaces.lower():
|
|
raise forms.ValidationError("Please pick another name - this name is reserved.")
|
|
|
|
class PersonPasswordForm(forms.ModelForm, PasswordForm):
|
|
|
|
class Meta:
|
|
model = Person
|
|
fields = ['name', 'ascii']
|
|
|
|
def clean_name(self):
|
|
name = self.cleaned_data.get('name', '')
|
|
prevent_at_symbol(name)
|
|
prevent_system_name(name)
|
|
|
|
return name
|
|
|
|
def clean_ascii(self):
|
|
ascii = self.cleaned_data.get('ascii', '')
|
|
if not isascii(ascii):
|
|
raise forms.ValidationError("Ascii name contains non-ASCII characters.")
|
|
|
|
return ascii
|
|
|
|
def get_person_form(*args, **kwargs):
|
|
|
|
exclude_list = ['time', 'user', 'photo_thumb', 'photo', ]
|
|
|
|
person = kwargs['instance']
|
|
roles = person.role_set.all()
|
|
if not roles:
|
|
exclude_list += ['biography', 'photo', ]
|
|
|
|
class PersonForm(forms.ModelForm):
|
|
class Meta:
|
|
model = Person
|
|
exclude = exclude_list
|
|
widgets = {
|
|
'consent': forms.widgets.CheckboxInput,
|
|
}
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super(PersonForm, self).__init__(*args, **kwargs)
|
|
|
|
# blank ascii if it's the same as name
|
|
self.fields["ascii"].required = self.fields["ascii"].widget.is_required = False
|
|
self.fields["ascii"].help_text += " " + "Leave blank to use auto-reconstructed Latin version of name."
|
|
|
|
if self.initial.get("ascii") == self.initial.get("name"):
|
|
self.initial["ascii"] = ""
|
|
|
|
for f in ['name', 'ascii', 'ascii_short', 'biography', 'photo', 'photo_thumb', ]:
|
|
if f in self.fields:
|
|
self.fields[f].label += ' \u2020'
|
|
|
|
self.unidecoded_ascii = False
|
|
|
|
if self.data and not self.data.get("ascii", "").strip():
|
|
self.data = self.data.copy()
|
|
name = self.data["name"]
|
|
reconstructed_name = unidecode(name)
|
|
self.data["ascii"] = reconstructed_name
|
|
self.unidecoded_ascii = name != reconstructed_name
|
|
|
|
def clean_name(self):
|
|
name = self.cleaned_data.get("name") or ""
|
|
prevent_at_symbol(name)
|
|
prevent_system_name(name)
|
|
return name
|
|
|
|
def clean_ascii(self):
|
|
if self.unidecoded_ascii:
|
|
raise forms.ValidationError("Name contained non-ASCII characters, and was automatically reconstructed using only Latin characters. Check the result - if you are happy, just hit Submit again.")
|
|
|
|
name = self.cleaned_data.get("ascii") or ""
|
|
prevent_at_symbol(name)
|
|
prevent_system_name(name)
|
|
return ascii_cleaner(name)
|
|
|
|
def clean_ascii_short(self):
|
|
name = self.cleaned_data.get("ascii_short") or ""
|
|
prevent_at_symbol(name)
|
|
prevent_system_name(name)
|
|
return ascii_cleaner(name)
|
|
|
|
def clean_consent(self):
|
|
consent = self.cleaned_data.get('consent')
|
|
require_consent = (
|
|
self.cleaned_data.get('name') != person.name_from_draft
|
|
or self.cleaned_data.get('ascii') != person.name_from_draft
|
|
or self.cleaned_data.get('biography')
|
|
)
|
|
if consent == False and require_consent:
|
|
raise forms.ValidationError("In order to modify your profile with data that require consent, you must permit the IETF to use the uploaded data.")
|
|
return consent
|
|
|
|
return PersonForm(*args, **kwargs)
|
|
|
|
|
|
class NewEmailForm(forms.Form):
|
|
new_email = forms.EmailField(label="New email address", required=False)
|
|
|
|
def clean_new_email(self):
|
|
email = self.cleaned_data.get("new_email", "")
|
|
if email:
|
|
existing = Email.objects.filter(address=email).first()
|
|
if existing:
|
|
raise forms.ValidationError("Email address '%s' is already assigned to account '%s' (%s)" % (existing, existing.person and existing.person.user, existing.person))
|
|
|
|
for pat in settings.EXCLUDED_PERSONAL_EMAIL_REGEX_PATTERNS:
|
|
if re.search(pat, email):
|
|
raise ValidationError("This email address is not valid in a datatracker account")
|
|
|
|
return email
|
|
|
|
|
|
class RoleEmailForm(forms.Form):
|
|
email = forms.ModelChoiceField(label="Role email", queryset=Email.objects.all())
|
|
|
|
def __init__(self, role, *args, **kwargs):
|
|
super(RoleEmailForm, self).__init__(*args, **kwargs)
|
|
|
|
f = self.fields["email"]
|
|
f.label = "%s in %s" % (role.name, role.group.acronym.upper())
|
|
f.help_text = "Email to use for <i>%s</i> role in %s" % (role.name, role.group.name)
|
|
f.queryset = f.queryset.filter(models.Q(person=role.person_id) | models.Q(role=role)).distinct()
|
|
f.initial = role.email_id
|
|
f.choices = [(e.pk, e.address if e.active else "({})".format(e.address)) for e in f.queryset]
|
|
|
|
|
|
class ResetPasswordForm(forms.Form):
|
|
username = forms.EmailField(label="Your email (lowercase)")
|
|
|
|
def clean_username(self):
|
|
import ietf.ietfauth.views
|
|
username = self.cleaned_data["username"]
|
|
if not User.objects.filter(username=username).exists():
|
|
raise forms.ValidationError(mark_safe("Didn't find a matching account. If you don't have an account yet, you can <a href=\"{}\">create one</a>.".format(urlreverse(ietf.ietfauth.views.create_account))))
|
|
return username
|
|
|
|
|
|
class TestEmailForm(forms.Form):
|
|
email = forms.EmailField(required=False)
|
|
|
|
class WhitelistForm(forms.ModelForm):
|
|
class Meta:
|
|
model = Whitelisted
|
|
exclude = ['by', 'time' ]
|
|
|
|
|
|
from django import forms
|
|
|
|
|
|
class ChangePasswordForm(forms.Form):
|
|
current_password = forms.CharField(widget=forms.PasswordInput)
|
|
|
|
new_password = forms.CharField(widget=PasswordStrengthInput(attrs={'class':'password_strength'}))
|
|
new_password_confirmation = forms.CharField(widget=PasswordConfirmationInput(
|
|
confirm_with='new_password',
|
|
attrs={'class':'password_confirmation'}))
|
|
|
|
def __init__(self, user, data=None):
|
|
self.user = user
|
|
super(ChangePasswordForm, self).__init__(data)
|
|
|
|
def clean_current_password(self):
|
|
password = self.cleaned_data.get('current_password', None)
|
|
if not self.user.check_password(password):
|
|
raise ValidationError('Invalid password')
|
|
return password
|
|
|
|
def clean(self):
|
|
new_password = self.cleaned_data.get('new_password', None)
|
|
conf_password = self.cleaned_data.get('new_password_confirmation', None)
|
|
if not new_password == conf_password:
|
|
raise ValidationError("The password confirmation is different than the new password")
|
|
|
|
|
|
class ChangeUsernameForm(forms.Form):
|
|
username = forms.ChoiceField(choices=['-','--------'])
|
|
password = forms.CharField(widget=forms.PasswordInput, help_text="Confirm the change with your password")
|
|
|
|
def __init__(self, user, *args, **kwargs):
|
|
assert isinstance(user, User)
|
|
super(ChangeUsernameForm, self).__init__(*args, **kwargs)
|
|
self.user = user
|
|
emails = user.person.email_set.filter(active=True)
|
|
choices = [ (email.address, email.address) for email in emails ]
|
|
self.fields['username'] = forms.ChoiceField(choices=choices)
|
|
|
|
def clean_password(self):
|
|
password = self.cleaned_data['password']
|
|
if not self.user.check_password(password):
|
|
raise ValidationError('Invalid password')
|
|
return password
|
|
|
|
def clean_username(self):
|
|
username = self.cleaned_data['username']
|
|
if User.objects.filter(username=username).exists():
|
|
raise ValidationError("A login with that username already exists. Please contact the secretariat to get this resolved.")
|
|
return username
|