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