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 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)
def new_form(self, paper=None):
form = BaseForm(fields=self.Fields)
form.process()
if paper:
self.inject_data(form, paper)
return form
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 create_form(prefix='', **kwargs):
form = BaseForm(fields, prefix=prefix)
form.process(**kwargs)
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)
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
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
