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