def __init__(self, method, action, csrf=False):
self.form = BaseForm({})
self.elements = dict()
self.method = method
self.action = action
if not csrf:
self.form._csrf = None
def __init__(self, course_id, questions, total_marks):
course = Course.query.filter(Course.id == course_id).first()
units = Unit.query.filter(Unit.course == course).all()
question_translator = defaultdict(dict)
form_fields = {}
validators = defaultdict(list)
flatten_data = defaultdict(list)
flatten_data["units"].extend([0] * len(units))
flatten_data["cognitive"].extend([0] * len(CognitiveEnum.__members__))
flatten_data["difficulty"].extend([0] *
len(DifficultyEnum.__members__))
flatten_data["questions"].extend([0] * sum(questions))
for unit in units:
field = f"Unit:{unit.chapter_no:02d}"
form_fields.update(
{field: IntegerField(field, validators=[DataRequired()])})
validators["units"].append(field)
for c_level in CognitiveEnum.__members__:
form_fields.update(
{c_level: IntegerField(c_level, validators=[DataRequired()])})
validators["cognitive"].append(c_level)
for d_level in DifficultyEnum.__members__:
form_fields.update(
{d_level: IntegerField(d_level, validators=[DataRequired()])})
validators["difficulty"].append(d_level)
idx = 0
for question_no, subquestions in enumerate(questions):
for subquestion in range(subquestions):
field = f"Que.{question_no + 1}.{ascii_uppercase[subquestion]}"
form_fields.update(
{field: IntegerField(field, validators=[DataRequired()])})
validators["questions"].append(field)
question_translator[question_no +
1][ascii_uppercase[subquestion]] = idx
idx += 1
for i, validator in validators.items():
validators[i] = IsSumOf(*validator)
form_fields.update({
"total_marks":
IntegerField("total_marks",
validators=[DataRequired(),
*validators.values()]) # *validators
})
self.form = BaseForm(form_fields)
self.flatten_data = flatten_data
self.course = course
self.total_marks = total_marks
self.unit_field_regex = re.compile(r"Unit:(\d\d)")
self.question_field_regex = re.compile(r"Que.(\d+).([A-Z])")
self.question_translator = question_translator
def test_create(self):
q_multi = QuestionMultiple(30, 'Alcohol')
self.assertEqual(q_multi.id, 30)
self.assertEqual(q_multi.group_name, 'Alcohol')
self.assertEqual(q_multi.set_response, None)
self.assertEqual(q_multi.response_type, 'MULTIPLE')
self.assertEqual(
q_multi.question,
'What type(s) of alcohol do you typically consume '
'(select all that apply)?')
self.assertEqual(
q_multi.american_question,
'What type(s) of alcohol do you typically consume '
'(select all that apply)?')
self.assertEqual(q_multi.triggers, tuple())
self.assertEqual(q_multi.qid, 'Alcohol_30')
self.assertEqual(q_multi.interface_element_ids, ['Alcohol_30_0'])
# Test rendering of form object
form = BaseForm(
{q_multi.interface_element_ids[0]: q_multi.interface_elements[0]})
eid = q_multi.interface_element_ids[0]
self.assertEqual(str(type(form[eid])),
"<class 'wtforms.fields.core.SelectMultipleField'>")
self.assertEqual(form[eid].choices, [(0, 'Beer/Cider'),
(1, 'Sour beers'),
(2, 'White wine'),
(3, 'Red wine'),
(4, 'Spirits/hard alcohol')])
def __init__(self, request):
"""Base class for input validation. Subclass to add validators.
:param request: flask.Request object to validate.
"""
#: List of errors from all validators.
self.errors = []
self._request = request
self._forms = dict()
for name in dir(self):
if not name.startswith('_') and name not in [
'errors', 'validate', 'valid_attrs'
]:
input = getattr(self, name)
fields = dict()
if isinstance(input, dict):
for field, validators in input.items():
fields[field] = Field(validators=validators)
elif isinstance(input, collections.Iterable):
fields['_input'] = Field(validators=input)
self._forms[name] = BaseForm(fields)
def admin():
if not current_user.is_admin():
# No permission
flash("Permission denied", 'danger')
return redirect(url_for("index"))
form = UserForm()
if form.is_submitted() and BaseForm.validate(
form, extra_validators={'password': [validators.Required()]}):
user = db.User()
form.populate_obj(user)
user.save()
User.update(username=user.username, password=form.password.data)
flash("Account for '%s' created" % user.username, 'success')
return redirect(url_for("admin"))
users = db.User.find()
deployment_counts_raw = db.User.get_deployment_count_by_user()
deployment_counts = {m['_id']: m['count'] for m in deployment_counts_raw}
return render_template('admin.html',
form=form,
users=users,
deployment_counts=deployment_counts)
def get_form(self, **kwargs):
def validate_test(form, field):
if field.data != "foobar":
raise ValidationError("error")
return BaseForm({"test": StringField(validators=[validate_test])},
**kwargs)
def get_form(self, **kwargs):
def validate_test(form, field):
if field.data != 'foobar':
raise ValidationError('error')
return BaseForm({'test': TextField(validators=[validate_test])},
**kwargs)
def admin():
if not current_user.is_admin():
# No permission
flash("Permission denied", 'danger')
return redirect(url_for("index"))
form = UserForm()
if form.is_submitted() and BaseForm.validate(form, extra_validators={'password':[validators.Required()]}):
user = db.User()
form.populate_obj(user)
user.save()
User.update(username=user.username, password=form.password.data)
# make sure user dirs exist
user.ensure_dir('upload')
flash("Account for '%s' created" % user.username, 'success')
return redirect(url_for("admin"))
users = db.User.find()
mission_counts_raw = db.User.get_mission_count_by_user()
mission_counts = {m['_id']:m['count'] for m in mission_counts_raw}
return render_template('admin.html', form=form, users=users, mission_counts=mission_counts)
def test_create_no_triggers(self):
q_single = QuestionSingle(23, 'Education')
self.assertEqual(q_single.id, 23)
self.assertEqual(q_single.group_name, 'Education')
self.assertEqual(q_single.set_response, None)
self.assertEqual(q_single.response_type, 'SINGLE')
self.assertEqual(q_single.question,
'What is your highest level of education?')
self.assertEqual(q_single.american_question,
'What is your highest level of education?')
self.assertEqual(q_single.triggers, tuple())
self.assertEqual(q_single.qid, 'Education_23')
self.assertEqual(q_single.interface_element_ids, ['Education_23_0'])
# Test rendering of form object
form = BaseForm({
q_single.interface_element_ids[0]:
q_single.interface_elements[0]
})
eid = q_single.interface_element_ids[0]
self.assertEqual(str(type(form[eid])),
"<class 'wtforms.fields.core.SelectField'>")
self.assertEqual(form[eid].choices,
[(0, 'Unspecified'),
(1, 'Did not complete high school'),
(2, 'High School or GED equilivant'),
(3, 'Some college or technical school'),
(4, "Associate's degree"), (5, "Bachelor's degree"),
(6, 'Some graduate school or professional'),
(7, 'Graduate or Professional degree')])
def get_form(self, **kwargs):
def validate_formdata_test(form, field):
if field.data != 'foobar':
raise ValidationError('error')
def validate_kwargs_test(form, field):
if field.data != 'batz':
raise ValidationError('error')
return BaseForm(
{
'test_fd': StringField(validators=[validate_formdata_test]),
'test_kwargs': StringField(validators=[validate_kwargs_test]),
'other_prop': StringField()
}, **kwargs)
def test_create(self):
q_text = QuestionText(98, 'Pregnancy')
self.assertEqual(q_text.id, 98)
self.assertEqual(q_text.group_name, 'Pregnancy')
self.assertEqual(q_text.set_response, None)
self.assertEqual(q_text.response_type, 'TEXT')
self.assertEqual(q_text.question, 'Pregnancy due date:')
self.assertEqual(q_text.american_question, 'Pregnancy due date:')
self.assertEqual(q_text.triggers, tuple())
self.assertEqual(q_text.qid, 'Pregnancy_98')
self.assertEqual(q_text.interface_element_ids, ['Pregnancy_98_0'])
# Test rendering of form object
form = BaseForm(
{q_text.interface_element_ids[0]: q_text.interface_elements[0]})
eid = q_text.interface_element_ids[0]
self.assertEqual(str(type(form[eid])),
"<class 'wtforms.fields.simple.TextAreaField'>")
def test_create(self):
q_string = QuestionString(127, 'PetName')
self.assertEqual(q_string.id, 127)
self.assertEqual(q_string.group_name, 'PetName')
self.assertEqual(q_string.set_response, None)
self.assertEqual(q_string.response_type, 'STRING')
self.assertEqual(q_string.question, 'Name')
self.assertEqual(q_string.american_question, 'Name')
self.assertEqual(q_string.triggers, tuple())
self.assertEqual(q_string.qid, 'PetName_127')
self.assertEqual(q_string.interface_element_ids, ['PetName_127_0'])
# Test rendering of form object
form = BaseForm({
q_string.interface_element_ids[0]:
q_string.interface_elements[0]
})
eid = q_string.interface_element_ids[0]
self.assertEqual(str(type(form[eid])),
"<class 'wtforms.fields.simple.TextField'>")
def test_create_triggers(self):
q_single = QuestionSingle(20, 'dog')
self.assertEqual(q_single.id, 20)
self.assertEqual(q_single.group_name, 'dog')
self.assertEqual(q_single.set_response, None)
self.assertEqual(q_single.response_type, 'SINGLE')
self.assertEqual(q_single.question, 'Do you have a dog(s)?')
self.assertEqual(q_single.american_question, 'Do you have a dog(s)?')
self.assertEqual(q_single.triggers, {101: [1], 105: [1]})
self.assertEqual(q_single.qid, 'dog_20')
self.assertEqual(q_single.interface_element_ids, ['dog_20_0'])
# Test form object
form = BaseForm({
q_single.interface_element_ids[0]:
q_single.interface_elements[0]
})
eid = q_single.interface_element_ids[0]
self.assertEqual(str(type(form[eid])),
"<class 'wtforms.fields.core.SelectField'>")
self.assertEqual(form[eid].choices, [(0, 'Unspecified'), (1, 'Yes'),
(2, 'No')])
def __init__(self, req=None):
if req is None:
req = request
self._request = req
self.errors = {}
fields = {}
for name, validators in self.headers.items():
fields[name] = Field(validators=validators)
self._headers_form = BaseForm(fields)
fields.clear()
for name, validators in self.args.items():
fields[name] = Field(validators=validators)
self._args_form = BaseForm(fields)
fields.clear()
for name, validators in self.form.items():
fields[name] = Field(validators=validators)
self._form_form = BaseForm(fields)
fields.clear()
fields['_jsonschema'] = Field(validators=self.json)
self._json_form = BaseForm(fields)
def test_automatic_wrapping(self):
def _check(formdata):
self.assertTrue(isinstance(formdata, WebobInputWrapper))
form = BaseForm({'a': SneakyField(_check)})
form.process(self.filled_mdict)
def test_automatic_wrapping(filled_mdict):
def _check(formdata):
assert isinstance(formdata, WebobInputWrapper)
form = BaseForm({"a": SneakyField(_check)})
form.process(filled_mdict)
class Input(object):
headers = {}
args = {}
form = {}
json = []
def __init__(self, req=None):
if req is None:
req = request
self._request = req
self.errors = {}
fields = {}
for name, validators in self.headers.items():
fields[name] = Field(validators=validators)
self._headers_form = BaseForm(fields)
fields.clear()
for name, validators in self.args.items():
fields[name] = Field(validators=validators)
self._args_form = BaseForm(fields)
fields.clear()
for name, validators in self.form.items():
fields[name] = Field(validators=validators)
self._form_form = BaseForm(fields)
fields.clear()
fields['_jsonschema'] = Field(validators=self.json)
self._json_form = BaseForm(fields)
def validate(self):
success = True
self._headers_form.process(self._request.headers)
if not self._headers_form.validate():
success = False
self.errors['headers'] = self._headers_form.errors
self._args_form.process(self._request.args)
if not self._args_form.validate():
success = False
self.errors['query_string'] = self._args_form.errors
self._form_form.process(self._request.form)
if not self._form_form.validate():
success = False
self.errors['form'] = self._form_form.errors
self._json_form.process(MultiDict(
dict(_jsonschema=self._request.get_json(force=True, silent=True))),
coerse=False)
if not self._json_form.validate():
success = False
self.errors['json'] = self._json_form.errors
return success
def model_as_form(model, initObj=None, ignore=[], override={}):
"""
Will take a model (non instantiated) object and produce a ``WTForm`` Form instance, this function only works one-way.
``model_as_form`` can take three parameters:
- ``initObj`` - If you want to inittialise the form with data, pass it an instance of the model in question and it will do it's best to instantiate it
- ``ignore`` - If you want to exclude a list of fields from the automated conversion you can specify them as a list of strings corresponding to the name of the field in your model
- ``override`` - To specify a custom wtForm field type, pass these as a dictionary of ``{"field name":FieldType,}``
*note*: The override function takes either classes or instantiated objects, so if you want to pass through custom validators
as part of the override, simply specify them in the override as if you would in a standard Form definition.
**Usage:** ::
from Mojo.Forms.MojoFormHelper import model_as_form
# Let's get some data from our imaginary blog app
posts = yield gen.Task(BlogPost.find_async, {'published':True}, sort=[('date_published',1)])
a_post = posts[0]
# Define a custom override set, the first is a base class,
# the second is an instance with my custom validators:
overrides = {'post_body': TextAreaField,
'post_intro': TextAreaField('Your intro text', [validators.required(),
validators.length(max=10)]}
# Create the form - we will ignore tags and
# comments (these are Lists, and not implemented),
# and override with our custom fields (StringFields are by
# default TextFields, but we want TextAreas):
thisForm = model_as_form(BlogPost, initObj=a_post, ignore=['tags', 'comments'], override=overrides)
# ...Now do something with the form
The system will automatically transform required model fields to required Form fields, no other validation checks are
passed through yet.
For the 'friendly name' o your form field, Mojo will use the ``friendly`` Mojo Model Form parameter, if none is present,
Mojo will use the name of the Modle Field.
"""
if model:
form_fields = {}
if not initObj:
ignore.append('_id')
class_attrs = [attr for attr in model.__dict__ if '__' not in attr]
for c in class_attrs:
if c not in EXCLUSIONS:
form_validators = []
field_type = type(model.__dict__[c]).__name__
field_name = str(c)
if model.__dict__[c].friendly == '':
friendly_name = model.__name__
else:
friendly_name = unicode(model.__dict__[c].friendly)
if model.__dict__[c].allow_empty:
form_validators.append(validators.required())
new_form_field = None
if field_name not in ignore:
if field_name not in override.keys():
if field_type in fieldMap.keys():
new_form_field = fieldMap[field_type](
friendly_name, form_validators)
else:
raise NotImplementedError(
'This field (%s) has not been implemented, please add it manually using override.'
% field_type)
else:
#Now for some magic, this makes sure overrides can provide field instances and custom validators
if inspect.isclass(override[field_name]):
#instantiate a fresh object
new_form_field = override[field_name](
friendly_name, form_validators)
else:
#Pass everything through
new_form_field = override[field_name]
if new_form_field:
if field_name == '_id': field_name = 'id'
form_fields[field_name] = new_form_field
new_form = BaseForm(form_fields)
if initObj:
temp_data = dict(initObj)
if '_id' in temp_data.keys():
#Need to get rid of _id as it clashes with WTForms
temp_data['id'] = temp_data['_id']
del temp_data['_id']
for key, value in temp_data.iteritems():
if key not in ignore:
new_form[key].data = value
return new_form
else:
return None
class MarkDistributionForm:
def __init__(self, course_id, questions, total_marks):
course = Course.query.filter(Course.id == course_id).first()
units = Unit.query.filter(Unit.course == course).all()
question_translator = defaultdict(dict)
form_fields = {}
validators = defaultdict(list)
flatten_data = defaultdict(list)
flatten_data["units"].extend([0] * len(units))
flatten_data["cognitive"].extend([0] * len(CognitiveEnum.__members__))
flatten_data["difficulty"].extend([0] *
len(DifficultyEnum.__members__))
flatten_data["questions"].extend([0] * sum(questions))
for unit in units:
field = f"Unit:{unit.chapter_no:02d}"
form_fields.update(
{field: IntegerField(field, validators=[DataRequired()])})
validators["units"].append(field)
for c_level in CognitiveEnum.__members__:
form_fields.update(
{c_level: IntegerField(c_level, validators=[DataRequired()])})
validators["cognitive"].append(c_level)
for d_level in DifficultyEnum.__members__:
form_fields.update(
{d_level: IntegerField(d_level, validators=[DataRequired()])})
validators["difficulty"].append(d_level)
idx = 0
for question_no, subquestions in enumerate(questions):
for subquestion in range(subquestions):
field = f"Que.{question_no + 1}.{ascii_uppercase[subquestion]}"
form_fields.update(
{field: IntegerField(field, validators=[DataRequired()])})
validators["questions"].append(field)
question_translator[question_no +
1][ascii_uppercase[subquestion]] = idx
idx += 1
for i, validator in validators.items():
validators[i] = IsSumOf(*validator)
form_fields.update({
"total_marks":
IntegerField("total_marks",
validators=[DataRequired(),
*validators.values()]) # *validators
})
self.form = BaseForm(form_fields)
self.flatten_data = flatten_data
self.course = course
self.total_marks = total_marks
self.unit_field_regex = re.compile(r"Unit:(\d\d)")
self.question_field_regex = re.compile(r"Que.(\d+).([A-Z])")
self.question_translator = question_translator
@property
def data(self):
for constraint in self.fields:
for field in self.fields[constraint]:
self.flatten_data[constraint][self.translate(
constraint, field.name)] = int(field.data)
return self.flatten_data
@property
def fields(self):
fields = defaultdict(list)
for field in self.form._fields:
if "Unit" in field:
fields["units"].append(self.form._fields[field])
elif "Que" in field:
fields["questions"].append(self.form._fields[field])
elif field in CognitiveEnum.__members__:
fields["cognitive"].append(self.form._fields[field])
elif field in DifficultyEnum.__members__:
fields["difficulty"].append(self.form._fields[field])
return fields
def translate(self, constraint, field):
if constraint == "cognitive":
return CognitiveEnum.__members__[field].value - 1
if constraint == "difficulty":
return DifficultyEnum.__members__[field].value - 1
if constraint == "units":
return int(self.unit_field_regex.search(field).group(1)) - 1
if constraint == "questions":
matched = self.question_field_regex.search(field)
return self.question_translator[int(
matched.group(1))][matched.group(2)]
def validate_on_submit(self):
self.form.process(request.form)
self.form._fields["total_marks"].process_data(self.total_marks)
return request.method == "POST" and self.form.validate()
def release_template_form(path, containers, formdata):
from lxml import etree
tree = etree.parse(path)
formfields = {}
spec = {"env": [], "ports": [], "folders": [], "links": []}
for field in tree.iterfind(".//environment/*"):
spec["env"].append(field.tag)
default = field.text or None
formfields[field.tag] = fields.StringField(field.tag, validators=[validators.required()], default=default)
for field in tree.iterfind(".//shared-folders/folder"):
name = field.attrib["mountpoint"]
default = field.attrib.get("local", None)
spec["folders"].append(name)
formfields[name] = fields.StringField(name, validators=[validators.required()], default=default)
for field in tree.iterfind(".//ports/expose"):
type = field.attrib["type"]
container = field.attrib["container"]
label = "{}/{}".format(type, container)
name = "port_{}_{}".format(type, container)
spec["ports"].append((name, type, container))
formfields[name + "_host_ip"] = fields.StringField(
label, validators=[validators.Optional(), validators.IPAddress()]
)
formfields[name + "_host_port"] = fields.IntegerField(
label, validators=[validators.Optional(), validators.NumberRange(0, 65535)]
)
containers_by_repo = {}
for c in containers:
try:
repo, tag = c["Image"].split(":")
except ValueError:
continue
for name in c["Names"]:
if "/" not in name[1:]:
label = "{} ({})".format(name[1:], tag)
containers_by_repo.setdefault(repo, []).append((name, label))
for field in tree.iterfind(".//links/*"):
spec["links"].append(field.tag)
default = field.attrib.get("container", None)
if "repository" in field.attrib:
choices = containers_by_repo.get(field.attrib["repository"], [])
formfields[field.tag] = fields.SelectField(
field.tag, validators=[validators.required()], default=default, choices=choices
)
else:
formfields[field.tag] = fields.StringField(field.tag, validators=[validators.required()], default=default)
form = BaseForm(formfields)
form.process(formdata)
return form, spec
def new_form(self, paper=None):
form = BaseForm(fields=self.Fields)
form.process()
if paper:
self.inject_data(form, paper)
return form
def test_automatic_wrapping(self):
def _check(formdata):
self.assert_(isinstance(formdata, WebobInputWrapper))
form = BaseForm({'a': SneakyField(_check)})
form.process(self.filled_mdict)
class FormCreator:
def __init__(self, method, action, csrf=False):
self.form = BaseForm({})
self.elements = dict()
self.method = method
self.action = action
if not csrf:
self.form._csrf = None
def set_field(self, element):
self.form[element.identifier] = {
"StringField":
StringField(element.identifier, element.validators),
"IntegerField":
IntegerField(element.identifier, element.validators),
"SelectField":
SelectField(element.identifier,
element.validators,
choices=element.choices),
"BooleanField":
BooleanField(element.identifier, element.validators),
"RadioField":
RadioField(element.identifier, element.validators)
}[element.element_type]
def build_form(self):
for identifier, element in self.elements.items():
self.set_field(element)
def process_form(self, request):
self.form.process(request.form)
return self.form
def add_text_field(self, name, required=False):
try:
self.elements[name] = FormElement(
"StringField", name, [DataRequired()] if required else [])
except KeyError as exception:
print(exception)
def add_number_field(self, name, required=False):
try:
self.elements[name] = FormElement(
"IntegerField", name, [DataRequired()] if required else [])
except KeyError as exception:
print(exception)
def add_select_field(self, name, required=False, options=None):
if options is None:
options = [("select", "Select")]
try:
self.elements[name] = FormElement(
"SelectField",
name, [DataRequired()] if required else [],
choices=options)
except KeyError as exception:
print(exception)
def add_checkbox_field(self, name, required=False):
try:
self.elements[name] = FormElement(
"BooleanField", name, [DataRequired()] if required else [])
except KeyError as exception:
print(exception)
def add_radio_field(self, name, required=False):
try:
self.elements[name] = FormElement(
"RadioField", name, [DataRequired()] if required else [])
except KeyError as exception:
print(exception)
def load_elements_from_form(self, base_form):
for field in base_form:
self.form[field.name] = field
def create_form(prefix='', **kwargs):
form = BaseForm(fields, prefix=prefix)
form.process(**kwargs)
return form
