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 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 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)
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()