class UserRegisterForm(wtf.Form):
username = wtf.TextField(
'Username',
validators=[
wtf.Required(),
wtf.Length(min=2, max=50),
wtf.Regexp(
'^[a-zA-Z0-9_]*$',
message=
('Username must only contain a to z, 0 to 9, and underscores.'
))
],
description=(
'Your username is public and used as part of your project name.'))
email = wtf.TextField('Email',
validators=[wtf.Required(),
wtf.validators.Email()])
password = wtf.PasswordField('Password',
validators=[
wtf.Required(),
wtf.Length(5),
wtf.EqualTo('confirm',
'Passwords do not match.'),
])
confirm = wtf.PasswordField('Confirm Password')
def validate_username(form, field):
from notifico.views.account import _reserved
username = field.data.strip().lower()
if username in _reserved or User.username_exists(username):
raise wtf.ValidationError('Sorry, but that username is taken.')
class RegisterForm(Form):
fullname = wtf.TextField('Full name', validators=[wtf.Required()])
email = wtf.html5.EmailField('Email address',
validators=[wtf.Required(),
wtf.Email()])
username = wtf.TextField('Username (optional)',
validators=[wtf.Optional()])
password = wtf.PasswordField('Password', validators=[wtf.Required()])
confirm_password = wtf.PasswordField(
'Confirm password',
validators=[wtf.Required(), wtf.EqualTo('password')])
recaptcha = wtf.RecaptchaField(
'Are you human?', description="Type both words into the text box")
def validate_username(self, field):
if field.data in RESERVED_USERNAMES:
raise wtf.ValidationError, "That name is reserved"
if not valid_username(field.data):
raise wtf.ValidationError(
u"Invalid characters in name. Names must be made of ‘a-z’, ‘0-9’ and ‘-’, without trailing dashes"
)
existing = User.query.filter_by(username=field.data).first()
if existing is not None:
raise wtf.ValidationError("That username is taken")
def validate_email(self, field):
existing = UserEmail.query.filter_by(email=field.data).first()
if existing is not None:
raise wtf.ValidationError(
Markup(
'This email address is already registered. Do you want to <a href="%s">login</a> instead?'
% url_for('login')))
class SignUpForm(Form):
"""Sign up form."""
name = wtf.TextField('Name',
validators=[
wtf.Required(),
wtf.Length(max=100),
],
description='e.g. Johnny')
primary_email = wtf.TextField('E-mail',
validators=[
wtf.Required(),
wtf.Email(),
wtf.Length(max=100),
])
password = wtf.PasswordField('Password', validators=[
wtf.Required(),
])
password_check = wtf.PasswordField('Password once more',
validators=[
wtf.EqualTo(
'password',
message='Passwords must match'),
],
description='protection against typos')
class UserPasswordForm(wtf.Form):
password = wtf.PasswordField('Password',
validators=[
wtf.Required(),
wtf.Length(5),
wtf.EqualTo('confirm',
'Passwords do not match.'),
])
confirm = wtf.PasswordField('Confirm Password')
class ChangePasswordForm(wtf.Form):
password = wtf.PasswordField('Password',
validators=[
wtf.Required(),
wtf.EqualTo(
'confirm',
message='Passwords must match.')
])
confirm = wtf.PasswordField('Repeat Password', validators=[wtf.Required()])
submit = wtf.SubmitField('Save')
class PasswordChangeForm(Form):
old_password = wtf.PasswordField('Current password',
validators=[wtf.Required()])
password = wtf.PasswordField('New password', validators=[wtf.Required()])
confirm_password = wtf.PasswordField(
'Confirm password',
validators=[wtf.Required(), wtf.EqualTo('password')])
def validate_old_password(self, field):
if g.user is None:
raise wtf.ValidationError, "Not logged in"
if not g.user.password_is(field.data):
raise wtf.ValidationError, "Incorrect password"
class UserDeleteForm(wtf.Form):
password = wtf.PasswordField('Password',
validators=[
wtf.Required(),
wtf.Length(5),
wtf.EqualTo('confirm',
'Passwords do not match.'),
])
confirm = wtf.PasswordField('Confirm Password')
def validate_password(form, field):
if not User.login(g.user.username, field.data):
raise wtf.ValidationError('Password is incorrect.')
class SignupForm(wtf.Form):
email = wtf.TextField('email',
validators=[
wtf.Required(message=u'请填写电子邮件'),
wtf.Email(message=u'无效的电子邮件')
])
nickname = wtf.TextField('nickname',
validators=[
wtf.Required(message=u'请填写昵称'),
wtf.Length(min=2,
max=20,
message=u'昵称应为2到20字符')
])
password = wtf.PasswordField('password',
validators=[
wtf.Required(message=u'请填写密码'),
wtf.Length(min=5,
max=20,
message=u'密码应为5到20位字符')
])
repassword = wtf.PasswordField('repassword',
validators=[
wtf.Required(message=u'请填写确认密码'),
wtf.EqualTo('password',
message=u'两次输入的密码不一致')
])
next = wtf.HiddenField('next')
def __init__(self, *args, **kargs):
wtf.Form.__init__(self, *args, **kargs)
self.user = None
def validate(self):
wtf.Form.validate(self)
# 验证邮箱是否注册
if not self.email.errors:
user = get_user(email=self.email.data)
user and self.email.errors.append(u'该邮箱已被注册')
self.user = User(email=self.email.data,
nickname=self.nickname.data,
openids=[
UserOpenID(provider=session['openid_provider'],
openid=session['current_openid'])
])
self.user.set_password(self.password.data)
self.user.info = UserInfo()
return len(self.errors) == 0
class EditPassForm(RedirectForm):
old_password = wtf.PasswordField(
u'当前密码', validators=[wtf.Required(message=u'请提供当前密码')])
password = wtf.PasswordField(u'新密码', validators=[ \
wtf.Required(message=u'请填写新密码，不能少与5位字符'), \
wtf.EqualTo('confirm', message=u'两次输入的密码不一致'), \
wtf.Length(min=5, max=20, message=u'密码应为5到20位字符')
])
confirm = wtf.PasswordField(u'确认密码',
validators=[wtf.Required(message=u'请再次输入新密码')])
def validate_old_password(form, field):
if not current_user.user.check_password(field.data):
raise wtf.ValidationError(u'提供的原始密码不正确')
class UserLoginForm(wtf.Form):
username = wtf.TextField('Username', validators=[wtf.Required()])
password = wtf.PasswordField('Password', validators=[wtf.Required()])
def validate_password(form, field):
if not User.login(form.username.data, field.data):
raise wtf.ValidationError('Incorrect username and/or password.')
class SigninForm(wtf.Form):
email = wtf.TextField('email',
validators=[
wtf.Required(message=u'请填写电子邮件'),
wtf.Email(message=u'无效的电子邮件')
])
password = wtf.PasswordField('password',
validators=[
wtf.Required(message=u'请填写密码'),
wtf.Length(min=5,
max=20,
message=u'密应应为5到20位字符')
])
next = wtf.HiddenField('next')
remember = wtf.BooleanField('remember')
openid_identifier = wtf.HiddenField('openid_identifier')
openid_provider = wtf.HiddenField('openid_provider')
def __init__(self, *args, **kargs):
wtf.Form.__init__(self, *args, **kargs)
self.user = None
def validate(self):
# 验证邮箱是否注册
if wtf.Form.validate(self):
user = get_user(email=self.email.data)
if not user:
self.email.errors.append(u'该邮箱尚未在本站注册')
elif not user.check_password(self.password.data):
self.password.errors.append(u'密码错误')
else:
self.user = user
return len(self.errors) == 0
class LoginForm(wtf.Form):
login = wtf.TextField(
label=u"Ім`я",
validators=[wtf.required()]
)
password = wtf.PasswordField(
label=u"Пароль",
validators=[wtf.required()]
)
def validate_login(self, field):
user = self.get_user()
if user is None:
raise wtf.ValidationError(u'Користувача з логіном %s не існує' % self.login.data)
if not user.is_authenticated(aUser=''.join(self.login.raw_data), aPassword=''.join(self.password.raw_data)):
raise wtf.ValidationError(u'Неспівпадіння паролей')
def get_user(self):
user = None
try:
user = User.get(login=self.login.raw_data)
except User.DoesNotExist, e:
print 'User with %s username does not exists' % self.login.raw_data
return user
class LoginForm(wtf.Form):
username = wtf.TextField(
'Username', [wtf.validators.Required(),
wtf.validators.Length(max=64)])
password = wtf.PasswordField(
'Password',
[wtf.validators.Required(),
wtf.validators.Length(max=256)])
def validate(self):
user = self.get_user()
if user is None:
self.username.errors = tuple(['Unknow username'])
return False
if user.password != self.password.data:
self.password.errors = tuple(['Invalid password'])
return False
return True
def get_user(self):
return db.session.query(User).filter_by(
username=self.username.data).first()
class RegistrationForm(wtf.Form):
login = wtf.TextField(validators=[wtf.required()])
email = wtf.TextField()
password = wtf.PasswordField(validators=[wtf.required()])
def validate_login(self, field):
if User.objects(login=self.login.data):
raise wtf.ValidationError('Duplicate username')
class RegistrationForm(wtf.Form):
login = wtf.TextField(u'用户名', validators=[wtf.required()])
email = wtf.TextField(u'邮箱')
password = wtf.PasswordField(u'密码', validators=[wtf.required()])
def validate_login(self, field):
if db.session.query(User).filter_by(login=self.login.data).count() > 0:
raise wtf.ValidationError('Duplicate username')
class PasswordForm(Form):
"""Password changing form."""
old_password = wtf.PasswordField('Old password',
validators=[
wtf.Required(),
])
new_password = wtf.PasswordField('New password',
validators=[
wtf.Required(),
])
password_check = wtf.PasswordField('New password once more',
validators=[
wtf.EqualTo(
'new_password',
message='Passwords must match'),
],
description='protection against typos')
class ProfileForm(wtf.Form):
password = wtf.PasswordField('Password',
validators=[
wtf.Required(),
wtf.EqualTo(
'confirm',
message='Passwords must match.')
])
confirm = wtf.PasswordField('Repeat Password', validators=[wtf.Required()])
name = wtf.TextField('Screen name',
validators=[wtf.Required(),
wtf.Length(1, 45)])
email = wtf.html5.EmailField('Email',
validators=[wtf.Optional(),
wtf.Email()])
url = wtf.html5.URLField('Website', validators=[wtf.Optional(), wtf.URL()])
submit = wtf.SubmitField('Save')
class RegistrationForm(wtf.Form):
login = wtf.TextField(validators=[wtf.required()])
email = wtf.TextField(validators=[wtf.required(), wtf.validators.Email()])
password = wtf.PasswordField(validators=[wtf.required()])
def validate_login(self, field):
current_ident_hash = bcrypt.generate_password_hash("".join(self.login.raw_data))
if User.filter(ident_hash=current_ident_hash).count():
raise wtf.ValidationError(u'Користувач з ніком %s вже зареєстрований. Оберіть інше ім`я')
class SignUpForm(wtf.Form):
login = wtf.TextField('Login name',
validators=[
wtf.Required(),
wtf.Length(2, 45),
wtf.Regexp(User.LOGIN_PATTERN)
])
password = wtf.PasswordField('Password',
validators=[
wtf.Required(),
wtf.EqualTo(
'confirm',
message='Passwords must match.')
])
confirm = wtf.PasswordField('Repeat Password', validators=[wtf.Required()])
name = wtf.TextField('Screen name',
validators=[wtf.Required(),
wtf.Length(1, 45)])
email = wtf.html5.EmailField('Email',
validators=[wtf.Optional(),
wtf.Email()])
url = wtf.html5.URLField('Website', validators=[wtf.Optional(), wtf.URL()])
@classmethod
def get_instance(cls, *args, **kwargs):
if ('RECAPTCHA_PUBLIC_KEY' in current_app.config
and 'RECAPTCHA_PRIVATE_KEY' in current_app.config):
class SignUpForm_recaptcha(cls):
recaptcha = wtf.RecaptchaField()
submit = wtf.SubmitField('Sign up')
return SignUpForm_recaptcha(*args, **kwargs)
class SignUpForm_plain(cls):
submit = wtf.SubmitField('Sign up')
return SignUpForm_plain(*args, **kwargs)
def validate_login(form, field):
if g.session.query(User).filter_by(login=field.data).count():
raise wtf.ValidationError('{0} is already taken.'.format(
field.data))
class SignInForm(Form):
"""Sign in form."""
email = wtf.TextField('E-mail',
validators=[
wtf.Required(),
wtf.Length(max=100),
])
password = wtf.PasswordField('Password', validators=[
wtf.Required(),
])
class LDAPLoginForm(wtf.Form):
"""
This is a form to be subclassed by your application.
Once validiated will have a `form.user` object that contains
a user object.
"""
username = wtf.TextField('Username', validators=[wtf.Required()])
password = wtf.PasswordField('Password', validators=[wtf.Required()])
remember_me = wtf.BooleanField('Remember Me', default=True)
def validate_ldap(self):
'Validate the username/password data against ldap directory'
ldap_mgr = current_app.ldap_login_manager
username = self.username.data
password = self.password.data
try:
userdata = ldap_mgr.ldap_login(username, password)
except ldap.INVALID_CREDENTIALS:
flash("Invalid LDAP credentials", 'danger')
return False
except ldap.LDAPError as err:
if isinstance(err.message, dict):
message = err.message.get('desc', str(err))
else:
message = str(err.message)
flash(message, 'danger')
return False
if userdata is None:
flash("Invalid LDAP credentials", 'danger')
return False
self.user = ldap_mgr._save_user(username, userdata)
return True
def validate(self, *args, **kwargs):
"""
Validates the form by calling `validate` on each field, passing any
extra `Form.validate_<fieldname>` validators to the field validator.
also calls `validate_ldap`
"""
valid = wtf.Form.validate(self, *args, **kwargs)
if not valid: return valid
return self.validate_ldap()
class LoginForm(Form):
username = wtf.TextField('Username or Email', validators=[wtf.Required()])
password = wtf.PasswordField('Password', validators=[wtf.Required()])
remember = wtf.BooleanField('Remember me')
def validate_username(self, field):
existing = getuser(field.data)
if existing is None:
raise wtf.ValidationError("User does not exist")
def validate_password(self, field):
user = getuser(self.username.data)
if user is None or not user.password_is(field.data):
raise wtf.ValidationError("Incorrect password")
self.user = user
class LoginForm(wtf.Form):
login = wtf.TextField(u'用户名', validators=[wtf.required()])
password = wtf.PasswordField(u'密码', validators=[wtf.required()])
def validate_login(self, field):
user = self.get_user()
if user is None:
raise wtf.ValidationError('Invalid user')
if user.password != self.password.data:
raise wtf.ValidationError('Invalid password')
def get_user(self):
return db.session.query(User).filter_by(login=self.login.data).first()
class LoginForm(wtf.Form):
login = wtf.TextField(validators=[wtf.required()])
password = wtf.PasswordField(validators=[wtf.required()])
def validate_login(self, field):
user = self.get_user()
if user is None:
raise wtf.ValidationError('Invalid user')
if user.password != self.password.data:
raise wtf.ValidationError('Invalid password')
def get_user(self):
return User.objects(login=self.login.data).first()
class RegistrationForm(wtf.Form):
username = wtf.TextField(
'Username', [wtf.validators.Required(),
wtf.validators.Length(max=64)])
password = wtf.PasswordField(
'Password',
[wtf.validators.Required(),
wtf.validators.Length(max=256)])
def validate(self):
if db.session.query(User).filter_by(
username=self.username.data).count() > 0:
self.username.errors = tuple(['Username already registered'])
return False
return True
class LoginForm(wtf.Form):
email = wtf.TextField('User ID', validators=[wtf.required()])
password = wtf.PasswordField(validators=[wtf.required()])
def validate_email(self, field):
user = self.get_user()
if user is None:
raise wtf.ValidationError('Invalid user')
if user.password != self.password.data:
raise wtf.ValidationError('Invalid password')
def get_user(self):
try:
return User.objects(email=self.email.data).get()
except User.DoesNotExist:
pass
class NewPaste(wtf.Form):
text = wtf.TextField('uid') # honeypot field
paste = wtf.TextAreaField('text', validators=[wtf.Required()])
title = wtf.TextField('title', validators=[wtf.Optional()])
password = wtf.PasswordField('password', validators=[wtf.Optional()])
unlisted = wtf.BooleanField('Unlisted')
submit = wtf.SubmitField('Paste')
language = wtf.SelectField(
'language',
choices=[
('', ''),
('text', 'Text'),
('c', 'C'),
('csharp', 'C#'),
('cpp', 'C++'),
('css', 'CSS'),
('erlang', 'Erlang'),
('go', 'GO'),
('html', 'HTML'),
('java', 'Java'),
('javascript', 'Javascript'),
('json', 'JSON'),
('objectivec', 'Objective-C'),
('perl', 'Perl'),
('python', 'Python (2.X)'),
('python3', 'Python (3.X)'),
('pycon', 'Python Console'),
('pytb', 'Python 2 Traceback'),
('py3tb', 'Python 3 Traceback'),
('ruby', 'Ruby'),
('sql', 'SQL'),
('vbnet', 'VB.NET'),
]
)
def validate_uid(form, field):
"""
This ensures the hidden honeypot field is left blank,
only automated spambots should attempt to fill it in
"""
if field.data != '':
raise wtf.validators.ValidationError()
class LoginForm(wtf.Form):
login = wtf.TextField(validators=[wtf.required()])
password = wtf.PasswordField(validators=[wtf.required()])
def validate_login(self, field):
user = self.get_user()
if ldap_auth.auth(self.login.data, self.password.data) != 1:
flash(u'Login failed', category='error')
raise wtf.ValidationError('Invalid user/password')
if user is None:
# add user to db
user = User()
user.username = self.login.data
user.active = True
user.admin = True if user.username == "bmays" or user.username == "cjohnson" else False
main.db.session.add(user)
main.db.session.commit()
def get_user(self):
return main.db.session.query(User).filter_by(
username=self.login.data).first()
class SignInForm(wtf.Form):
login = wtf.TextField('Login name',
validators=[
wtf.Required(),
wtf.Length(2, 45),
wtf.Regexp(User.LOGIN_PATTERN)
])
password = wtf.PasswordField('Password', validators=[wtf.Required()])
return_url = wtf.HiddenField(validators=[wtf.Optional()])
submit = wtf.SubmitField('Login')
def validate_login(form, field):
if g.session.query(User).filter_by(login=field.data).count() < 1:
raise wtf.ValidationError('There is no {0}.'.format(field.data))
def validate_password(form, field):
try:
user = g.session.query(User).filter_by(login=form.login.data)[0]
except IndexError:
pass
else:
if user.password != field.data:
raise wtf.ValidationError('Incorrect password.')
class PasswordConfirmForm(wtf.Form):
password = wtf.PasswordField('Password', validators=[wtf.Required()])
def validate_password(form, field):
if not User.login(g.user.username, field.data):
raise wtf.ValidationError('Your password is incorrect.')
