def get(self):
"""Get all quizzes"""
logs.debug_ ("_______________________________________________")
logs.debug_ ("QuizzesAPI get fn: %s" %(request))
userid, username = utls.get_user_from_hdr()
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException
('Error: No active session for this user found',
status_code=404))
return response
# Query from quiz table
query_obj = models.Quiz.query.order_by(models.Quiz.qzid).all()
if not query_obj:
response = handle_invalid_usage(InvalidUsageException
('Error: No quizzes found', status_code=404))
return response
# Return response
resource_fields = {'qzid':fields.Integer,
'title':fields.String
}
user = marshal(query_obj, resource_fields)
response = jsonify(user=user)
response.status_code = 200
logs.info_(response)
utls.display_tables()
return response
def get(self):
"""Get all quizzes"""
logs.debug_ ("_______________________________________________")
logs.debug_ ("QuizzesAPI get fn: %s" %(request))
# Query quizzes for this admin from quiz table
# Should that be the case or should admin be able to see
# other quizzes as well
userid, username = utls.get_user_from_hdr()
query_obj = models.Quiz.query.filter_by(userid=userid).all()
if not query_obj:
response = handle_invalid_usage(InvalidUsageException
('Error: No quizzes found', status_code=404))
return response
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException
('Error: No active session for this user found',
status_code=404))
return response
# Return response
resource_fields = {}
resource_fields['qzid'] =fields.Integer
resource_fields['title']=fields.String
resource_fields['difficulty_level'] =fields.String
resource_fields['text'] =fields.String
resource_fields['no_ques']=fields.Integer
quizzes = marshal(query_obj, resource_fields)
response = jsonify(quizzes=quizzes)
response.status_code = 200
logs.info_(response)
utls.display_tables()
return response
def get(self, qzid):
"""Get quiz details"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("QuizAPI get fn: %s" %(request))
userid, username = utls.get_user_from_hdr()
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException
('Error: No active session for this user found',
status_code=404))
return response
# Query from quiz table
query_obj = models.Quiz.query.filter_by(qzid=qzid).all()
if not query_obj:
response = handle_invalid_usage(InvalidUsageException
('Error: Quiz not found', status_code=404))
return response
# Return response
resource_fields = {'qzid':fields.Integer,
'title':fields.String,
'difficulty_level':fields.String,
'text':fields.String,
'no_ques':fields.Integer
}
quiz = marshal(query_obj, resource_fields)
response = jsonify(quiz=quiz)
utls.display_tables()
response.status_code = 200
logs.info_(response)
return response
def eventresults(userid):
# GET allevents summary for user (event sumaary result for user)
if request.method == 'GET':
error=""
"""Get eventsresultsummary.html"""
logs.debug_ ("_______________________________________________")
logs.debug_ ("getresultsummary.html get fn: %s" %(request))
#does flask get username from session from http message? does username
#come in any form and appear as a function argument in uservents(username)?
#get username from flask session
username = session['username']
if 'username' not in session:
print "Error: Username not in session"
#get user event info for events that have occured
events = models.Event.query.filter(models.Event.userid==userid,models.Event.status==3).all()
if (events == []):
print "error, no events for this username"
return render_template('error.html', error=error)
#plot_url1=plotsbar.eventplot(events)
plot_url2=plotsdiff.eventplot(events)
plotno = ''.join(s for s in plot_url2 if s.isdigit())
# Return response
#Create graph comparison of pre annd post event fear factors
#filename to save graph in
return render_template('eventsresultsummary.html', events=events, plot_url2=plot_url2, plotno=plotno, error=error)
def get(self, qzid, qid):
"""Get question qid for quiz"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("QuestionAPI get fn: %s" %(request))
userid, username = utls.get_user_from_hdr()
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException(
'Error: No active session for this user found',
status_code=404))
return response
# Query Question table
query_obj = models.Question.query.join(models.Anschoice).filter\
(models.Question.qid == qid,models.Question.qzid == qzid).all()
if not query_obj:
response = handle_invalid_usage(InvalidUsageException
('Error: Question not found', status_code=404))
return response
# Return response
ans_fields = {'ans_choice':fields.String,
'correct':fields.Boolean
}
resource_fields = {'qid':fields.Integer,
'ques_text':fields.String,
'anschoices':fields.Nested(ans_fields)
}
question = marshal(query_obj, resource_fields)
response = jsonify(question=question)
response.status_code = 200
logs.info_(response)
utls.display_tables()
return response
def get(self):
"""Get all quizzes"""
logs.debug_ ("_______________________________________________")
logs.debug_ ("QuizzesAPI get fn: %s" %(request))
# Query quizzes for this admin from quiz table
# Should that be the case or should admin be able to see
# other quizzes as well
userid, username = utls.get_user_from_hdr()
query_obj = models.Quiz.query.filter_by(userid=userid).all()
if not query_obj:
response = handle_invalid_usage(InvalidUsageException
('Error: No quizzes found', status_code=404))
return response
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException
('Error: No active session for this user found',
status_code=404))
return response
# Return response
resource_fields = {}
resource_fields['qzid'] =fields.Integer
resource_fields['title']=fields.String
resource_fields['difficulty_level'] =fields.String
resource_fields['text'] =fields.String
resource_fields['no_ques']=fields.Integer
quizzes = marshal(query_obj, resource_fields)
response = jsonify(quizzes=quizzes)
response.status_code = 200
logs.info_(response)
utls.display_tables()
return response
def updateevent(eventid):
# GET /events (event info for user)
if request.method == 'POST':
error = ""
"""Get userevents.html"""
logs.debug_("_______________________________________________")
logs.debug_("userevents.html get fn: %s" % (request))
username = session['username']
if 'username' not in session:
print "Error user not in session"
else:
if (request.form["submit"] == "Update"):
user_obj = models.User.query.filter_by(
username=username).first()
if user_obj:
userid = user_obj.userid
#get created event info and pass for template
event_obj = models.Event.query.filter_by(
eventid=eventid).all()
event = event_obj[0]
return render_template('updateventform.html',
userid=userid,
event=event,
error=error)
def login():
# POST
if request.method == 'POST':
error = None
"""Post """
logs.debug_("_______________________________________________")
logs.debug_("login get fn: %s" % (request))
username = request.form["username"]
pwd = request.form["password"]
encrypted_pwd = bcrypt.generate_password_hash(pwd)
user_obj = models.User.query.filter_by(username=username).all()
if (not user_obj):
user_obj = models.User(username,bcrypt.\
generate_password_hash(pwd))
models.db.session.add(user_obj)
models.db.session.commit()
# Create Flask session
if 'username' not in session:
session['username'] = username
# Return response
utls.display_tables()
location = "/quizzes"
response = make_response(render_template('login.html', error=error),
303)
response.location = location
return response
def get(self, qzid):
"""Get result for taker of this quiz"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("UsrQuizRtAPI get fn: %s" %(request))
userid, username = utls.get_user_from_hdr()
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException
('Error: No active session for this user found',
status_code=404))
return response
# Find quiz result for session
query_obj = models.User.query.filter_by(userid=userid).first()
result = query_obj.qzscore
# Return response
logs.debug_ ("Json response")
logs.debug_ ("=============\n")
logs.debug_ ("{\'result\':%s}\n" %(result))
response = jsonify (result=result)
response.status_code = 200
utls.display_tables()
logs.info_(response)
return response
def get(self, qzid):
"""Get quiz details"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("QuizAPI get fn: %s" %(request))
userid, username = utls.get_user_from_hdr()
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException
('Error: No active session for this user found',
status_code=404))
return response
# Query from quiz table
query_obj = models.Quiz.query.filter_by(qzid=qzid).all()
if not query_obj:
response = handle_invalid_usage(InvalidUsageException
('Error: Quiz not found', status_code=404))
return response
# Return response
resource_fields = {'qzid':fields.Integer,
'title':fields.String,
'difficulty_level':fields.String,
'text':fields.String,
'no_ques':fields.Integer
}
quiz = marshal(query_obj, resource_fields)
response = jsonify(quiz=quiz)
utls.display_tables()
response.status_code = 200
logs.info_(response)
return response
def get(self):
"""Get all quizzes"""
logs.debug_ ("_______________________________________________")
logs.debug_ ("QuizzesAPI get fn: %s" %(request))
userid, username = utls.get_user_from_hdr()
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException
('Error: No active session for this user found',
status_code=404))
return response
# Query from quiz table
query_obj = models.Quiz.query.order_by(models.Quiz.qzid).all()
if not query_obj:
response = handle_invalid_usage(InvalidUsageException
('Error: No quizzes found', status_code=404))
return response
# Return response
resource_fields = {'qzid':fields.Integer,
'title':fields.String
}
user = marshal(query_obj, resource_fields)
response = jsonify(user=user)
response.status_code = 200
logs.info_(response)
utls.display_tables()
return response
def quiz_result(qzid, userid):
# GET /user/quizzes/{qzid}/result
if ((request.method == 'GET') or (request.method == 'POST')):
error = None
"""Get result for taker of this quiz"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("UsrQuizRtAPI get fn: %s" %(request))
# get user id for user - in this case just create default?
userid = 1
qzid = 1
# Find quiz result for session
query_obj = models.User.query.filter_by(userid=userid).first()
score = query_obj.qzscore
utls.display_tables()
# Return response
location = "/quizzes/%d/%d/result" % (qzid , userid)
response = make_response(render_template('result.html',
userid=userid,
qzid=qzid,
score=score,
error=error),
200)
response.location=location
return response
def login():
# POST
if request.method == 'POST':
error = None
"""Post """
logs.debug_ ("_______________________________________________")
logs.debug_ ("login get fn: %s" %(request))
username = request.form["username"]
pwd = request.form["password"]
encrypted_pwd = bcrypt.generate_password_hash(pwd)
user_obj=models.User.query.filter_by(username=username).all()
if (not user_obj):
user_obj = models.User(username,bcrypt.\
generate_password_hash(pwd))
models.db.session.add(user_obj)
models.db.session.commit()
# Create Flask session
if 'username' not in session:
session['username'] = username
# Return response
utls.display_tables()
location = "/quizzes"
response = make_response(render_template('login.html', error=error),
303)
response.location=location
return response
def get(self, qzid, qid):
"""Get question qid for quiz"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("QuestionAPI get fn: %s" %(request))
userid, username = utls.get_user_from_hdr()
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException(
'Error: No active session for this user found',
status_code=404))
return response
# Query Question table
query_obj = models.Question.query.join(models.Anschoice).filter\
(models.Question.qid == qid,models.Question.qzid == qzid).all()
if not query_obj:
response = handle_invalid_usage(InvalidUsageException
('Error: Question not found', status_code=404))
return response
# Return response
ans_fields = {'ans_choice':fields.String,
'correct':fields.Boolean
}
resource_fields = {'qid':fields.Integer,
'ques_text':fields.String,
'anschoices':fields.Nested(ans_fields)
}
question = marshal(query_obj, resource_fields)
response = jsonify(question=question)
response.status_code = 200
logs.info_(response)
utls.display_tables()
return response
def get(self, qzid):
"""Get result for taker of this quiz"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("UsrQuizRtAPI get fn: %s" %(request))
userid, username = utls.get_user_from_hdr()
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException
('Error: No active session for this user found',
status_code=404))
return response
# Find quiz result for session
query_obj = models.User.query.filter_by(userid=userid).first()
result = query_obj.qzscore
# Return response
logs.debug_ ("Json response")
logs.debug_ ("=============\n")
logs.debug_ ("{\'result\':%s}\n" %(result))
response = jsonify (result=result)
response.status_code = 200
utls.display_tables()
logs.info_(response)
return response
def patch(self, qzid):
"""Edit quiz details"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("QuizAPI patch fn: %s \nJson Request\n=============\n %s"
%(request, request.json))
userid, username = utls.get_user_from_hdr()
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException
('Error: No active session for this user found',
status_code=404))
return response
# Get values from req
args = self.reqparse.parse_args()
cols = {}
no_data = True
for key, value in args.iteritems():
if value is not None:
no_data = False
cols[key] = request.json[key]
# Check if user is auth to update this quiz
query_obj = models.Quiz.query.filter_by(qzid=qzid).first()
if (query_obj.userid != userid):
response = handle_invalid_usage(InvalidUsageException
('Error: Unauthorized Username for this quiz', \
status_code=401))
return response
# If no input in patch request, return 400
if no_data:
response = handle_invalid_usage(InvalidUsageException
('Error: No input data provided in Patch req',
status_code=400))
return response
# Update tables
models.Quiz.query.filter_by(qzid=qzid).update(cols)
models.db.session.commit()
# Return response
query_obj = models.Quiz.query.filter_by(qzid=qzid).all()
resource_fields = {'qzid':fields.Integer,
'title':fields.String,
'difficulty_level':fields.String,
'text':fields.String,
'no_ques':fields.Integer
}
quiz = marshal(query_obj, resource_fields)
response = jsonify(quiz=quiz)
response.status_code = 200
logs.info_(response)
utls.display_tables()
return response
def patch(self, ideaid):
"""Edit idea details"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("IdeaAPI patch fn: %s \nJson Request\n=============\n %s"
%(request, request.json))
userid, username = utls.get_user_from_hdr()
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException
('Error: No active session for this user found',
status_code=404))
return response
# Get values from req
args = self.reqparse.parse_args()
cols = {}
no_data = True
for key, value in args.iteritems():
if value is not None:
no_data = False
cols[key] = request.json[key]
# Check if user is auth to update this idea
query_obj = models.Idea.query.filter_by(ideaid=ideaid).first()
if (query_obj.userid != userid):
response = handle_invalid_usage(InvalidUsageException
('Error: Unauthorized Username for this idea', \
status_code=401))
return response
# If no input in patch request, return 400
if no_data:
response = handle_invalid_usage(InvalidUsageException
('Error: No input data provided in Patch req',
status_code=400))
return response
# Update tables
models.Idea.query.filter_by(ideaid=ideaid).update(cols)
models.db.session.commit()
# Return response
query_obj = models.Idea.query.filter_by(ideaid=ideaid).all()
resource_fields = {'ideaid':fields.Integer,
'title':fields.String,
'score':fields.String,
'text':fields.String,
'no_ques':fields.Integer
}
idea = marshal(query_obj, resource_fields)
response = jsonify(idea=idea)
response.status_code = 200
logs.info_(response)
utls.display_tables()
return response
def userevents(userid):
# POST /events (new event creation info submitted here)
if request.method == 'POST':
error = ""
logs.debug_("_______________________________________________")
logs.debug_("HTTP request get fn: %s" % (request))
username = session['username']
if 'username' not in session:
return render_template('login.html', error=error)
#import pdb; pdb.set_trace()
#import dateutil.parser
if ((request.form["Submit"] == "Submit Query")
or (request.form["Submit"] == "Submit")):
if (request.form["title"] and request.form["preeventtxt"] and \
request.form["prefearfactor"] and request.form["datetime"]):
title = request.form['title']
preeventtxt = request.form['preeventtxt']
prefearfactor = request.form[
'prefearfactor'] #no rating fear out of 10
datetime = request.form['datetime']
#datetime = dateutil.parser.parse(datetimefield)
#if isinstance(request.form['datetime'],dt.datetime):
# datetime=request.form['datetime']
#else:
# import re
# datetime = dt.datetime(re.split('[\s,:,am,pm]+',request.form['datetime'])) #time of future event given by user
#else:
#error= "All fields are mandatory!"
#return render_template('dashboard.html', error=error), 400
#else:
#error= "Need to submit after form entry!"
#return render_template('dashboard.html', error=error), 400
users = models.User.query.filter_by(username=username).all()
userid = users[0].userid
status = 0
models.db.session.add(
models.Event(title, datetime, preeventtxt, "",
prefearfactor, 0, status, 0, userid))
models.db.session.commit()
location = "/users/" + str(userid) + "/dashboard"
code = 303
response = make_response()
response.location = location
response.status_code = code
return response
def post(self):
"""Login already existing user or add new user"""
print "-------Hello"
logs.debug_ ("_________________________________________________")
logs.debug_ ("UserAPI post fn: %s\nJson Request\n=============\n %s" %(request, request.json))
# Get values from request
args = self.reqparse.parse_args()
for key, value in args.iteritems():
if value is not None:
if (key == 'username'):
username = request.json['username']
if (key == 'password'):
password = request.json['password']
# Check and Update tables
# This is implemented as if we are processing get /users
user_obj = models.User.query.filter_by(username=username).first()
user_index = None
for i in range(len(user_obj)):
if username in user_obj[i].username:
user_index = i
if user_index is not None:
#match encrypted password with one in table
if not bcrypt.check_password_hash(user_obj[user_index].password,
password):
response = handle_invalid_usage(InvalidUsageException
('Error: Password for user does not match',
status_code=401))
return response
else:
# Add new user
user_obj = models.User(username,
bcrypt.generate_password_hash(password))
models.db.session.add(user_obj)
models.db.session.commit()
# Create flask session here with secret key based on username
if 'username' not in session:
session['username'] = username
# Return response
location = "/users/%s" % user_obj.userid
query_obj = models.User.query.filter_by(userid=user_obj.userid).all()
resource_fields = {'userid':fields.Integer}
user = marshal(query_obj, resource_fields)
response = jsonify(user=user)
response.status_code = 201
response.location = location
logs.info_(response)
utls.display_tables()
return response
def logout():
# GET /
error = None
logs.debug_ ("_______________________________________________")
logs.debug_ ("QuizzesAPI post fn: %s" %(request))
session.pop('username',None)
# Return response
utls.display_tables()
return render_template('logout.html', error=error)
def index():
# GET /
if request.method == 'GET':
error = None
"""Get index.html"""
logs.debug_("_______________________________________________")
logs.debug_("index.html get fn: %s" % (request))
# Return response
utls.display_tables()
return render_template('login.html', error=error)
def index():
# GET /
if request.method == 'GET':
error = None
"""Get index.html"""
logs.debug_ ("_______________________________________________")
logs.debug_ ("index.html get fn: %s" %(request))
# Return response
utls.display_tables()
return render_template('login.html', error=error)
def logout():
# GET /
error = None
logs.debug_("_______________________________________________")
logs.debug_("QuizzesAPI post fn: %s" % (request))
session.pop('username', None)
# Return response
utls.display_tables()
return render_template('logout.html', error=error)
def logout():
# GET /
error = ""
loggedin = False
logs.debug_("_______________________________________________")
logs.debug_("HTTP request get fn: %s" % (request))
if 'username' in session:
session.pop('username', None)
return render_template('index.html', loggedin=loggedin, error=error)
def quiz_result(qzid):
# GET /user/quizzes/{qzid}/result
if ((request.method == 'GET') or (request.method == 'POST')):
error = None
"""Get result for taker of this quiz"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("UsrQuizRtAPI get fn: %s" %(request))
# get user id for user - in this case just create default?
username = session['username']
user_obj = models.User.query.filter_by(username=username).first()
userid = user_obj.userid
# Find quiz result for session
qz_obj = models.Quiz.query.filter_by(qzid=qzid).first()
qztitle = qz_obj.title
qzattemptid = models.QResult.query.with_entities(sqlalchemy.func.max\
(models.QResult.qzattemptid)).\
filter_by(userid=userid, qzid=qzid).first()
if (qzattemptid[0] == None):
return render_template('result.html')
cur_qscore_obj = models.QResult.query.with_entities(models.QResult.qid,\
models.QResult.score).filter_by(userid=userid, \
qzid=qzid, qzattemptid=qzattemptid[0]).all()
allqscore_obj = models.QResult.query.with_entities(models.QResult.qid,\
sqlalchemy.func.sum(models.QResult.score).\
label("score")).filter_by(userid=userid, qzid=qzid).\
group_by(models.QResult.qid).all()
cur_qzscore = 0
for index in range(len(cur_qscore_obj)):
cur_qzscore += cur_qscore_obj[index][1]
# Return response
location = "/quizzes/%d/%d/result" % (qzid , userid)
response = make_response(render_template('result.html',
username=username,
qztitle=qztitle,
cur_qscore_obj=cur_qscore_obj,
cur_qzscore=cur_qzscore,
qzattemptid=qzattemptid[0],
allqscore_obj=allqscore_obj,
error=error),
200)
response.location=location
return response
def quiz_result(qzid):
# GET /user/quizzes/{qzid}/result
if ((request.method == 'GET') or (request.method == 'POST')):
error = None
"""Get result for taker of this quiz"""
logs.debug_("_________________________________________________")
logs.debug_("UsrQuizRtAPI get fn: %s" % (request))
# get user id for user - in this case just create default?
username = session['username']
user_obj = models.User.query.filter_by(username=username).first()
userid = user_obj.userid
# Find quiz result for session
qz_obj = models.Quiz.query.filter_by(qzid=qzid).first()
qztitle = qz_obj.title
qzattemptid = models.QResult.query.with_entities(sqlalchemy.func.max\
(models.QResult.qzattemptid)).\
filter_by(userid=userid, qzid=qzid).first()
if (qzattemptid[0] == None):
return render_template('result.html')
cur_qscore_obj = models.QResult.query.with_entities(models.QResult.qid,\
models.QResult.score).filter_by(userid=userid, \
qzid=qzid, qzattemptid=qzattemptid[0]).all()
allqscore_obj = models.QResult.query.with_entities(models.QResult.qid,\
sqlalchemy.func.sum(models.QResult.score).\
label("score")).filter_by(userid=userid, qzid=qzid).\
group_by(models.QResult.qid).all()
cur_qzscore = 0
for index in range(len(cur_qscore_obj)):
cur_qzscore += cur_qscore_obj[index][1]
# Return response
location = "/quizzes/%d/%d/result" % (qzid, userid)
response = make_response(
render_template('result.html',
username=username,
qztitle=qztitle,
cur_qscore_obj=cur_qscore_obj,
cur_qzscore=cur_qzscore,
qzattemptid=qzattemptid[0],
allqscore_obj=allqscore_obj,
error=error), 200)
response.location = location
return response
def userevent(eventid):
# Get event info to update the rest part
if request.method == 'GET':
error = ""
logs.debug_("_______________________________________________")
logs.debug_("HTTP request get fn: %s" % (request))
username = session['username']
if 'username' not in session:
return render_template('login.html', error=error)
if (request.args.get("submit") == "Update"):
user_obj = models.User.query.filter_by(username=username).first()
if user_obj: #The 'else' for this condition will not happen
userid = user_obj.userid
#get created event info and pass for template
event_obj = models.Event.query.filter_by(eventid=eventid).all()
event = event_obj[0]
return render_template('updateventform.html',
userid=userid,
event=event,
error=error)
#Update event
if request.method == 'POST':
error = ""
logs.debug_("_______________________________________________")
logs.debug_("HTTP request get fn: %s" % (request))
if 'username' not in session:
#Also doesnt seem like this can happen
return render_template('login.html', error=error)
#get username from flask session
username = session["username"]
if (request.form["submit"] == "Submit"):
query_obj = models.User.query.filter_by(username=username).first()
userid = query_obj.userid
posteventtxt = request.form['posteventtxt']
postfearfactor = request.form['postfearfactor']
status = 3
models.Event.query.filter_by(eventid=eventid).update(
dict(posteventtxt=posteventtxt,
postfearfactor=postfearfactor,
status=status))
models.db.session.commit()
# Return response
location = "/users/" + str(userid) + "/dashboard"
code = 303
response = make_response()
response.location = location
response.status_code = code
return response
def userevents(userid):
# GET /events (event info for user)
if request.method == 'GET':
error=""
"""Get userevents.html"""
logs.debug_ ("_______________________________________________")
logs.debug_ ("userevents.html get fn: %s" %(request))
#does flask get username from session from http message? does username
#come in any form and appear as a function argument in uservents(username)?
#get username from flask session
username = session['username']
if 'username' not in session:
#return error#-------------------------------------?????-----
print "Error -username not in session"
#get user event info
events= models.Event.query.filter_by(userid=userid).all()
if (events is None):
print "error, no events for this username"
return render_template('error.html', error=error)
# Return response
#utls.display_tables()
#Create graph comparison of pre and post event fear factors
#filename to save graph in
return render_template('eventslist.html', username=username, events=events, error=error)
# POST /events (new event creation)
elif request.method == 'POST':
error=""
"""Post login.html"""
logs.debug_ ("_______________________________________________")
logs.debug_ ("login.html get fn: %s" %(request))
#get username from flask session
username = session['username']
if 'username' not in session:
print "Error -username not in session"
if (request.form["Submit"]=="Submit"):
title = request.form['title']
preeventtxt = request.form['preeventtxt']
prefearfactor = request.form['prefearfactor'] #no rating fear out of 10
datetime = request.form['datetime'] #time of future event given by user
users = models.User.query.filter_by(username=username).all()
userid = users[0].userid
status = 0
#twiliosmsstatus = NONE for now- will be updated by polling sched app
models.db.session.add(models.Event(title, datetime, preeventtxt, "", prefearfactor,0, status, 0, userid))
models.db.session.commit()
# Return response
#utls.display_tables()
return render_template('welcomelgn.html', username=username, userid=userid, error=error)
def eventgraphresults(userid):
# GET allevents summary for user (event summary result for user)
if request.method == 'GET':
error = ""
logs.debug_("_______________________________________________")
logs.debug_("HTTP request get fn: %s" % (request))
if 'username' not in session:
return None
username = session['username']
loggedin = True
#if using bokeh
events = models.Event.query.filter(models.Event.userid == userid,
models.Event.status == 3).all()
#an old user has at least one event so a dashboard makes sense- default set to False
olduser = False
if (events):
#old user
olduser = True
#Unique js and div tag created everytime for a new plot
bokehjs1, raddivtag = bokehradial.plotradial(events, userid)
bokehjs2, bardivtag = bokehbar.plotbar(events, userid)
return render_template('dashboard.html',
olduser=True,
raddivtag=raddivtag,
bardivtag=bardivtag,
loggedin=loggedin,
events=events,
username=username,
userid=userid,
error=error)
#return render_template('dashboard.html', olduser=True, raddivtag=raddivtag, loggedin=loggedin, events=events, username=username, userid=userid, error=error)
else:
#new user
return render_template('dashboard.html',
olduser=False,
loggedin=loggedin,
events=events,
username=username,
userid=userid,
error=error)
def post(self):
"""Add new quiz"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("QuizzesAPI post fn: %s\nJson Request\n=============\n %s"
%(request, request.json))
userid, username = utls.get_user_from_hdr()
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException
('Error: No active session for this user found',
status_code=404))
return response
# Get values from request
args = self.reqparse.parse_args()
for key, value in args.iteritems():
if value is not None:
if (key == 'title'):
title = request.json['title']
if (key == 'difficulty_level'):
difficulty_level = request.json['difficulty_level']
if (key == 'text'):
text = request.json['text']
# Update tables
quiz_obj = models.Quiz(title, difficulty_level, text, userid)
models.db.session.add(quiz_obj)
models.db.session.commit()
# Return response
location = "/quizzes/%s" % quiz_obj.qzid
query_obj = models.Quiz.query.filter_by(qzid=quiz_obj.qzid).all()
resource_fields = {'qzid':fields.Integer,
'title':fields.String,
'difficulty_level':fields.String,
'text':fields.String,
'no_ques':fields.Integer
}
quiz = marshal(query_obj, resource_fields)
response = jsonify(quiz=quiz)
response.status_code = 201
response.location = location
logs.info_(response)
utls.display_tables()
return response
def post(self):
"""Add new idea"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("IdeasAPI post fn: %s\nJson Request\n=============\n %s"
%(request, request.json))
userid, username = utls.get_user_from_hdr()
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException
('Error: No active session for this user found',
status_code=404))
return response
# Get values from request
args = self.reqparse.parse_args()
for key, value in args.iteritems():
if value is not None:
if (key == 'title'):
title = request.json['title']
if (key == 'score'):
score = request.json['score']
if (key == 'text'):
text = request.json['text']
# Update tables
idea_obj = models.Idea(title, score, text, userid)
models.db.session.add(idea_obj)
models.db.session.commit()
# Return response
location = "/ideas/%s" % idea_obj.ideaid
query_obj = models.Idea.query.filter_by(ideaid=idea_obj.ideaid).all()
resource_fields = {'ideaid':fields.Integer,
'title':fields.String,
'score':fields.String,
'text':fields.String,
'no_ques':fields.Integer
}
idea = marshal(query_obj, resource_fields)
response = jsonify(idea=idea)
response.status_code = 201
response.location = location
logs.info_(response)
utls.display_tables()
return response
def post(self):
"""Add new quiz"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("QuizzesAPI post fn: %s\nJson Request\n=============\n %s"
%(request, request.json))
userid, username = utls.get_user_from_hdr()
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException
('Error: No active session for this user found',
status_code=404))
return response
# Get values from request
args = self.reqparse.parse_args()
for key, value in args.iteritems():
if value is not None:
if (key == 'title'):
title = request.json['title']
if (key == 'difficulty_level'):
difficulty_level = request.json['difficulty_level']
if (key == 'text'):
text = request.json['text']
# Update tables
quiz_obj = models.Quiz(title, difficulty_level, text, userid)
models.db.session.add(quiz_obj)
models.db.session.commit()
# Return response
location = "/quizzes/%s" % quiz_obj.qzid
query_obj = models.Quiz.query.filter_by(qzid=quiz_obj.qzid).all()
resource_fields = {'qzid':fields.Integer,
'title':fields.String,
'difficulty_level':fields.String,
'text':fields.String,
'no_ques':fields.Integer
}
quiz = marshal(query_obj, resource_fields)
response = jsonify(quiz=quiz)
response.status_code = 201
response.location = location
logs.info_(response)
utls.display_tables()
return response
def quizzes():
# GET /quizzes
if request.method == 'GET':
error = None
"""Get all quiz questions"""
logs.debug_("_______________________________________________")
logs.debug_("QuizzesAPI get fn: %s" % (request))
username = session['username']
# Return response
utls.display_tables()
response = make_response(
render_template('welcome.html', username=username, error=error),
200)
return response
def get(self, qzid):
"""Get all questions for quiz"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("QuestionisAPI get fn: %s" %(request))
# Check if user is auth to get details of this ques
userid, username = utls.get_user_from_hdr()
query_obj = models.Quiz.query.filter_by(qzid=qzid).first()
if (query_obj.userid != userid):
response = handle_invalid_usage(InvalidUsageException
('Error: Unauthorized Username for this quiz', \
status_code=401))
return response
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException
('Error: No active session for this user found',
status_code=404))
return response
# Query from questions table
query_obj = models.Question.query.join(models.Quiz).join(models.Anschoice).\
filter(models.Quiz.qzid == qzid).all()
if not query_obj:
response = handle_invalid_usage(InvalidUsageException
('Error: No question for quiz found',
status_code=404))
return response
# Return response
ans_fields = {'ans_choice':fields.String,
'correct':fields.Boolean
}
resource_fields = {'qid':fields.Integer,
'ques_text':fields.String,
'ans_text':fields.String,
'qzid':fields.Integer,
'anschoices':fields.Nested(ans_fields)
}
questions = marshal(query_obj, resource_fields)
response = jsonify(questions=questions)
response.status_code = 200
utls.display_tables()
logs.info_(response)
return response
def get(self, qzid):
"""Get all questions for quiz"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("QuestionisAPI get fn: %s" %(request))
# Check if user is auth to get details of this ques
userid, username = utls.get_user_from_hdr()
query_obj = models.Quiz.query.filter_by(qzid=qzid).first()
if (query_obj.userid != userid):
response = handle_invalid_usage(InvalidUsageException
('Error: Unauthorized Username for this quiz', \
status_code=401))
return response
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException
('Error: No active session for this user found',
status_code=404))
return response
# Query from questions table
query_obj = models.Question.query.join(models.Quiz).join(models.Anschoice).\
filter(models.Quiz.qzid == qzid).all()
if not query_obj:
response = handle_invalid_usage(InvalidUsageException
('Error: No question for quiz found',
status_code=404))
return response
# Return response
ans_fields = {'ans_choice':fields.String,
'correct':fields.Boolean
}
resource_fields = {'qid':fields.Integer,
'ques_text':fields.String,
'ans_text':fields.String,
'qzid':fields.Integer,
'anschoices':fields.Nested(ans_fields)
}
questions = marshal(query_obj, resource_fields)
response = jsonify(questions=questions)
response.status_code = 200
utls.display_tables()
logs.info_(response)
return response
def quizzes():
# GET /quizzes
if request.method == 'GET':
error = None
"""Get all quiz questions"""
logs.debug_ ("_______________________________________________")
logs.debug_ ("QuizzesAPI get fn: %s" %(request))
username = session['username']
# Return response
utls.display_tables()
response= make_response(render_template('welcome.html',
username=username,
error=error),
200)
return response
def newevent():
# GET /events (event info for user)
if request.method == 'GET':
error=""
"""Get userevents.html"""
logs.debug_ ("_______________________________________________")
logs.debug_ ("userevents.html get fn: %s" %(request))
username = session['username']
if 'username' not in session:
print "Error user not in session"
else:
user_obj=models.User.query.filter_by(username=username).first()
if user_obj:
userid=user_obj.userid
return render_template('createeventform.html',userid=userid, error=error)
def login():
#User clicks on login button- GET /users/login
if request.method == 'GET':
error = ""
"""Get login.html"""
logs.debug_("_______________________________________________")
logs.debug_("login.html get fn: %s" % (request))
return render_template('loginform.html', error=error)
# User posts log in info in form and submits -POST /login
elif request.method == 'POST':
error = ""
"""Post login.html"""
logs.debug_("_______________________________________________")
logs.debug_("login.html get fn: %s" % (request))
if (request.form["Login"] != "Submit"):
pass
# Return error
else:
username = request.form["username"]
password = request.form["password"]
query_obj = models.User.query.filter_by(username=username).first()
userid = query_obj.userid
#import pdb; pdb.set_trace()
if (query_obj is None):
error = "Username does not exist"
return render_template('loginform.html', error=error)
elif ((query_obj.username == username)
and (not bcrypt.check_password_hash(query_obj.password,
password))):
error = "Password is incorrect"
return render_template('loginform.html', error=error)
if 'username' not in session:
session['username'] = username
# Return response
#utls.display_tables()
return render_template('welcomelgn.html',
username=username,
userid=userid,
error=error)
else: # methods other than get/post
error = "Incorrect Method"
response = make_response(render_template('error.html', error=error),
400)
return response
def eventtxtresults(userid, pageid,
strval): #default pageid=1 if url does not provide
# GET all events summary for user (event summary result for user)
if request.method == 'GET':
error = ""
logs.debug_("_______________________________________________")
logs.debug_("HTTP request get fn: %s" % (request))
if 'username' not in session:
return "Error: Username not in session"
username = session['username']
if (str(strval) == 'updatedevents'):
events = models.Event.query.filter(
models.Event.userid == userid,
models.Event.status == FEARAPP_STATUS_UPDATED).paginate(
page=pageid, per_page=POSTS_PER_PAGE, error_out=False)
futureevents = False
else:
events = models.Event.query.filter(
models.Event.userid == userid,
models.Event.status != FEARAPP_STATUS_UPDATED).paginate(
page=pageid, per_page=POSTS_PER_PAGE, error_out=False)
futureevents = True
thispage = events.items
totalpages = events.pages
#Not sure if the foll part of code is of any use since paginate takes care of 404. If error_out=False
#like in our case, no error is displayed on zero results; else it will return a 404 code automatically
if (events == []):
print "error, no events for this username"
return render_template('error.html', error=error), 404
return render_template('eventsajax.html',
futureevents=futureevents,
thispage=thispage,
pageid=pageid,
userid=userid,
totalpages=totalpages,
error=error)
def updateevent(eventid):
# GET /events (event info for user)
if request.method == 'POST':
error=""
"""Get userevents.html"""
logs.debug_ ("_______________________________________________")
logs.debug_ ("userevents.html get fn: %s" %(request))
username = session['username']
if 'username' not in session:
print "Error user not in session"
else:
if (request.form["submit"] == "Update"):
user_obj=models.User.query.filter_by(username=username).first()
if user_obj:
userid=user_obj.userid
#get created event info and pass for template
event_obj=models.Event.query.filter_by(eventid=eventid).all()
event=event_obj[0]
return render_template('updateventform.html',userid=userid, event=event, error=error)
def newevent():
# GET /events (event info for user)
if request.method == 'GET':
error = ""
"""Get userevents.html"""
logs.debug_("_______________________________________________")
logs.debug_("userevents.html get fn: %s" % (request))
#Arch: you need to get userid first -maybe in func args; then write a query to get username
#The following should always result in error all through this code- look at quizngn code
username = session['username']
if 'username' not in session:
print "Error user not in session"
else:
user_obj = models.User.query.filter_by(username=username).first()
if user_obj:
userid = user_obj.userid
return render_template('createeventform.html',
userid=userid,
error=error)
def role_decorator(*args, **kwargs):
# get username password from HTTP Basic Authentication header in
# request- Authorization: 'Basic username:password'
logs.debug_ ( "\n-------role.py required------\n")
auth = request.headers.get('Authorization')
# Auth header is in the form 'basic username:pwd role:admin'
import views
from views import handle_invalid_usage, InvalidUsageException
if not auth:
response = handle_invalid_usage(InvalidUsageException \
('Error: Authorization required', \
status_code=401))
return response
role = auth.split()[2].split(':').pop()
if ("admin" != role):
logs.debug_ ( "Error role should be admin to access the resource")
response = handle_invalid_usage(InvalidUsageException \
('Error: Cannot access resource, role should be admin', \
status_code=401))
return response
return f(*args, **kwargs)
def role_decorator(*args, **kwargs):
# get username password from HTTP Basic Authentication header in
# request- Authorization: 'Basic username:password'
logs.debug_("\n-------role.py required------\n")
auth = request.headers.get('Authorization')
# Auth header is in the form 'basic username:pwd role:admin'
import views
from views import handle_invalid_usage, InvalidUsageException
if not auth:
response = handle_invalid_usage(InvalidUsageException \
('Error: Authorization required', \
status_code=401))
return response
role = auth.split()[2].split(':').pop()
if ("admin" != role):
logs.debug_("Error role should be admin to access the resource")
response = handle_invalid_usage(InvalidUsageException \
('Error: Cannot access resource, role should be admin', \
status_code=401))
return response
return f(*args, **kwargs)
def userevents(userid):
# POST /events (new event creation info submitted here)
if request.method == 'POST':
error = ""
logs.debug_("_______________________________________________")
logs.debug_("HTTP request get fn: %s" % (request))
username = session['username']
if 'username' not in session:
return render_template('login.html', error=error)
if (request.form["Submit"] == "Submit"):
if (request.form["title"] and request.form["preeventtxt"] and \
request.form["prefearfactor"] and request.form["datetime"]):
title = request.form['title']
preeventtxt = request.form['preeventtxt']
prefearfactor = request.form[
'prefearfactor'] #no rating fear out of 10
datetime = request.form[
'datetime'] #time of future event given by user
else:
error = "All fields are mandatory!"
return render_template('dashboard.html', error=error), 400
users = models.User.query.filter_by(username=username).all()
userid = users[0].userid
status = 0
models.db.session.add(
models.Event(title, datetime, preeventtxt, "", prefearfactor,
0, status, 0, userid))
models.db.session.commit()
location = "/users/" + str(userid) + "/dashboard"
code = 303
response = make_response()
response.location = location
response.status_code = code
return response
def get(self, ideaid):
"""Get idea details"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("IdeaAPI get fn: %s" %(request))
# Check if user is auth to get details of this idea
userid, username = utls.get_user_from_hdr()
query_obj = models.Idea.query.filter_by(ideaid=ideaid).first()
if (query_obj.userid != userid):
response = handle_invalid_usage(InvalidUsageException
('Error: Unauthorized Username for this idea', \
status_code=401))
return response
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException
('Error: No active session for this user found',
status_code=404))
return response
# Query from idea table
query_obj = models.Idea.query.filter_by(ideaid = ideaid).all()
if not query_obj:
response = handle_invalid_usage(InvalidUsageException
('Error: Idea not found', status_code=404))
return response
# Return response
resource_fields = {'ideaid':fields.Integer,
'title':fields.String,
'score':fields.String,
'text':fields.String,
'no_ques':fields.Integer
}
idea = marshal(query_obj, resource_fields)
response = jsonify(idea=idea)
response.status_code = 200
logs.info_(response)
return response
def delete(self, qzid, qid):
"""Delete question"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("QuestionAPI del fn: %s" %(request.url))
# Check if user is auth to del this ques
userid, username = utls.get_user_from_hdr()
query_obj = models.Question.query.filter_by(qid=qid).first()
if (query_obj.userid != userid):
response = handle_invalid_usage(InvalidUsageException
('Error: Unauthorized Username for this ques', \
status_code=401))
return response
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException
('Error: No active session for this user found',
status_code=404))
return response
# Updating no_ques col in quiz table
L = models.Quiz.query.filter_by(qzid = qzid).first()
models.Quiz.query.filter_by(qzid = qzid).\
update(dict(no_ques= (L.no_ques-1)))
# Deleting Ans choices table entries for qid
models.Anschoice.query.filter(models.Anschoice.qid == qid).delete()
# Finally deleting entries from Question table
models.Question.query.filter_by(qid = qid).delete()
models.db.session.commit()
# Return response
response = jsonify(qid=qid)
response.status_code = 204
logs.info_(response)
utls.display_tables()
return response
def auth_decorator(*args, **kwargs):
# get username password from HTTP Basic Authentication header in
# request- Authorization: 'Basic username:password'
logs.debug_( "\n-------basicauth.py; login required------\n")
auth = request.headers.get('Authorization')
if not auth:
return send_authenticate_req()
# Auth header is in the format 'basic username:pwd role:admin'
username, password = tuple(auth.split()[1].split(':'))
if not check_auth(username, password):
#Maybe we need to set a flag to limit the no of times
# we should authenticate?
logs.debug_( "Invalid username or password")
return send_authenticate_req()
#Create Flask session here after user is authenticated
if 'username' not in session:
session['username'] = username
return f(*args, **kwargs)
def delete(self, qzid, qid):
"""Delete question"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("QuestionAPI del fn: %s" %(request.url))
# Check if user is auth to del this ques
userid, username = utls.get_user_from_hdr()
query_obj = models.Question.query.filter_by(qid=qid).first()
if (query_obj.userid != userid):
response = handle_invalid_usage(InvalidUsageException
('Error: Unauthorized Username for this ques', \
status_code=401))
return response
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException
('Error: No active session for this user found',
status_code=404))
return response
# Updating no_ques col in quiz table
L = models.Quiz.query.filter_by(qzid = qzid).first()
models.Quiz.query.filter_by(qzid = qzid).\
update(dict(no_ques= (L.no_ques-1)))
# Deleting Ans choices table entries for qid
models.Anschoice.query.filter(models.Anschoice.qid == qid).delete()
# Finally deleting entries from Question table
models.Question.query.filter_by(qid = qid).delete()
models.db.session.commit()
# Return response
response = jsonify(qid=qid)
response.status_code = 204
logs.info_(response)
utls.display_tables()
return response
def login():
reset = False
#import pdb; pdb.set_trace()
#User clicks on login button- GET /users/login
if request.method == 'GET':
error = ""
logs.debug_("_______________________________________________")
logs.debug_("HTTP request get fn: %s" % (request))
return render_template('login.html', error=error, reset=reset)
# User posts log in info in form and submits -POST /login
elif request.method == 'POST':
error = ""
loggedin = False
logs.debug_("_______________________________________________")
logs.debug_("HTTP request get fn: %s" % (request))
if ((request.form["username"]) and (request.form["password"])):
username = request.form["username"]
password = request.form["password"]
else:
error = "Fields are empty!"
return render_template('login.html', error=error, reset=reset), 400
query_obj = models.User.query.filter_by(username=username).first()
if (query_obj is None):
error = "Username does not exist!"
return render_template('login.html', error=error, reset=reset), 404
elif ((query_obj.username == username) and
(not bcrypt.check_password_hash(query_obj.password, password))):
error = "Incorrect password. Type again!"
return render_template('login.html', reset=reset, error=error), 400
userid = query_obj.userid
session['username'] = username
loggedin = True
response = make_response()
response.location = "/users/" + str(userid) + "/dashboard"
response.status_code = 303
return response
def index():
# GET /index
if request.method == 'GET':
error = ""
logs.debug_("_______________________________________________")
logs.debug_("HTTP request get fn: %s" % (request))
userid = ""
loggedin = False
username = ""
if 'username' in session:
username = session['username']
query_obj = models.User.query.filter_by(username=username).first()
userid = query_obj.userid
loggedin = True
return render_template('index.html',
loggedin=loggedin,
username=username,
userid=userid,
error=error)
def login():
#User clicks on login button- GET /users/login
if request.method == 'GET':
error=""
"""Get login.html"""
logs.debug_ ("_______________________________________________")
logs.debug_ ("login.html get fn: %s" %(request))
return render_template('loginform.html', error=error)
# User posts log in info in form and submits -POST /login
elif request.method == 'POST':
error=""
"""Post login.html"""
logs.debug_ ("_______________________________________________")
logs.debug_ ("login.html get fn: %s" %(request))
if (request.form["Login"] != "Submit"):
pass;
# Return error
else:
username = request.form["username"]
password = request.form["password"]
query_obj=models.User.query.filter_by(username=username).first()
userid=query_obj.userid
#import pdb; pdb.set_trace()
if (query_obj is None):
error= "Username does not exist"
return render_template('loginform.html', error=error)
elif ((query_obj.username == username) and (not bcrypt.check_password_hash(query_obj.password,password))):
error= "Password is incorrect"
return render_template('loginform.html', error=error)
if 'username' not in session:
session['username']=username
# Return response
#utls.display_tables()
return render_template('welcomelgn.html', username=username, userid=userid, error=error)
else:# methods other than get/post
error = "Incorrect Method"
response = make_response(render_template('error.html', error=error), 400)
return response
def delete(self, qzid):
"""Delete quiz"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("QuizAPI delete fn: %s" %(request))
# Check if user is auth to delete this quiz
userid, username = utls.get_user_from_hdr()
query_obj = models.Quiz.query.filter_by(qzid=qzid).first()
if (query_obj.userid != userid):
response = handle_invalid_usage(InvalidUsageException
('Error: Unauthorized Username for this quiz', \
status_code=401
)
)
return response
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException
('Error: No active session for this user found',
status_code=404))
return response
# Delete all questions table entries for the quiz
models.Question.query.join(models.Quiz).filter(models.Question.qzid == qzid).\
delete()
# Delete all Ans choices table entries for quiz
models.Anschoice.query.join(models.Quiz).filter(models.Anschoice.qzid == qzid).\
delete()
# Delete quiz
models.Quiz.query.filter(models.Quiz.qzid == qzid).delete()
models.db.session.commit()
# Return response
utls.display_tables()
return 204
def delete(self):
"""Delete session"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("SessionAPI del fn: %s" %(request.url))
# Pop user from session
userid, username = utls.get_user_from_hdr()
if 'username' not in session:
logs.debug_("User already not in session")
else:
session.pop('username', None)
# Return response
utls.display_tables()
return 204
def patch(self, qzid, qid):
"""Add question to quiz"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("QuestionAPI patch fn: %s \nJson Request\n=============\n %s"
%(request, request.json))
# Check if user is auth to update this ques
userid, username = utls.get_user_from_hdr()
query_obj = models.Question.query.filter_by(qid=qid).first()
if (query_obj.userid != userid):
response = handle_invalid_usage(InvalidUsageException
('Error: Unauthorized Username for this ques', \
status_code=401))
return response
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException
('Error: No active session for this user found',
status_code=404))
return response
# Check if question qid exists for qzid, raise error
query_obj = models.Question.query.filter(models.Question.qid == qid,models.Question.qzid == qzid).all()
if not query_obj:
response = handle_invalid_usage(InvalidUsageException
('Error: Question to edit not found for ques',
status_code=400))
return response
args = self.reqparse.parse_args()
for key, value in args.iteritems():
if value is not None:
if (key == 'ques_text'):
ques_text = request.json['ques_text']
if (key == 'ans_text'):
ans_text = request.json['ans_text']
if (key == 'anschoices'):
anschoices = request.json['anschoices']
# Update all table entries with input data
models.Question.query.filter_by(qid = qid).\
update(dict(ques_text=ques_text, ans_text=ans_text))
# Updating correspnoding relationship tables
# Ans choices table
query_obj = models.Anschoice.query.filter_by(qid = qid)
index = 0
for choice in query_obj:
ansid = query_obj[index].ansid
ans_choice = anschoices[index]["answer"]
correct = anschoices[index]["correct"]
models.Anschoice.query.filter_by(ansid = ansid).\
update(dict(ans_choice = ans_choice, correct = correct))
index += 1
models.db.session.commit()
# Return response
query_obj = models.Question.query.join(models.Anschoice).filter(
models.Question.qid == qid).all()
ans_fields = {'ans_choice':fields.String,
'correct':fields.Boolean
}
resource_fields = {'qid':fields.Integer,
'ques_text':fields.String,
'ans_text':fields.String,
'qzid':fields.Integer,
'anschoices':fields.Nested(ans_fields)
}
question = marshal(query_obj, resource_fields)
response = jsonify(question=question)
response.status_code = 200
logs.info_(response)
utls.display_tables()
return response
def quiz_questions(qzid):
# GET /quizzes/qzid/questions
if request.method == 'GET':
error = None
"""Get all quiz questions"""
logs.debug_ ("_______________________________________________")
logs.debug_ ("QuizzesAPI get fn: %s" %(request))
# Query Question table
ques = models.Question.query.join(models.Anschoice).filter\
(models.Question.qzid == qzid).all()
# Return response
utls.display_tables()
return render_template('questions.html', ques=ques, error=error)
#POST /quizzes/qzid/questions
else:
error = None
""" Post answers to all quiz questions"""
logs.debug_ ("_______________________________________________")
logs.debug_ ("QuizzesAPI Post fn: %s" %(request))
#get all questions from db
ques_obj = models.Question.query.join(models.Anschoice).filter\
(models.Question.qzid == qzid).all()
#User must tick one checkbox per ques and only one
ansidlist = request.form.getlist("choices")
#Getting a list of qid, ansid answeres- [[qid, ansid, anstext],...]
qanslist = []
for i in range(len(ques_obj)):
tmplist = ansidlist[i].encode('utf-8').split(',')
qanslist.append([int(tmplist[0]), int(tmplist[1]),tmplist[2]])
# Just for testing setting userid = 1
username = session['username']
user_obj = models.User.query.filter_by(username=username).first()
userid = user_obj.userid
#Check the attempt no for the quiz taker
qzattemptid_obj = models.QResult.query.with_entities(\
sqlalchemy.func.max(models.QResult.qzattemptid)).\
filter_by(qzid=qzid, userid=userid).first()
if (qzattemptid_obj == (None,)):
qzattemptid = 1
else:
qzattemptid = qzattemptid_obj[0] + 1
#Check quiz taker's answers against ones in the table
qindex = 0
Resultlist = []
for index in range(len(qanslist)):
qid=qanslist[index][0]
qscore = 0
for ans in ques_obj[index].anschoices:
if ((ans.qid == qanslist[index][0]) and
(ans.ansid == qanslist[index][1]) and
(ans.correct == True)):
#Correct ans increment score
qscore = 1
#Update results table with qz question score for user with timestmp
Resultlist.append(models.QResult(userid, qzid, qid, qzattemptid, \
qscore))
models.db.session.add_all(Resultlist)
models.db.session.commit()
utls.display_tables()
# Return response
response = make_response(render_template('answers.html',
ques_obj=ques_obj,
qzid=qzid,
qanslist=qanslist,
error=error),
200
)
return response
def post(self):
"""Login already existing user or add new user"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("UserAPI post fn: %s\nJson Request\n=============\n %s" %(request, request.json))
# Get values from request
args = self.reqparse.parse_args()
for key, value in args.iteritems():
if value is not None:
if (key == 'username'):
username = request.json['username']
if (key == 'password'):
password = request.json['password']
if (key == 'role'):
role = request.json['role']
if ((role != 'admin') and (role != 'user')):
response = handle_invalid_usage(InvalidUsageException
('Error: Role should be admin or user', \
status_code=400))
return response
# Check and Update tables
# This is implemented as if we are processing get /users
user_obj = models.User.query.filter_by(username=username).all()
user_index = None
for i in range(len(user_obj)):
if username in user_obj[i].username:
user_index = i
if user_index is not None:
#match encrypted password with one in table
if not bcrypt.check_password_hash(user_obj[user_index].password,
password):
response = handle_invalid_usage(InvalidUsageException
('Error: Password for user does not match',
status_code=401))
return response
else:
# Add new user
user_obj = models.User(username,
bcrypt.generate_password_hash(password),
role)
models.db.session.add(user_obj)
models.db.session.commit()
# Create flask session here with secret key based on username
# if 'username' not in session:
# session['username'] = username
# Return response
location = "/users/%s" % user_obj.userid
query_obj = models.User.query.filter_by(userid=user_obj.userid).all()
resource_fields = {'userid':fields.Integer}
user = marshal(query_obj, resource_fields)
response = jsonify(user=user)
response.status_code = 201
response.location = location
logs.info_(response)
utls.display_tables()
return response
def post(self, qzid, qid):
"""Answer question of quiz"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("QuestionAPI patch fn: %s \nJson Request\n=============\n %s"
%(request, request.json))
# Check if cookie user_session exists
userid, username = utls.get_user_from_hdr()
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException(
'Error: No active session found for this user',
status_code=404))
return response
# Check if question qid exists for qzid, raise error
query_obj = models.Question.query.filter(
models.Question.qid == qid,models.Question.qzid == qzid).all()
if not query_obj:
response = handle_invalid_usage(InvalidUsageException
('Error: Question to edit not found for ques',
status_code=400))
return response
args = self.reqparse.parse_args()
for key, value in args.iteritems():
if value is not None:
if (key == 'anschoices'):
anschoices = request.json['anschoices']
# Comparing quiz taker answers with actual ans choices in db
correct = True
query_obj = models.Anschoice.query.filter_by(qid=qid).all()
index = 0
for choice in query_obj:
if (unicode(query_obj[index].correct) !=
anschoices[index]["correct"]):
correct = False
index += 1
if correct:
#update the user table in the database
query_obj = models.User.query.filter_by(userid=userid).all()
cur_qzscore= query_obj[0].qzscore #get current quiz score
#increment quiz score
models.User.query.filter_by(userid=userid).\
update(dict(qzscore=cur_qzscore+1))
query_obj = models.Question.query.join(models.Anschoice).filter\
(models.Question.qid == qid).all()
location = "/quizzes/<int:qzid>/result %s" % qzid
# Return response
ans_fields = {'ans_choice':fields.String,
'correct':fields.Boolean
}
resource_fields = {'qid':fields.Integer,
'ques_text':fields.String,
'ans_text':fields.String,
'qzid':fields.Integer,
'anschoices':fields.Nested(ans_fields)
}
question = marshal(query_obj, resource_fields)
response = jsonify(question=question)
response.status_code = 200
response.location = location
logs.info_(response)
utls.display_tables()
return response
def post(self, qzid):
"""Add question to quiz"""
logs.debug_ ("_________________________________________________")
logs.debug_ ("QuestionsAPI post fn: %s \nJson Request\n=============\n %s"
%(request, request.json))
# Get userid from hdr
userid, username = utls.get_user_from_hdr()
if 'username' not in session:
response = handle_invalid_usage(InvalidUsageException
('Error: No active session for this user found',
status_code=404))
return response
# Get data from req
args = self.reqparse.parse_args()
for key, value in args.iteritems():
if value is not None:
if (key == 'ques_text'):
ques_text = request.json['ques_text']
if (key == 'ans_text'):
ans_text = request.json['ans_text']
if (key == 'anschoices'):
anschoices = request.json['anschoices']
# Post new data to table
qn_obj = models.Question(ques_text, ans_text, qzid, userid)
models.db.session.add(qn_obj)
# Update correspnoding relationship tables
#Quiz table
L = models.Quiz.query.filter_by(qzid = qzid).first()
models.Quiz.query.filter_by(qzid = qzid).update(dict(no_ques=
(L.no_ques+1)))
# Ans choices table
ansidL = []
for choice in range(len(anschoices)):
ans_obj = models.Anschoice(qzid,
qn_obj.qid,
anschoices[choice]["answer"],
anschoices[choice]["correct"]
)
models.db.session.add(ans_obj)
models.db.session.commit()
# Return response
location = "/quizzes/%s/questions/%s" % (qzid, qn_obj.qid)
query_obj = models.Question.query.join(models.Anschoice).\
filter(models.Question.qid == qn_obj.qid).all()
qid = qn_obj.qid
ans_fields = {'ans_choice':fields.String,
'correct':fields.Boolean
}
resource_fields = {'ques_text':fields.String,
'ans_text':fields.String,
'qzid':fields.Integer,
'qid':fields.Integer,
'anschoices':fields.Nested(ans_fields)
}
question = marshal(query_obj, resource_fields)
response = jsonify(question=question)
response.location = location
response.status_code = 201
logs.info_(response)
utls.display_tables()
return response
def qz_questions(qzid):
""" Class that defines methods for processing get/post requests
for /api/quizzes endpoint
"""
# GET /quizzes/qzid/questions
if request.method == 'GET':
error = None
"""Get all quiz questions"""
logs.debug_ ("_______________________________________________")
logs.debug_ ("QuizzesAPI get fn: %s" %(request))
# Query from quiz table
# Get qzid from query string parameters of get request
# In this case just create default?
# Query Question table
#Arch: modify query to get all questions
ques = models.Question.query.join(models.Anschoice).filter\
(models.Question.qzid == qzid).all()
# Return response
return render_template('questions.html', ques=ques, error=error)
#POST /quizzes/qzid/questions
else:
error = None
""" Get answers to all quiz questions"""
logs.debug_ ("_______________________________________________")
logs.debug_ ("QuizzesAPI Post fn: %s" %(request))
#get qz answers
#User must tick one checkbox and only one
ansidlist = request.form.getlist("choices")
# Just for testing setting userid = 1
userid = 1
#get all questions from Questions db
query_obj = models.Anschoice.query.all()
#Comparing quiz taker answers with actual ans choices in db
for el in range(len(ansidlist)):
for index in range(len(query_obj)):
correct = 0
if ((unicode(query_obj[index].ansid) == ansidlist[el]) and
(query_obj[index].correct == True)):
correct += 1
if correct:
#get current quiz score from user table db
usrquery_obj = models.User.query.filter_by(userid=userid).all()
cur_qzscore= usrquery_obj[0].qzscore
#increment quiz score and update user table in db
models.User.query.filter_by(userid=userid).\
update(dict(qzscore=cur_qzscore+1))
ans = models.Question.query.join(models.Anschoice).filter\
(models.Question.qzid == qzid).all()
#put query_obj info in list format
#questions[0].qid
#questions[0].ques_text
#questions[0].ans[0].ansid
#questions[0].ans[0].ans_choice
#questions[0].ans[0].correct
#get answers from quiz and put into placeholders in html
utls.display_tables()
# Return response
response = make_response(render_template('answers.html', ans=ans, error=error), 200)
return response
