def edit_quiz(quiz_id):
"""
Changes quiz info
"""
try:
body = request.get_json()
name = body["name"]
start_date = body["start_date"]
end_date = body["end_date"]
description = body["description"]
language = body["language"]
if not models.check_dates(
start_date, end_date) and not models.check_languages(language):
return bad_request()
models.edit_quiz(quiz_id, name, start_date, end_date, description,
language)
except KeyError:
return bad_request()
except Exception as e:
print(e)
return server_error()
return success()
def activate():
"""
Activates a student account and set's there password
"""
try:
body = request.get_json()
activate_token = body["activate_token"]
password = body["password"]
if len(password) < 3 or len(password) > 50:
return bad_request()
if not models.token_exists(activate_token):
return bad_request()
student_hash = models.create_hash(password)
models.save_hash(student_hash, activate_token)
except KeyError:
return bad_request()
except Exception as e:
print(e)
return server_error()
return created()
def parse():
"""
Parses an excel spreadsheet and returns students
"""
try:
if "excel_doc" not in request.files:
return bad_request()
excel_doc = request.files["excel_doc"]
if not models.allowed_file(excel_doc.filename):
return bad_request()
file_path = models.save_excel_doc(excel_doc)
students = models.parse_students(file_path)
os.remove(file_path)
except ValueError as e:
return bad_request()
except Exception as e:
print(e)
return server_error()
return success(students)
def create_quiz(course_id):
"""
Creates a quiz
"""
try:
body = request.get_json()
name = body["name"]
start_date = body["start_date"]
end_date = body["end_date"]
description = body["description"]
language = body["language"]
if not models.check_dates(
start_date, end_date) and not models.check_languages(language):
return bad_request()
quiz_id = models.insert_quiz(course_id, name, start_date, end_date,
description, language)
except KeyError:
return bad_request()
except Exception:
return server_error()
return created({"quiz_id": quiz_id})
def precheck(qc_id, question_id):
"""
Adds one question to a quiz
"""
try:
student_id = request.student_id if hasattr(
request, "student_id") else str(uuid.uuid4().hex)
body = request.get_json()
code = body["code"]
filename = models.precheck_file_name(student_id, qc_id, question_id)
filepath = os.path.join("app", "packages", "quizzes", "question_files",
filename)
with open(filepath, "w") as f:
f.write(code)
bashCommand = "pylint --errors-only {}".format(filepath)
process = subprocess.Popen(bashCommand.split(), stdout=subprocess.PIPE)
process.wait()
output, _ = process.communicate()
os.remove(filepath)
except KeyError:
return bad_request()
except Exception as e:
print(e)
return server_error()
return success({"output": output.decode()})
def signin():
"""
Signs in either a teacher or a student
"""
try:
body = request.get_json()
email = body["email"]
password = body["password"]
# Returns the user_id (either teacher or student) and if the user is a teacher or a student
user_id, is_teacher = models.id_from_credentials(email, password)
if not user_id:
return bad_request()
token = models.create_token()
models.save_token(token, user_id, is_teacher)
except KeyError:
return bad_request()
except Exception as e:
print(e)
return server_error()
return success({
"token": token,
"teacher_id" if is_teacher else "student_id": user_id
})
def delete_course(course_id):
"""
Deletes a course
"""
try:
models.delete_course(course_id)
except Exception:
return server_error()
return success()
def delete_class(class_id):
"""
Deletes a class
"""
try:
models.delete_class(class_id)
except Exception:
return server_error()
return success()
def get_students(class_id):
"""
Gets all the students of a class
"""
try:
students = models.get_students(class_id)
except Exception:
return server_error()
return success({"students": students})
def get_languages():
"""
Gets all supported programming languages
"""
try:
languages = models.get_languages()
return success(languages)
except Exception as e:
print(e)
return server_error()
def delete_test_case(quiz_id, question_id, test_id):
"""
Creates a test case
"""
try:
models.delete_test_case(test_id)
except Exception:
return server_error()
return success()
def me():
"""
Returns student data if they are logged in
"""
try:
student_data = models.get_student_data(request.student_id)
except Exception as e:
print(e)
return server_error()
return success(student_data)
def delete_question(quiz_id, question_id):
"""
Deletes a question from a quiz
"""
try:
models.delete_question(quiz_id, question_id)
except Exception as e:
print(e)
return server_error()
return success()
def get_classes():
"""
Gets all of a teachers classes
"""
try:
teacher_id = request.teacher_id
classes = models.get_classes(teacher_id)
except Exception:
return server_error()
return success({"classes": classes})
def get_free_quizzes():
"""
Gets all the free quizzes
"""
try:
free_quizzes = models.get_free_quizzes()
except Exception as e:
print(e)
return server_error()
return success(free_quizzes)
def get_quizzes():
"""
Gets all the quizzes that the teacher owns
"""
try:
quizzes = models.get_quizzes(request.teacher_id)
except Exception as e:
print(e)
return server_error()
return success(quizzes)
def check(qc_id, question_id):
"""
Checks students code for a particular question against test cases
"""
try:
# If user is not a student, assign them random uuid for filename
student_id = request.student_id if hasattr(
request, "student_id") else str(uuid.uuid4().hex)
body = request.get_json()
code = body["code"]
code_runner = CodeRunner(student_id, qc_id, question_id)
code_runner.write_code(code) # Writes students code to file
test_cases = models.get_test_cases(question_id)
# question_worth, total_negated and last_attempt_wrong only valid for free quiz!
results, question_worth, total_negated, last_attempt_wrong = code_runner.run(
test_cases)
code_runner.remove_code() # Deletes students code
# If user is not student or the quiz is a free quiz, then don't save their attempt
if hasattr(request, "is_free_quiz"):
return success({
"results": results,
"question_worth": question_worth,
"total_negated": total_negated,
"last_attempt_wrong": last_attempt_wrong
})
attempt_id = models.insert_attempt(question_id, student_id)
models.insert_test_cases(results, attempt_id)
question_worth, total_negated, last_attempt_wrong = models.get_mark_worth(
question_id, student_id)
except KeyError as e:
print(e)
return bad_request()
except Exception as e:
print(e)
return server_error()
return success({
"results": results,
"question_worth": question_worth,
"total_negated": total_negated,
"last_attempt_wrong": last_attempt_wrong
})
def me():
"""
Returns teachers data if they are logged in
"""
print("Hello")
try:
teacher_data = models.get_teacher_data(request.teacher_id)
except Exception as e:
print(e)
return server_error()
return success(teacher_data)
def delete_student(class_id, student_id):
"""
Deletes a student from a class
"""
try:
if not models.check_student(class_id, student_id):
return not_found()
models.delete_student(class_id, student_id)
except Exception:
return server_error()
return success()
def delete_class(course_id, class_id):
"""
Deletes a class from a course
"""
try:
teacher_id = request.teacher_id
if not models.class_exists(teacher_id, class_id):
return not_found()
models.delete_class(course_id, class_id)
except Exception:
return server_error()
return success()
def get_quiz_template(quiz_id):
"""
Gets quiz information along with questions for one quiz
"""
try:
quiz = models.get_quiz_template(quiz_id)
questions = models.get_questions(quiz_id)
questions_with_tests = models.get_tests(questions, None)
except Exception as e:
print(e)
return server_error()
return success({"quiz": quiz, "questions": questions_with_tests})
def get_quiz_instance(qc_id):
"""
Gets quiz information along with questions for one quiz
"""
try:
quiz = models.get_quiz_instance(qc_id)
questions = models.get_questions(quiz["quiz_id"])
questions_with_tests = models.get_tests(
questions,
request.student_id if hasattr(request, "student_id") else None)
except Exception as e:
print(e)
return server_error()
return success({"quiz": quiz, "questions": questions_with_tests})
def questions(quiz_id):
"""
Adds one question to a quiz
"""
try:
json = request.get_json()
description = json["description"]
question_id = models.add_question(quiz_id, description)
except KeyError:
return bad_request()
except Exception as e:
return server_error()
return created({"question_id": question_id})
def update_question(quiz_id, question_id):
"""
Updates a question from a quiz
"""
try:
json = request.get_json()
question_description = json["question_description"]
models.update_description(question_description, question_id)
except (KeyError, ValueError):
return bad_request()
except Exception as e:
return server_error()
return success()
def get_course(course_id):
"""
Gets information on one course
"""
try:
name = models.get_name(course_id)
quizzes = models.get_quizzes(course_id)
classes = models.get_classes(course_id)
except Exception as e:
print(e)
return server_error()
return success({
"course_id": course_id,
"course_name": name,
"course_quizzes": quizzes,
"course_classes": classes
})
def signout():
"""
Signs a teacher or student out by changing their token to null
"""
try:
if hasattr(request, "teacher_id"):
user_id = request.teacher_id
is_teacher = True
else:
user_id = request.student_id
is_teacher = False
models.remove_token(user_id, is_teacher)
except Exception as e:
print(e)
return server_error()
return success()
def change_class(class_id):
"""
Changes information about a class
"""
try:
body = request.get_json()
name = body["name"]
if not name:
return bad_request()
models.change_class(class_id, name)
except KeyError:
return bad_request()
except Exception:
return server_error()
return success()
def change_course(course_id):
"""
Changes name of a course
"""
try:
body = request.get_json()
name = body["name"]
if not name:
return bad_request()
models.change_course(course_id, name)
except KeyError:
return bad_request()
except Exception:
return server_error()
return success()
def create():
"""
Creates a class
"""
try:
body = request.get_json()
teacher_id = request.teacher_id
name = body["name"]
if not name:
return bad_request()
class_id = models.insert_class(teacher_id, name)
except KeyError:
return bad_request()
except Exception:
return server_error()
return created({"class_id": class_id})
def create_test_case(quiz_id, question_id):
"""
Creates a test case
"""
try:
json = request.get_json()
test_input = json["test_input"]
test_expected = json["test_expected"]
test_id = models.create_test_case(question_id, test_input,
test_expected)
except (KeyError, ValueError):
return bad_request()
except Exception as e:
print(e)
return server_error()
return created({"test_id": test_id})
