def scaffold_form(self):
"""改写form"""
form_class = super(PubView, self).scaffold_form()
delete_attrs(form_class, ('access_token_time', 'access_token', 'address', 'tel', 'base_path', 'rel_path',
'pic_name', 'logo', 'create_time'))
form_class.user = TextField(label=u'酒吧管理员', validators=[validators.required(), validators.length(max=16)])
form_class.password = TextField(label=u'管理员密码', validators=[validators.required()])
return form_class
def test_required(self):
self.assertEqual(required()(self.form, DummyField('foobar')), None)
self.assertRaises(StopValidation, required(), self.form, DummyField(''))
self.assertRaises(StopValidation, required(), self.form, DummyField(' '))
self.assertEqual(required().field_flags, ('required', ))
f = DummyField('', ['Invalid Integer Value'])
self.assertEqual(len(f.errors), 1)
self.assertRaises(StopValidation, required(), self.form, f)
self.assertEqual(len(f.errors), 0)
def test_required(self):
self.assertEqual(required()(self.form, DummyField("foobar")), None)
self.assertRaises(StopValidation, required(), self.form, DummyField(""))
self.assertRaises(StopValidation, required(), self.form, DummyField(" "))
self.assertEqual(required().field_flags, ("required",))
f = DummyField("", ["Invalid Integer Value"])
self.assertEqual(len(f.errors), 1)
self.assertRaises(StopValidation, required(), self.form, f)
self.assertEqual(len(f.errors), 0)
def scaffold_form(self):
"""改写form"""
form_class = super(PubView, self).scaffold_form()
delete_attrs(form_class, ('access_token_time', 'access_token', 'token', 'appid', 'secret', 'create_time',
'stop_time', 'status', 'base_path', 'rel_path', 'pic_name', 'logo'))
form_class.user = TextField(label=u'酒吧管理员', validators=[validators.required(), validators.length(max=16)])
form_class.password = TextField(label=u'管理员密码', validators=[validators.required()])
form_class.picture = FileField(label=u'酒吧图片',
description=u'为了更好的展示效果，严格使用640 * 288的图片，仅支持png与jpeg(jpg)格式')
return form_class
def field_factory(attr):
kwargs = defaultdict(list)
kwargs['id'] = attr.name
kwargs['label'] = attr.comment
if attr.in_key: kwargs['validators'].append(required())
if attr.nullable or attr.default is not None:
kwargs['validators'].append(optional())
if attr.type.startswith('int'):
return wtf.IntegerField(**kwargs)
elif attr.type == 'double' or attr.type == 'float':
return wtf.FloatField(**kwargs)
elif attr.type.startswith('varchar'):
ml = int(attr.type.split('(')[-1][:-1])
return wtf.StringField(**kwargs) # TODO: can I specify a max length here?
elif attr.type == 'date':
kwargs['validators'].append(date_validator)
return wtf.DateField(format='%Y-%m-%d', default=datetime.date.today(), **kwargs)
elif attr.type.startswith('enum'):
choices = [(e[1:-1],e[1:-1]) for e in attr.type[attr.type.find('(')+1:attr.type.rfind(')')].split(',')]
return wtf.SelectField(choices=choices, **kwargs)
elif attr.type.startswith('char'):
l = int(attr.type.split('(')[-1][:-1])
kwargs['validators'].append(len_validator_factory(l))
return wtf.StringField(**kwargs) # TODO: can I specify a max length here?
elif attr.type == 'timestamp':
return wtf.DateTimeField(format='%Y-%m-%d %H:%M', default=datetime.datetime.today(), **kwargs)
else:
raise NotImplementedError('FieldFactory does not know what to do with %s' % (attr.type))
def setUp(self):
F = make_form(
a=TextField(validators=[validators.required()]),
b=TextField(),
)
self.F1 = make_form('F1', a=FormField(F))
self.F2 = make_form('F2', a=FormField(F, separator='::'))
def formfield_from_modelfield(field):
field_type = field.__class__.__name__.lower()
opts = {
'validators': []
}
default = getattr(field, 'default', odis.EMPTY)
if field_type == 'relfield':
opts['queryset'] = field.model.obj.all()
if is_coll_field(field):
opts['validators'].append(validators.optional())
elif default != odis.EMPTY or getattr(field, 'nil', False):
opts['validators'].append(validators.optional())
else:
opts['validators'].append(validators.required())
if default != odis.EMPTY:
opts['default'] = default
if getattr(field, 'choices', False):
opts['choices'] = field.choices
opts['label'] = field.verbose_name or field.name
if 'choices' in opts:
form_field = fields.SelectField
#opts['coerce'] = field.to_python
else:
form_field = fields_table[field_type]
return form_field(**opts)
def set_validators(column):
vldts=[]
for key,val in column.iteritems():
if key == 'notnull':
if val == 0:
self.vldts + validators.required()
return vldts
def convert(self, model, prop, field_args):
"""
Returns a form field for a single model property.
:param model:
The ``db.Model`` class that contains the property.
:param prop:
The model property: a ``db.Property`` instance.
:param field_args:
Optional keyword arguments to construct the field.
"""
prop_type_name = type(prop).__name__
kwargs = {
'label': prop.name.replace('_', ' ').title(),
'default': prop.default_value(),
'validators': [],
}
if field_args:
kwargs.update(field_args)
if prop.required and prop_type_name not in self.NO_AUTO_REQUIRED:
kwargs['validators'].append(validators.required())
if prop.choices:
# Use choices in a select field if it was not provided in field_args
if 'choices' not in kwargs:
kwargs['choices'] = [(v, v) for v in prop.choices]
return f.SelectField(**kwargs)
else:
converter = self.converters.get(prop_type_name, None)
if converter is not None:
return converter(model, prop, kwargs)
def scaffold_form(self):
"""改写form"""
form_class = super(GiftView, self).scaffold_form()
delete_attrs(form_class, ("pub", "number", "win_number", "create_time", "intro"))
form_class.intro = TextAreaField(label=u"奖品介绍", validators=[validators.required(), validators.length(max=256)])
return form_class
def postprocess_form(self, form):
form.product_id = Select2Field(_("Product"), default=0,
choices=[(g.id, g.customer.customer_name + " " + g.product_name +
" " + str(g.specification) + "")
for g in Product.query.filter_by(active=True)
.order_by("customer_id")
.order_by('product_name')],
coerce=int, validators=[required()])
form.inventory_location_id = Select2Field(_("Inventory Location"),
default=0, choices=[(g.id, g.location_full_name) for g in
InventoryLocation.query.filter_by(active=True).
order_by('location_name')],
coerce=int, validators=[required()])
form.quantity = IntegerField(_("Quantity"), validators=[required()],
default=1)
return form
def convert(self, column):
kwargs = {
'label': column.info.get('label', column.name),
'description': column.description,
'validators': [],
'default': column.default and column.default.arg
}
if column.info.get('optional', False):
kwargs['validators'].append(validators.optional())
elif not column.nullable:
kwargs['validators'].append(validators.required())
if hasattr(column.type, 'length') and column.type.length is not None:
kwargs['validators'].append(validators.length(max=column.type.length))
fname = type(column.type).__name__
if len(column.foreign_keys) > 0:
return self.conv_ForeignKey(kwargs, column)
if fname in self.SIMPLE_CONVERSIONS:
return self.SIMPLE_CONVERSIONS[fname](**kwargs)
else:
mod = getattr(self, 'conv_%s' % fname, None)
if mod is not None:
return mod(kwargs, column)
def scaffold_form(self):
"""改写form"""
form_class = super(TicketView, self).scaffold_form()
delete_attrs(form_class, ('base_path', 'rel_path', 'pic_name', 'pub', 'create_time', 'intro'))
form_class.intro = TextAreaField(label=u'优惠券介绍', validators=[validators.required(), validators.length(max=256)])
form_class.picture = FileField(label=u'优惠券图片', description=u'推荐使用640*288')
return form_class
def __init__(self, *args, **kwargs):
super(AddProjectForm, self).__init__(*args, **kwargs)
project_types = ProjectTypes.query.all()
self.project_type_id.choices = [(u.id, u.name) for u in project_types]
# additional validators
self.project_type_id.validators = [validators.required()]
def build_questionnaire(form, data=None):
fields = {'groups': []}
fields['participant'] = StringField(
u'Participant',
filters=[partial(filter_participants, form)],
validators=[validators.required()])
for group in form.groups:
groupspec = (group.name, [])
for field in group.fields:
# if the field has options, create a list of choices
if field.options:
choices = [(v, k) for k, v in field.options.iteritems()]
if field.allows_multiple_values:
fields[field.name] = IntegerSplitterField(
field.name,
choices=choices,
description=field.description,
validators=[validators.optional()],
)
else:
fields[field.name] = SelectField(
field.name,
choices=choices,
coerce=int,
description=field.description,
validators=[validators.optional()],
widget=widgets.TextInput()
)
else:
if form.form_type == 'CHECKLIST':
fields[field.name] = IntegerField(
field.name,
description=field.description,
validators=[
validators.optional(),
validators.NumberRange(min=field.min_value,
max=field.max_value)]
)
else:
fields[field.name] = IntegerField(
field.name,
description=field.description,
validators=[validators.optional()]
)
fields['groups'].append(groupspec)
form_class = type('QuestionnaireForm', (BaseQuestionnaireForm,), fields)
return form_class(data)
def convert(self, model, prop, field_args):
"""
Returns a form field for a single model property.
:param model:
The ``db.Model`` class that contains the property.
:param prop:
The model property: a ``db.Property`` instance.
:param field_args:
Optional keyword arguments to construct the field.
"""
prop_type_name = type(prop).__name__
# Check for generic property
if(prop_type_name == "GenericProperty"):
# Try to get type from field args
generic_type = field_args.get("type")
if generic_type:
prop_type_name = field_args.get("type")
# If no type is found, the generic property uses string set in convert_GenericProperty
kwargs = {
'label': prop._code_name.replace('_', ' ').title(),
'default': prop._default,
'validators': [],
}
if field_args:
kwargs.update(field_args)
if prop._required and prop_type_name not in self.NO_AUTO_REQUIRED:
kwargs['validators'].append(validators.required())
if kwargs.get('choices', None):
# Use choices in a select field.
kwargs['choices'] = [(v, v) for v in kwargs.get('choices')]
return f.SelectField(**kwargs)
if prop._choices:
# Use choices in a select field.
kwargs['choices'] = [(v, v) for v in prop._choices]
return f.SelectField(**kwargs)
else:
converter = self.converters.get(prop_type_name, None)
if converter is not None:
return converter(model, prop, kwargs)
else:
return self.fallback_converter(model, prop, kwargs)
def __init__(cls,**kwargs):
super(AddEntryForm,cls).__init__(**kwargs)
#
columns = [c for c in kwargs['columns'] if c['pk'] == 0]
colnames = [c['name'] for c in columns]
#self._fields = {}
_table = kwargs['table']
#
for column in columns:
vldts = []
if column['notnull'] == 1:
vldts.append(validators.required())
setattr(cls,column['name'],None)
if column['type'] == 'integer':
def convert(self, model, prop, field_args):
"""
Returns a form field for a single model property.
:param model:
The ``db.Model`` class that contains the property.
:param prop:
The model property: a ``db.Property`` instance.
:param field_args:
Optional keyword arguments to construct the field or an
UnboundField instance (i.e. Field declaration).
"""
if isinstance(field_args, UnboundField):
return field_args
prop_type_name = self.get_prop_type_name(prop, field_args)
kwargs = {
'label': prop._code_name.replace('_', ' ').title(),
'default': prop._default,
'validators': [],
}
if field_args:
kwargs.update(field_args)
if prop._required and prop_type_name not in self.NO_AUTO_REQUIRED:
kwargs['validators'].append(validators.required())
if kwargs.get('choices', None) or prop._choices:
# Use choices in a select field.
if not kwargs.get('choices', None):
kwargs['choices'] = [(v, v) for v in sorted(prop._choices)]
if prop._repeated:
return f.SelectMultipleField(**kwargs)
else:
return f.SelectField(**kwargs)
else:
converter = self.get_converter(
prop_type_name,
prop,
field_args)
return converter(model, prop, kwargs)
def convert(self, model, prop, field_args):
"""
Returns a form field for a single model property.
:param model:
The ``db.Model`` class that contains the property.
:param prop:
The model property: a ``db.Property`` instance.
:param field_args:
Optional keyword arguments to construct the field.
"""
name = prop._code_name
#if prop.verbose_name:
# name = prop.verbose_name
kwargs = {
'label': name.replace('_', ' ').title(),
'default': prop._default,
'validators': [],
}
choices = None
#default = None
if field_args:
choices = field_args.get("choices", None)
if choices:
del field_args["choices"]
kwargs.update(field_args)
if prop._required:
kwargs['validators'].append(validators.required())
if prop._choices:
# Use choices in a select field.
kwargs['choices'] = [(v, v) for v in prop._choices]
return f.SelectField(**kwargs)
if choices:
kwargs['choices'] = [(v, v) for v in choices]
field = f.SelectField(**kwargs)
#field.process_data(default)
return field
else:
converter = self.converters.get(type(prop).__name__, None)
if converter is not None:
return converter(model, prop, kwargs)
def create_form(self, relations=True):
model = self.model
class_name = '%sForm' % mixedcase(model._name)
attrs = {}
fields = model.fields_get(self.fields)
defaults = model.default_get(fields.keys())
for k, v in fields.items():
type_field = MAPPING_TYPES.get(v.get('type', 'float'))
if not type_field:
continue
override = self._get_form_overrides(k)
if override:
type_field = override
kwargs = {}
validators = []
if 'required' in v and v['required']:
validators.append(wtf_validators.required())
if 'size' in v:
validators.append(wtf_validators.length(max=v['size']))
if k in defaults and defaults[k] is not False:
kwargs['default'] = defaults[k]
if v.get('help'):
kwargs['description'] = v['help']
if v['type'] == 'selection':
if v['selection'] and isinstance(v['selection'][0][0], int):
kwargs['coerce'] = int
kwargs['choices'] = v['selection']
elif v['type'] == 'char' and 'invisible' in v and v['invisible']:
type_field = PasswordField
elif v['type'] == 'date':
kwargs['widget'] = widgets.DatePickerWidget()
elif v['type'] == 'datetime':
kwargs['widget'] = widgets.DateTimePickerWidget()
elif v['type'] in ('many2one', 'one2many'):
kwargs['coerce'] = coerce_relation
if v['type'] == 'many2one':
kwargs['widget'] = widgets.Select2Widget()
elif v['type'] == 'one2many':
kwargs['widget'] = ListWidget()
elif v['type'] == 'many2many':
kwargs['widget'] = widgets.Select2Widget(multiple=True)
attrs[k] = type_field(label=v['string'], **kwargs)
return type(class_name, (BaseForm, ), attrs)
def test_lazy_proxy(self):
"""Tests that the validators support lazy translation strings for messages."""
class ReallyLazyProxy(object):
def __unicode__(self):
raise Exception('Translator function called during form declaration: it should be called at response time.')
__str__ = __unicode__
message = ReallyLazyProxy()
self.assertRaises(Exception, str, message)
self.assertRaises(Exception, text_type, message)
self.assertTrue(equal_to('fieldname', message=message))
self.assertTrue(length(min=1, message=message))
self.assertTrue(NumberRange(1, 5, message=message))
self.assertTrue(required(message=message))
self.assertTrue(regexp('.+', message=message))
self.assertTrue(email(message=message))
self.assertTrue(ip_address(message=message))
self.assertTrue(url(message=message))
def convert(self, model, prop, field_args):
prop_type_name = type(prop).__name__
kwargs = {
'label': self.locale_obj.translate(prop.name.replace('_', ' ').title()),
'default': prop.default_value(),
'validators': [],
}
if field_args:
kwargs.update(field_args)
if prop.required and prop_type_name not in self.NO_AUTO_REQUIRED:
kwargs['validators'].append(validators.required())
if prop.choices:
# Use choices in a select field.
kwargs['choices'] = [(v, v) for v in prop.choices]
return f.SelectField(**kwargs)
else:
converter = self.converters.get(prop_type_name, None)
if converter is not None:
return converter(model, prop, kwargs)
def test_required(self):
# Make sure we stop the validation chain
self.assertEqual(required()(self.form, DummyField('foobar')), None)
self.assertRaises(StopValidation, required(), self.form, DummyField(''))
self.assertRaises(StopValidation, required(), self.form, DummyField(' '))
self.assertEqual(required().field_flags, ('required', ))
# Make sure we clobber errors
f = DummyField('', ['Invalid Integer Value'])
self.assertEqual(len(f.errors), 1)
self.assertRaises(StopValidation, required(), self.form, f)
self.assertEqual(len(f.errors), 0)
# Check message and custom message
grab = lambda **k: grab_stop_message(required(**k), self.form, DummyField(''))
self.assertEqual(grab(), 'This field is required.')
self.assertEqual(grab(message='foo'), 'foo')
class RenderArgsForm(Form):
page = StringField("page", [validators.required()])
key = FieldList(StringField("key", [validators.Optional()]))
value = FieldList(StringField("value", [validators.Optional()]))
def setUp(self):
F = make_form(a=TextField(validators=[validators.required()]), b=TextField())
self.F1 = make_form("F1", a=FormField(F))
self.F2 = make_form("F2", a=FormField(F, separator="::"))
def text_renderer_field_factory():
return SelectField(label=u'Text format',
choices=(('rest', 'reStructuredText'),
('plain', 'plain text')),
default='rest',
validators=[required()])
def Required(cls):
''' Legacy alias for DataRequired. '''
return validators.required()
class ReusableForm(Form):
module = TextField('Module Grade:', validators=[validators.required()])
weight = TextField('Weighting:', validators=[validators.required()])
class RegisterForm(FlaskForm):
login = TextField('username', validators=[validators.required()])
key = TextField('password', validators=[validators.required()])
class EditPlaybookForm(Form):
new_name = StringField(
'new_name', [validators.Length(min=1, max=50),
validators.required()])
#!/usr/bin/env python
# encoding: utf-8
"""
public_forms.py
"""
from wtforms import Form, TextField, TextAreaField, BooleanField, validators
class fileForm(Form):
title = TextField(u'file title', validators=[validators.required()])
link = TextField(u'link', validators=[validators.required()])
comment = TextAreaField(u'Comment')
adddate = ndb.DateTimeProperty(auto_now_add=True)
class MemberForm(Form):
name = TextField(u'name', validators=[validators.required()])
email = TextField(u'email', validators=[validators.required()])
ext = TextField(u'ext', validators=[validators.required()])
funFact = TextAreaField(u'fun fact')
startDate = ndb.DateTimeProperty()
# cumstom validation code
# def validate_field(form, field):
# sfield = form.sfield.data
# if sfield:
# if not field.data:
# raise validators.ValidationError('If you are sfield, reasons ')
class EditForm(self.form_base_class):
content = fields.TextAreaField(lazy_gettext('Content'),
(validators.required(), ))
class AddSourceForm(FlaskForm):
sourceName = StringField("Source Name:",[validators.required(), validators.length(max=20)])
presType = StringField("PresType Name:",[validators.required()])
submit = SubmitField('SubmitCreateSource')
class QuizGenerator(Form):
topic = TextField('Topic:')
article = TextField('Article:',
validators=[
validators.required(),
validators.Length(
min=100,
message=(u'Must be atleast 100 words length'))
])
@app.route("/generateGapQuestions", methods=['POST'])
def generateGapQuestions():
data = json.loads(request.data)
article = data['article']
summarized_text, summary_sentences = summarize(article)
gap_questions = []
for sentence in summary_sentences:
gap_question = create_gap_questions(sentence)
# create_mcq_questions(sentence)
if gap_question:
gap_questions.append(gap_question)
# print(gap_questions)
response = jsonify(gap_questions)
response.headers.add('Access-Control-Allow-Origin', '*')
return response
@app.route("/generateMcqQuestions", methods=["POST"])
def generateMcqQuestions():
data = json.loads(request.data)
article = data['article']
summarized_text, summary_sentences = summarize(article)
mcq_questions = []
no_questions = 0
for sentence in summary_sentences:
mcq_question = create_mcq_questions(sentence)
if mcq_question:
no_questions += 1
mcq_questions.append(mcq_question)
print(no_questions)
response = jsonify(mcq_questions)
response.headers.add('Access-Control-Allow-Origin', '*')
return response
@app.route("/generateShortQuestions", methods=['POST'])
def generateShortQuestions():
data = json.loads(request.data)
article = data['article']
summarized_text, summary_sentences = summarize(article)
short_questions = []
for sentence in summary_sentences:
short_question = create_short_questions(sentence)
if short_question:
short_questions.append(short_question)
response = jsonify(short_questions)
response.headers.add('Access-Control-Allow-Origin', '*')
return response
@app.route("/summary", methods=['POST'])
def generateSummary():
data = json.loads(request.data)
article = data['article']
summarized_text, summary_sentences = summarize(article)
return (json.dumps(summarized_text), 200)
@app.route("/check", methods=['POST', 'GET'])
def checkApp():
return "working"
class newForm(Form):
ticker = StringField('ticker:', validators=[validators.required()])
class NameForm(FlaskForm):
name = StringField("What is your name ? ", validators=[required()])
submit = SubmitField("Submit")
def test_required(self):
self.assertEqual(required()(self.form, DummyField('foobar')), None)
self.assertRaises(StopValidation, required(), self.form, DummyField(''))
class CommentForm(Form):
comment = TextField('Comentario',
[
validators.required(message="Requiere usuario"),
])
honeypot = HiddenField("",[length_honeypot])
class EditConfigForm(Form):
key = StringField(
'key', [validators.required(),
validators.length(min=1, max=25)])
value = StringField('value')
class NewRoleForm(Form):
name = StringField('name', [validators.required()])
description = StringField('description')
from wtforms import fields, validators
from common import form
UserNameField = lambda: fields.TextField(u"Username",
[validators.required(), validators.regexp('[-a-zA-Z0-9]+'), validators.length(max=256)])
class RegisterForm(form.Form):
username = UserNameField()
password = fields.PasswordField(u"Password", [validators.required()])
class Hello(Form):
nickName = TextField('Nick Name:', validators=[validators.required()])
email = TextField('Email:')
class EditForm(form.BaseForm):
content = fields.TextAreaField(lazy_gettext('Content'),
(validators.required(), ))
class LoginForm(FlaskForm):
username = TextField('Username:'******'Password:'******'Submit')
class LoginForm(Form):
username = TextField('Username', [validators.required()])
password = PasswordField('Password', [validators.required()])
class UploadForm(Form):
url = URLField(u"App URL", validators=[url(), required()])
language = Select2Field(u"Language", choices = LANGUAGE_CHOICES, validators = [ required() ])
target = Select2Field(u"Target age", choices = TARGET_CHOICES, validators = [ required() ], default = "ALL")
opensocial_xml = FileField(u'OpenSocial XML file', validators = [required()])
class LoginForm(FlaskForm):
username = TextField('username', validators=[validators.required()])
password = TextField('password', validators=[validators.required()])
if check:
raise validators.ValidationError(self.message)
UserForm = model_form(User,
db.session,
Form,
only=[
'username', 'name',
'email', 'phone', 'company',
'address1', 'address2',
'postcode', 'city', 'country',
'locksmith_licence'
],
field_args={
'username': {'validators': [validators.required(),
Unique(User, User.username)]},
'password': {'validators': [validators.required()]},
'name': {'validators': [validators.required()]},
'email': {'validators': [validators.required()]},
'phone': {'validators': [validators.required()]},
'company': {'validators': [validators.required()]},
'address1': {'validators': [validators.required()]},
'address2': {'validators': [validators.required()]},
'postcode': {'validators': [validators.required()]},
'city': {'validators': [validators.required()]},
'country': {'validators': [validators.required()]},
'locksmith_licence': {'validators': [validators.required()]},
})
class ReusableForm(Form):
name = TextField('Name:', validators=[validators.required()])
class RemoveConfigForm(Form):
key = StringField(
'key', [validators.required(),
validators.length(min=1, max=25)])
class ReusableForm(Form):
value = TextField('Value:', validators=[validators.required()])
class IPForm(Form):
ip = TextField('Dirección IP:', validators=[validators.required()])
class ReusableForm(Form):
value = StringField('Value:', validators=[validators.required()])
key = StringField('Key:', validators=[validators.required()])
class LoginForm(Form):
email = StringField('Email',[
validators.required(),validators.Email(), validators.Length(min=4,max=40)])
password = PasswordField('Password',[
validators.required()])
remember = BooleanField('Remember Me')
class Background(Form):
YearRangeMsg = 'Years of experience should be between 0 and 40'
ExpRangeMsg = 'Number of experiments is limited to a number in the range of 0-1000'
MonthRangeMsg = 'Months of experience should be between 0 and 11'
# Choices for expertise.
valid_choices = ['novice', 'intermediate', 'expert']
# Fields
numdeteryears = TextField(
'How long have you used DETERLab?<br>(An estimate is fine. Pleas round <b>up</b> to the nearest month.)',
validators=[validators.required()])
numdetermonths = TextField('numdetermonths',
validators=[validators.required()])
numdeterexps = TextField(
'How many experiments have you run on DETERLab?<br>(An estimate is fine)',
validators=[validators.required()])
deterExperience = RadioField(
'How would you rate your DETERLab experience level?',
choices=[('novice', 'Novice'), ('intermediate', 'Intermediate'),
('expert', 'Expert')],
default='novice')
numyears = TextField(
'How long have you used testbeds in general?<br>(e.g. Genie, Emulab etc.)',
validators=[validators.required()])
nummonths = TextField('nummonths', validators=[validators.required()])
numexps = TextField(
'How many experiments have you run on testbeds?<br>(An estimate is fine)',
validators=[validators.required()])
testbedExperience = RadioField(
'How would you rate your general testbed experience level?',
choices=[('novice', 'Novice'), ('intermediate', 'Intermediate'),
('expert', 'Expert')],
default='novice')
def inYearRange(num):
try:
if int(num.data.strip()) >= 0 and int(num.data.strip()) <= 40:
return True
except:
return False
def inMonthRange(num):
try:
if int(num.data.strip()) >= 0 and int(num.data.strip()) <= 11:
return True
except:
return False
def inExpRange(num):
try:
if int(num.data.strip()) >= 0 and int(num.data.strip()) <= 1000:
return True
except:
return False
@staticmethod
def validate_numdeteryears(form, field):
print("Testing ", field)
if not Background.inYearRange(field):
raise validators.ValidationError(Background.YearRangeMsg)
@staticmethod
def validate_numyears(form, field):
if not Background.inYearRange(field):
raise validators.ValidationError(Background.YearRangeMsg)
@staticmethod
def validate_numdetermonths(form, field):
if not Background.inMonthRange(field):
raise validators.ValidationError(Background.MonthRangeMsg)
@staticmethod
def validate_nummonths(form, field):
if not Background.inMonthRange(field):
raise validators.ValidationError(Background.MonthRangeMsg)
@staticmethod
def validate_numdeterexps(form, field):
if not Background.inExpRange(field):
raise validators.ValidationError(Background.ExpRangeMsg)
@staticmethod
def validate_numexps(form, field):
if not Background.inExpRange(field):
raise validators.ValidationError(Background.ExpRangeMsg)
@staticmethod
def validate_deterExperience(form, field):
Background.validate_testbedExperience(form, field)
@staticmethod
def validate_testbedExperience(form, field):
if field.data not in Background.valid_choices:
raise validators.ValidationError(
"Requires choice of %s but got %s" %
(' '.join(Background.valid_choices), field.data))
class CommentForm(Form):
text = TextAreaField(u'Text', validators=[
validators.required(),
validators.Length(max=2000)
])
class LoginForm(FlaskForm):
email = StringField('email', [required(), Email()])
password = PasswordField('password', [required(), length(min=8, max=35)])
submit = SubmitField('submit', [required()])
class NewUserForm(Form):
username = StringField(
'username', [validators.Length(min=4, max=25),
validators.required()])
password = PasswordField('password', [validators.required()])
role = FieldList(StringField('role', [validators.Length(min=4, max=25)]))
class Query(FlaskForm):
queryField = StringField("Query Field:", [validators.required(), validators.length(max=10)])
similarityLevel = StringField("Similarity Level:", [validators.length(max=10)])
queryType = SelectField("Query Type :", choices=[("0", "Local Query"), ("1", "Singleview Query"), ("2", "Singleview Similarity Query")], coerce=int)
submit = SubmitField('Query')
class Tools(Form):
tooldescription = TextAreaField(
"Description of your orchestration, scripting and tooling.",
validators=[validators.required()])
