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