def show_question(request, student_id, exam_id, question_id):
#if Exam(connection).is_exam_active(exam_id) != True:
# return redirect('/{student_id}/tests/{exam_id}'.format(student_id = student_id, exam_id = exam_id))
if request.method == "POST":
variable = request.POST['text_area']
print(variable)
return redirect("/{student_id}/tests/{exam_id}/{question_id}".format(
student_id=student_id,
exam_id=exam_id,
question_id=question_id + 1))
else:
time_left = Exam(connection).get_exam_time_left(7)
question, question_amount = Question(connection).get_question(
exam_id, question_id)
return render(
request, "question.html", {
"question_amount": question_amount,
"range": range(1, question_amount + 1),
"student_id": student_id,
"exam_id": exam_id,
'question': question,
'time': time_left
})
def parse(self, **kwargs):
worksheet = GoogleSheetsParser.get_worksheet(self, '1iw-Wv4omM8GoAhdF3yKBKXQzECZBFClRJIVsOrqcynU')
i = 2
while True:
values_list = worksheet.row_values(i)
i += 1
if not values_list[0]:
break
try:
exam = Exam.objects.get(
name=values_list[0]
)
except ObjectDoesNotExist:
exam = Exam(
name=values_list[0]
)
self.exam_count += 1
exam.save()
return [
'New Exams: ' + str(self.exam_count),
]
def add():
data = request.json or request.data or request.form
res_code = 200
res = dict(status="fail")
name = data.get("name")
branch_id = data.get("branch_id")
for key in ("name", "branch_id"):
val = data.get(key)
if not val:
res["statusText"] = errors.BLANK_VALUES_FOR_REQUIRED_FIELDS.text
res["statusData"] = errors.BLANK_VALUES_FOR_REQUIRED_FIELDS.type(
[key])
return jsonify(res), res_code
exam = Exam.query.filter_by(branch_id=branch_id, name=name).first()
if exam:
res["statusText"] = errors.CUSTOM_ERROR.text
res["statusData"] = errors.CUSTOM_ERROR.type(
'Exam with name "%s" already exists' % exam.name)
return jsonify(res), res_code
exam = Exam(name=name, branch_id=branch_id)
db.session.add(exam)
db.session.commit()
res["status"] = "success"
res["exam"] = exam.serialize()
return jsonify(res), res_code
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('name')
parser.add_argument('description')
parser.add_argument('roles', type=str)
parser.add_argument('time', type=int)
parser.add_argument('attempts', type=int)
parser.add_argument('file',
location='files',
type=werkzeug.datastructures.FileStorage)
args = parser.parse_args()
file = args['file']
exam = Exam(**args)
# Check if file exists, rename if so
filename = werkzeug.utils.secure_filename(file.filename)
if os.path.isfile(f'uploads/{filename}'):
filename = str(int(datetime.now().timestamp())) + "-" + filename
exam.json_file = filename
exam.roles = args['roles']
file.save(f"uploads/{filename}")
exam.save()
return exam
def show_tests(request, user_id):
exams = Exam(connection).get_exam_details(user_id)
return render(request, "show_tests.html", {
"test_details": exams[0],
"time_remain": exams[1],
"index": len(exams[0])
})
def test_detail(request, student_id, exam_id):
test_details = Exam(connection).single_exam_details(exam_id)
print(test_details)
student = Student(connection).get_student_by_id(student_id)
#(3, 'Midterm 3', datetime.datetime(2020, 4, 7, 20, 0), 120, '*****@*****.**', 'ENGR 101')
return render(request, "test.html", {
"test_detail": test_details,
"student": student
})
def create_fixture_exams(count=10):
print(f'Inserting {count} exams...')
teachers = Teacher.query.all()
exams = [
Exam(**generate_random_exam(random.choice(teachers).id))
for _ in range(count)
]
if Exam.persist_changes({'insert': exams}):
print(f'The {len(exams)} exams were added...')
else:
print(f'Cannot insert exams.')
def test_delete_exam_teacher(self):
"""Teacher archiving their exam"""
exam = Exam.query.first()
new_exam_dict = generate_random_exam(exam.author_id)
new_exam = Exam(**new_exam_dict)
new_exam.insert()
try:
teacher = Teacher.get_by_id(new_exam.author_id)
token = generate_user_token(teacher.username, TEACHER_PERMISSIONS)
res = self.client.delete(f'/api/v1/exams/{new_exam.id}',
headers={
'Content-Type': 'application/json',
'Authorization': f'bearer {token}'})
self.assertEqual(res.status_code, 200, res.get_json())
data = res.get_json()
self.check_fields_list(data, ['success', 'deleted'])
self.assertTrue('success')
self.assertEqual(data['deleted'], new_exam.id)
self.assertIsNone(Exam.get_by_id(new_exam.id))
finally:
new_exam.delete()
def paper_upload():
data = MultiDict(mapping=request.json)
form = PaperUploadForm(data)
if not form.validate():
raise FormValidateError(form.errors)
# todo 插入数据库
attachments = request.json.get('attachments', [])
exam = Exam(name=form.name.data, section=form.section.data, subject=form.subject.data, paper_types=form.paper_types.data, \
province_id=form.province_id.data, city_id=form.city_id.data, area_id=form.area_id.data,\
school_id=form.school_id.data,
exam_date=form.exam_date.data,
year=form.year.data,
grade=form.grade.data,
is_fast=form.is_fast.data,
state=0,
attachments=attachments,
upload_user=g.user.id,
order=PAPER_TYPE_ORDER[form.paper_types.data])
result = exam.save()
ExamLog.log(exam.id, g.user.id, EXAM_STATUS['未审核'], 'UPLOAD')
if result.id is not None:
return render_api({})
raise JsonOutputException('添加失败')
def exam(user):
if request.method == 'POST':
try:
metric_id = request.data['metricId']
visit_id = request.data['visitId']
value = request.data['value']
except KeyError:
return {}, 400
metric = Metric.query.filter_by(id=metric_id)
visit = Visit.query.filter_by(id=visit_id)
if not user.admin:
metric = metric.filter_by(gender=user.gender)
visit = visit.filter_by(user=user)
metric = metric.first()
visit = visit.first()
if visit is None or metric is None:
return {}, 400
exam = Exam(value=value, metric=metric, visit=visit)
exam.save()
visit.date_modified = exam.date_modified
visit.save()
response = jsonify({
'id': exam.id,
'value': exam.value,
'dateCreated': exam.date_created,
'dateModified': exam.date_modified,
'visitId': exam.visit.id,
'metricId': exam.metric.id,
'metricName': exam.metric.name
})
response.status_code = 201
return response
else:
try:
visit_id = request.values['visitId']
except KeyError:
if user.admin:
exams = Exam.get_all()
else:
visit_ids = Visit.query.filter_by(user=user).with_entities(
Visit.id)
exams = Exam.query.filter(Exam.visit_id.in_(visit_ids))
else:
visit = Visit.query.filter_by(id=visit_id)
if not user.admin:
visit = visit.filter_by(user=user)
visit = visit.first()
exams = Exam.query.filter_by(visit=visit).order_by(
Exam.metric_id)
results = []
for exam in exams:
obj = {
'id': exam.id,
'value': exam.value,
'dateCreated': exam.date_created,
'dateModified': exam.date_modified,
'visitId': exam.visit.id,
'metricId': exam.metric.id,
'metricName': exam.metric.name
}
results.append(obj)
response = jsonify(results)
response.status_code = 200
return response
def data_entry():
import pprint
pprint.pprint(request.form)
qualifications_form = QualificationFormAdd()
qualifications_form.locale.choices = [('GB', 'GB'), ('DE', 'DE'),
('US', 'US')]
qualifications_form.year.choices = [('2015', '2015'), ('2014', '2014'),
('2013', '2013'), ('2012', '2012'),
('2011', '2011')]
board_form = BoardFormAdd()
board_form.locale.choices = [('GB', 'GB'), ('DE', 'DE'), ('US', 'US')]
subject_form = SubjectFormAdd()
exam_form = ExamFormAdd()
section_form = SectionFormAdd()
question_form = QuestionFormAdd()
if request.method == 'GET':
return render_template('data_entry.html',
user=current_user.name,
user_role=current_user.role.name,
qualifications_form=qualifications_form,
subject_form=subject_form,
board_form=board_form,
exam_form=exam_form,
section_form=section_form,
question_form=question_form)
if request.method == 'POST':
if qualifications_form.validate_on_submit():
new_qualification = Qualification(
name=qualifications_form.name.data,
locale=qualifications_form.locale.data,
year=qualifications_form.year.data,
num_students=qualifications_form.num_students.data)
db.session.add(new_qualification)
db.session.commit()
flash('Added Qualification: {0} {1} ({2})'.format(
new_qualification.name, new_qualification.year,
new_qualification.locale))
return redirect(url_for('data_entry'))
else:
utilities.flash_form_errors(qualifications_form)
if board_form.validate_on_submit():
new_board = Board(name=board_form.name.data,
locale=board_form.locale.data,
num_marking=board_form.num_marking.data)
db.session.add(new_board)
db.session.commit()
flash('Added Board: {0} ({1})'.format(new_board.name,
new_board.locale))
return redirect(url_for('data_entry'))
else:
utilities.flash_form_errors(board_form)
if subject_form.validate_on_submit():
new_subject = Subject(
name=subject_form.name.data,
qualification_id=subject_form.qualification.data.id,
board_id=subject_form.board.data.id,
is_compulsory=subject_form.is_compulsory.data,
is_higher=subject_form.is_higher.data,
perc_exam=subject_form.perc_exam.data,
total_marks=subject_form.total_marks.data,
num_modules=subject_form.num_modules.data,
num_students=subject_form.num_students.data)
db.session.add(new_subject)
db.session.commit()
flash('Added Subject: {0} | {1} {2} | {3} ({4})'.format(
new_subject.name, new_subject.qualification.name,
new_subject.qualification.year, new_subject.board.name,
new_subject.board.locale))
return redirect(url_for('data_entry'))
else:
utilities.flash_form_errors(subject_form)
if exam_form.validate_on_submit():
new_exam = Exam(subject_id=exam_form.subject.data.id,
name=exam_form.name.data,
marks=exam_form.marks.data,
total_num_q=exam_form.total_num_q.data,
required_num_q=exam_form.required_num_q.data,
time=exam_form.time.data,
datetime=exam_form.datetime.data,
num_retakes=exam_form.num_retakes.data)
db.session.add(new_exam)
db.session.commit()
flash('Added Exam: {0} | {1} | {2} {3} | {4} ({5})'.format(
new_exam.name, new_exam.subject.name,
new_exam.subject.qualification.name,
new_exam.subject.qualification.year,
new_exam.subject.board.name, new_exam.subject.board.locale))
return redirect(url_for('data_entry'))
else:
utilities.flash_form_errors(exam_form)
if section_form.validate_on_submit():
new_section = Section(exam_id=section_form.exam.data.id,
topic=section_form.topic.data,
marks=section_form.marks.data,
time=section_form.time.data)
db.session.add(new_section)
db.session.commit()
flash(
'Added Section: {0} | {1} | {2} | {3} {4} | {5} ({6})'.format(
new_section.topic, new_section.exam.name,
new_section.exam.subject.name,
new_section.exam.subject.qualification.name,
new_section.exam.subject.qualification.year,
new_section.exam.subject.board.name,
new_section.exam.subject.board.locale))
return redirect(url_for('data_entry'))
else:
utilities.flash_form_errors(section_form)
return redirect(url_for('data_entry'))
def exams(request):
from app.models import Course
display = Course.objects.filter(
student__user__username=request.user).exists()
if request.method == 'POST':
from app.forms import ExamForm
from app.models import Student, Subject, Exam, Course
form = ExamForm(request.POST)
if form.is_valid():
sameCourse = Course.objects.get(
student__user__username=request.user)
sameStudent = Student.objects.get(user__username=request.user)
sent_subject = request.POST['new_subject'].capitalize()
newSubject, created = Subject.objects.get_or_create(
name=sent_subject, course=sameCourse)
if created:
newSubject.save()
newGrade = request.POST['grade'] or None
newPassed = request.POST.get('passed', '') == 'on'
newDate = request.POST['date_passed'] or None
newExam = Exam(
student=sameStudent,
subject=newSubject,
grade=newGrade,
passed=newPassed,
date_passed=newDate,
)
newExam.save()
return render(
request, 'exams/exams.html', {
'msg':
'Exam Succesfully Added',
'newExamForm':
ExamForm(),
'exams':
Exam.objects.filter(student__user__username=request.user),
'display':
display
})
else:
return render(
request, 'exams/exams.html', {
'err':
'Invalid data',
'newExamForm':
form,
'exams':
Exam.objects.filter(student__user__username=request.user),
'display':
display
})
from app.models import Exam
from app.forms import ExamForm
exams = Exam.objects.filter(student__user__username=request.user)
return render(
request, 'exams/exams.html', {
'exams': exams,
'request': request,
'newExamForm': ExamForm(),
'display': display
})
