class LoginForm(Form):
username = StringField('username', [validators.Required()])
password = PasswordField('password', [validators.Required()])
remember_me = BooleanField('remember_me', default=False)
class CommentForm(Form):
comment_body = TextAreaField(" ", [validators.Required()])
class AnswerForm(Form):
answer_body = TextAreaField("Your Answer", [validators.Required()])
class SetupForm(RegisterForm):
name = StringField('Blog name', [
validators.Required(),
validators.Length(max=80)
])
class DirForm(Form):
pointA = TextField('From: ', [validators.Required("(Required)")])
pointB = TextField('To: ', [validators.Required("(Required)")])
def convert(self, model, mapper, prop, field_args, db_session=None):
if not hasattr(prop, 'columns') and not hasattr(prop, 'direction'):
return
elif not hasattr(prop, 'direction') and len(prop.columns) != 1:
raise TypeError(
'Do not know how to convert multiple-column properties currently'
)
kwargs = {
'validators': [],
'filters': [],
'default': None,
}
converter = None
column = None
types = None
if not hasattr(prop, 'direction'):
column = prop.columns[0]
# Support sqlalchemy.schema.ColumnDefault, so users can benefit
# from setting defaults for fields, e.g.:
# field = Column(DateTimeField, default=datetime.utcnow)
default = getattr(column, 'default', None)
if default is not None:
# Only actually change default if it has an attribute named
# 'arg' that's callable.
callable_default = getattr(default, 'arg', None)
if callable_default is not None:
# ColumnDefault(val).arg can be also a plain value
default = callable_default(None) if callable(callable_default) else callable_default
kwargs['default'] = default
if column.nullable:
kwargs['validators'].append(validators.Optional())
else:
kwargs['validators'].append(validators.Required())
if db_session and column.unique:
kwargs['validators'].append(Unique(
lambda: db_session, model, column
))
if self.use_mro:
types = inspect.getmro(type(column.type))
else:
types = [type(column.type)]
for col_type in types:
type_string = '%s.%s' % (col_type.__module__, col_type.__name__)
if type_string.startswith('sqlalchemy'):
type_string = type_string[11:]
if type_string in self.converters:
converter = self.converters[type_string]
break
else:
for col_type in types:
if col_type.__name__ in self.converters:
converter = self.converters[col_type.__name__]
break
else:
raise ModelConversionError('Could not find field converter for %s (%r).' % (prop.key, types[0]))
else:
# We have a property with a direction.
if not db_session:
raise ModelConversionError("Cannot convert field %s, need DB session." % prop.key)
foreign_model = prop.mapper.class_
nullable = True
for pair in prop.local_remote_pairs:
if not pair[0].nullable:
nullable = False
kwargs.update({
'allow_blank': nullable,
'query_factory': lambda: db_session.query(foreign_model).all()
})
converter = self.converters[prop.direction.name]
if field_args:
kwargs.update(field_args)
return converter(
model=model,
mapper=mapper,
prop=prop,
column=column,
field_args=kwargs
)
class RegistrationForm(Form):
username = TextField('Username', [validators.Length(min=4, max=20)])
email = TextField('Email Address', [validators.Length(min=6, max=50)])
password = PasswordField('Password', [validators.Required(), validators.EqualTo('confirm', message="Passwords must match")])
confirm = PasswordField('Repeat Password')
accept_tos = BooleanField('I accept the <a href="/tos/">Terms of Service</a> and the <a href="/privacy/">Privacy Notice</a> (Last updated Feb 2020)', [validators.Required()])
class EmailForm(Form):
email = TextField('Email', [validators.Length(min=5, max=48),validators.Required(),
validators.Email(message='Email is invalid')])
class SearchForm(Form):
query = TextAreaField('', [validators.Length(min=20, max=1000), validators.Required()])
class ProfileForm(Form):
fname = TextField('First Name', [validators.Length(min=2, max=32), validators.Required()])
lname = TextField('Last Name', [validators.Length(min=2, max=32), validators.Required()])
email1 = TextField('Email', [validators.Length(min=5, max=48),validators.Required(),
validators.Email(message='Either email is invalid or already registered.')])
recaptcha = RecaptchaField(validators.Required())
class TagForm(Form):
info = TextAreaField('', [validators.Length(min=20, max=5000), validators.Required()])
class CommentForm(Form):
comment = TextAreaField('', [validators.Length(min=20, max=5000), validators.Required()])
class AnswerForm(Form):
answer = TextAreaField('', [validators.Length(min=20, max=5000), validators.Required()])
class QuestionForm(Form):
question = TextField('Question', [validators.Length(min=4, max=200), validators.Required()])
description = TextAreaField('', [validators.Length(min=20, max=10000), validators.Required()])
tags = TextField('Tags', [validators.Length(min=1, max=100), validators.Required()])
class LimitKeywordForm(Form):
limitcategory = StringField('限制分类(请在分类名前加Category:',[validators.Required(),validators.Length(min=8,max=100)])
catsubmit = SubmitField('提交')
limittopic = StringField('限制标题(请使用python正则表达式书写)',[validators.Length(min=3,max=100),validators.Required()])
topicsubmit = SubmitField('提交')
class EditProfileForm(Form):
fname = TextField('First Name', [validators.Length(min=2, max=32), validators.Required()])
lname = TextField('Last Name', [validators.Length(min=2, max=32), validators.Required()])
website = TextField('Website', [validators.Length(min=2, max=160), validators.optional()])
location = TextField('Location', [validators.Length(min=2, max=60), validators.optional()])
about_me = TextAreaField('', [validators.Length(min=20, max=5000), validators.optional()])
class PushForm(Form):
pushtitle=StringField('条目名',[validators.Required(),validators.Length(min=1,max=60)])
submit=SubmitField('推送')
class TokenForm(FlaskForm):
password = StringField("Token", [validators.Required()])
class LoginForm(Form):
username = TextField("username", [validators.Required()])
password = PasswordField("password", [validators.Required()])
class MascotForm(FlaskForm):
name = StringField('Name des Maskottchens', [validators.Required()])
submit = SubmitField()
class CommentForm(Form):
#post_id = HiddenField()
body = TextAreaField('Content', validators=[validators.Required()])
class PasswordForm(Form):
password = PasswordField(lazy_gettext('Password'), [
validators.Required(message=lazy_gettext("You must enter a password"))
])
class SearchForm(Form):
search = TextField('', [validators.Required("(Required)")])
class LoadtestForm(Form):
repo = TextField('git repo', [validators.Required()])
class LoginForm(Form):
user_name = TextField('Username: '******'Password: '******'Remember me: ')
class DeployForm(Form):
ref = TextField('git ref', [validators.Required()])
password = PasswordField('secret', [validators.Required()])
who = TextField('identify yourself', [validators.Required()])
class QuestionForm(Form):
title = TextField("What's your question?", [validators.Required()])
body = TextAreaField("Body", [validators.Required()])
tags = TextField("Tags")
class BanKeywordForm(Form):
keyword=StringField('屏蔽关键词(请使用python正则表达式书写)',[validators.Length(min=3,max=100),validators.Required()])
submit=SubmitField('提交')
class FieldListTest(TestCase):
t = TextField(validators=[validators.Required()])
def test_form(self):
F = make_form(a=FieldList(self.t))
data = ['foo', 'hi', 'rawr']
a = F(a=data).a
self.assertEqual(a.entries[1].data, 'hi')
self.assertEqual(a.entries[1].name, 'a-1')
self.assertEqual(a.data, data)
self.assertEqual(len(a.entries), 3)
pdata = DummyPostData({
'a-0': ['bleh'],
'a-3': ['yarg'],
'a-4': [''],
'a-7': ['mmm']
})
form = F(pdata)
self.assertEqual(len(form.a.entries), 4)
self.assertEqual(form.a.data, ['bleh', 'yarg', '', 'mmm'])
self.assertFalse(form.validate())
form = F(pdata, a=data)
self.assertEqual(form.a.data, ['bleh', 'yarg', '', 'mmm'])
self.assertFalse(form.validate())
# Test for formdata precedence
pdata = DummyPostData({'a-0': ['a'], 'a-1': ['b']})
form = F(pdata, a=data)
self.assertEqual(len(form.a.entries), 2)
self.assertEqual(form.a.data, ['a', 'b'])
self.assertEqual(list(iter(form.a)), list(form.a.entries))
def test_enclosed_subform(self):
make_inner = lambda: AttrDict(a=None)
F = make_form(a=FieldList(
FormField(make_form('FChild', a=self.t), default=make_inner)))
data = [{'a': 'hello'}]
form = F(a=data)
self.assertEqual(form.a.data, data)
self.assertTrue(form.validate())
form.a.append_entry()
self.assertEqual(form.a.data, data + [{'a': None}])
self.assertFalse(form.validate())
pdata = DummyPostData({
'a-0': ['fake'],
'a-0-a': ['foo'],
'a-1-a': ['bar']
})
form = F(pdata, a=data)
self.assertEqual(form.a.data, [{'a': 'foo'}, {'a': 'bar'}])
inner_obj = make_inner()
inner_list = [inner_obj]
obj = AttrDict(a=inner_list)
form.populate_obj(obj)
self.assertTrue(obj.a is not inner_list)
self.assertEqual(len(obj.a), 2)
self.assertTrue(obj.a[0] is inner_obj)
self.assertEqual(obj.a[0].a, 'foo')
self.assertEqual(obj.a[1].a, 'bar')
# Test failure on populate
obj2 = AttrDict(a=42)
self.assertRaises(TypeError, form.populate_obj, obj2)
def test_entry_management(self):
F = make_form(a=FieldList(self.t))
a = F(a=['hello', 'bye']).a
self.assertEqual(a.pop_entry().name, 'a-1')
self.assertEqual(a.data, ['hello'])
a.append_entry('orange')
self.assertEqual(a.data, ['hello', 'orange'])
self.assertEqual(a[-1].name, 'a-1')
self.assertEqual(a.pop_entry().data, 'orange')
self.assertEqual(a.pop_entry().name, 'a-0')
self.assertRaises(IndexError, a.pop_entry)
def test_min_max_entries(self):
F = make_form(a=FieldList(self.t, min_entries=1, max_entries=3))
a = F().a
self.assertEqual(len(a), 1)
self.assertEqual(a[0].data, None)
big_input = ['foo', 'flaf', 'bar', 'baz']
self.assertRaises(AssertionError, F, a=big_input)
pdata = DummyPostData(('a-%d' % i, v) for i, v in enumerate(big_input))
a = F(pdata).a
self.assertEqual(a.data, ['foo', 'flaf', 'bar'])
self.assertRaises(AssertionError, a.append_entry)
def test_validators(self):
def validator(form, field):
if field.data and field.data[0] == 'fail':
raise ValueError('fail')
elif len(field.data) > 2:
raise ValueError('too many')
F = make_form(a=FieldList(self.t, validators=[validator]))
# Case 1: length checking validators work as expected.
fdata = DummyPostData({
'a-0': ['hello'],
'a-1': ['bye'],
'a-2': ['test3']
})
form = F(fdata)
assert not form.validate()
self.assertEqual(form.a.errors, ['too many'])
# Case 2: checking a value within.
fdata['a-0'] = ['fail']
form = F(fdata)
assert not form.validate()
self.assertEqual(form.a.errors, ['fail'])
# Case 3: normal field validator still works
form = F(DummyPostData({'a-0': ['']}))
assert not form.validate()
self.assertEqual(form.a.errors, [['This field is required.']])
def test_no_filters(self):
my_filter = lambda x: x
self.assertRaises(TypeError,
FieldList,
self.t,
filters=[my_filter],
_form=Form(),
_name='foo')
def test_process_prefilled(self):
data = ['foo', 'hi', 'rawr']
class A(object):
def __init__(self, a):
self.a = a
obj = A(data)
F = make_form(a=FieldList(self.t))
# fill form
form = F(obj=obj)
self.assertEqual(len(form.a.entries), 3)
# pretend to submit form unchanged
pdata = DummyPostData({'a-0': ['foo'], 'a-1': ['hi'], 'a-2': ['rawr']})
form.process(formdata=pdata)
# check if data still the same
self.assertEqual(len(form.a.entries), 3)
self.assertEqual(form.a.data, data)
class LoginForm(Form):
username = StringField('Username',
[validators.Required("Please enter user name.")])
password = PasswordField('Password',
[validators.Required("Please enter password.")])
