def get_task_status(task_id):
get_user_cookie(True)
task = process_audio_stats.AsyncResult(task_id)
if not task:
raise NotFoundError()
response = {"state": task.state, "result": {}}
if task.state == "PENDING":
response["current"] = 0
response["total"] = 100
response["status"] = "pending"
elif task.state != "FAILURE":
response["current"] = task.info.get("current", 0)
response["total"] = task.info.get("total", 100)
response["status"] = task.info.get("status", "")
if "result" in task.info:
response["result"] = task.info["result"]
else:
response["current"] = 100
response["total"] = 100
response["status"] = str(task.info)
return response, 200
def get_results_user():
user_id = get_user_cookie()
if not user_id:
raise ForbiddenError()
user_questions = get_questions_for_user(user_id)
if not user_questions:
raise NotFoundError()
aggd = []
for q in user_questions:
stats = q["stats"]
aggd.append(stats)
num_pauses = 0
wpm = 0
for each in aggd:
num_pauses += int(each["number_of_pauses"])
wpm += int(each["words_per_min"])
return {
"results": {
"words_per_minute": {
"total": wpm,
"avg": wpm / len(aggd)
},
"number_of_pauses": {
"total": num_pauses,
"avg": num_pauses / len(aggd),
},
},
}
def get_user_questions():
"""
GET /api/questions
Fetch questions for the current user if cookie is found, else return a 404
"""
user_id = get_user_cookie(True)
questions = get_questions_for_user(user_id)
if not questions:
raise NotFoundError()
return {"questions": questions}, 200
def submit_answer(question_id):
"""
1. Extract webm audio file and convert to wav file
2. Upload to a the users folder in cloud storage with name as question id
"""
user_id = get_user_cookie(True)
# Extract file and sanity check
webm_file = request.files["audio"]
if webm_file.filename.split(".")[1] != "webm":
raise BadRequestError()
blob_name = question_id
gcs_file_path = f"{user_id}/{blob_name}{WEBM_EXT}"
local_file_path = f"{TMP_DIR}/{blob_name}"
webm_file_path = f"{local_file_path}{WEBM_EXT}"
app.logger.info("Saving answer .webm for question[%s] by user[%s]",
question_id, user_id)
webm_file.save(webm_file_path)
# upload to bucket
app.logger.info(
"Uploading answer .webm for question[%s] by user[%s] to %s",
question_id,
user_id,
get_blob_url(GCS_BUCKET, gcs_file_path),
)
upload_file(GCS_BUCKET, gcs_file_path, webm_file_path)
# add file path to question doc in db
question = add_answer(question_id, gcs_file_path)
# Trigger task and obtain task id
process_task = process_audio_stats.delay(question["answer"])
task_id = process_task.id
app.logger.info("Triggered processing stats task[%s]", task_id)
# cleanup webm and wav file in temp directory
delete_local_file(webm_file_path)
# delete_local_file(wav_file_path)
app.logger.info(
"Cleaned up temp answer files for question[%s] by user[%s]",
question_id,
user_id,
)
return {
"question": question,
"task_id": task_id,
"poll_url": url_for("get_task_status", task_id=task_id),
}, 201
def get_results_question(question_id):
user_id = get_user_cookie(True)
question = get_question_by_id(question_id)
if not question:
raise NotFoundError()
if question["user_id"] != user_id:
app.logger.warning(
"Revoked unauthorized access to question[%s] by user[%s]",
question_id,
user_id,
)
raise ForbiddenError()
return {"result": question["stats"]}, 200
def get_question(question_id):
"""
GET /api/questions/<question_id>
Fetch information about a specific question matching question_id, else return a 404
"""
user_id = get_user_cookie(True)
question = get_question_by_id(question_id)
if not question:
raise NotFoundError()
if question["user_id"] != user_id:
app.logger.warning(
"Revoked unauthorized access to question[%s] by user[%s]",
question_id,
user_id,
)
raise ForbiddenError()
return {"question": question}, 200
def save_questions():
"""
POST /api/questions
Submit up to five questions at a time. Identifies user via cookie
in the request else creates new user id and sends cookie in response
"""
user_id = get_user_cookie()
if not user_id:
user_id = create_new_user()
app.logger.info("Created new user[%s]", user_id)
after_this_request(set_user_cookie(user_id))
body = request.get_json(force=True)
questions = body["questions"]
questions = list(
map(lambda desc: create_question(desc, user_id), questions))
question_ids = bulk_create_questions(questions)
app.logger.info("Created questions%s for user[%s]", str(question_ids),
user_id)
return {"questions": question_ids}, 201