def create_question(question, instructor, course, time):
if not isinstance(time, (int, long)):
time = 0
session.add(Question(instructor, course, question, False, time))
session.commit()
return render_template('handleQuestion.html',question=question)
def add_list(list):
for a_id, u_id in list:
if session.query(Schedule).filter(Schedule.answer_id == a_id,
Schedule.user_id == u_id).first() is None:
session.add(Schedule(a_id, u_id))
session.commit()
def process(self):
userid = g.lti.get_user_id()
try:
answer0 = int(request.values['answerzero'])
answer1 = int(request.values['answerone'])
bestanswer = int(request.values['bestanswer'])
except KeyError:
return abort(404)
except ValueError:
return abort(404)
if answer0 == bestanswer:
best = answer0
other = answer1
elif answer1 == bestanswer:
best = answer1
other = answer0
else:
return abort(404)
#try:
session.add(AnswerChoiceModel(userid,best,other))
session.commit()
#except:
# session.rollback()
return redirect('/')
def delete_question(qid):
question = Question.by_id(int(qid))
if g.lti.is_instructor():
session.delete(question)
session.commit()
return json.dumps({'deleted': g.lti.is_instructor()})
def __init__(self, request):
# lele add dummy questions le
if len(Question.get_all()) == 0:
print "I MAEK DUMMY SHIZZLE"
userID = g.lti.get_user_id()
q1 = Question("1","1","What am I?",True,1000)
q2 = Question("2","1","Who am I?",True,1000)
q3 = Question("3","1","Where am I?",True,1000)
session.add(q1)
session.add(q2)
session.add(q3)
a11 = AnswerModel("einseins",1,userID,0,1000.0)
a12 = AnswerModel("einszwei",1,1338, 0,1000.0)
a13 = AnswerModel("einsdrei",1,1339, 0,1000.0)
a21 = AnswerModel("zweieins",2,userID,0,1000.0)
a22 = AnswerModel("zweizwei",2,1338, 0,1000.0)
a23 = AnswerModel("zweidrei",2,1339, 0,1000.0)
a31 = AnswerModel("dreieins",3,userID,0,1000.0)
a32 = AnswerModel("dreizwei",3,1338, 0,1000.0)
a33 = AnswerModel("dreidrei",3,1339, 0,1000.0)
session.add(a11)
session.add(a12)
session.add(a13)
session.add(a21)
session.add(a22)
session.add(a23)
session.add(a31)
session.add(a32)
session.add(a33)
session.commit()
def edit_question(q_id, question, time):
"""Updates a question with given contents and activation status."""
if g.lti.is_instructor():
if question is None:
escaped_question = None
else:
escaped_question = escape(question)
escaped_time = escape(time)
q = Question.by_id(q_id)
q.question = escaped_question
q.time = int(time)
activate = q.answerable
session.add(q)
session.commit()
return json.dumps({"id": q_id,
"text": escaped_question,
"answerable": activate,
"time":time,
"check": g.lti.is_instructor()})
else:
return json.dumps({"id": q_id,
"text": question,
"answerable": activate,
"time": time,
"check": g.lti.is_instructor()})
def save(questionID, userID, answerText):
try:
ranking = ((session.query(UserModel).filter_by(userid=userID).one().trust - 1000.0) / 4) + 1000.0
except exc.InvalidRequestError:
ranking = 1000.0
session.add(AnswerModel(questionID=questionID, userID=userID, text=answerText, edit=0, ranking=ranking))
session.commit()
def delete_userquestion(qid):
'''removes the question with the provided id from the database'''
question = UserQuestion.by_id(int(qid))
if g.lti.is_instructor():
session.delete(question)
session.commit()
return json.dumps({'deleted': g.lti.is_instructor()})
def add_tag(name):
if session.query(Tag.name).filter(Tag.name == name).first() is None:
tag = Tag(name)
session.add(tag)
session.commit()
return tag.id
else:
return False
def create_question(question, instructor, course, active, time, comment, tags, rating):
'''formats a question for database insertion and inserts it, calls a result screen afterwards'''
try:
time = int(time)
except ValueError:
time = 0
session.add(Question(instructor, course, question, active, time, comment, tags, rating))
session.commit()
def get_list():
questions = Question.get_filtered()
for question in questions:
if question is not None and question.activate_time is not None:
if question.get_time_left() < 0:
question.answerable = False
session.commit()
return render_template('question_list.html', questions=questions)
def save(uid,uname):
user = UserModel.by_user_id(uid)
if user is None:
session.add(UserModel(userid=uid,username=uname))
session.commit()
elif user.username != uname:
user.username = uname
session.commit()
def __init__(self):
# create a few database items
for model in session.query(Question):
break
else:
session.add(Question("1","What am I?",True))
session.add(Question("1","Who am I?",True))
session.add(Question("1","Where am I?",True))
session.commit()
def setTrust(uID, trust):
# set current trust (in usermodel)
user = session.query(UserModel).filter_by(userid=uID).one()
user.trust = trust
# fetch last known history record
old = UserHistoryModel.get_user_latest_data(uID)
# create a new trust entry in userhistory
history = UserHistoryModel(uID, trust, old.answered, old.asked)
session.add(history)
session.commit()
def get_list_asked():
"""Retrieves questions asked by the user currently logged in."""
if g.lti.is_instructor():
# TODO: pagination, etc..... same goes for get_questions
session.commit()
return render_template('question_list.html',
questions=session.query(Question).filter_by(user_id=g.lti.get_user_id() ) )
else:
session.commit()
return render_template('question_list.html',
questions=session.query(Question).filter_by(user_id=g.lti.get_user_id() ) )
def get_list_table(limit,offset):
(questions, curpage, maxpages, startpage, pagecount) = Question.get_filtered_offset(limit,offset,orderby='created')
for question in questions:
if question is not None and question.activate_time is not None:
if question.get_time_left() < 0:
question.answerable = False
session.commit()
return render_template('question_list_tbl.html', questions=questions,
currentpage=curpage,startpage=startpage,pagecount=pagecount,maxpages=maxpages)
def create_question(question, instructor, course, active, time, comment, tags, rating):
'''Formats a question for database insertion and inserts it, calls a
result screen afterwards. Returns the id of the added question.'''
try:
time = int(time)
except ValueError:
time = 0
q = Question(instructor, course, question, active, time, comment, tags, rating)
session.add(q)
session.commit()
return q.id
def toggle_options(args):
try:
type = args['type']
except KeyError:
return
question = Question.by_id(args['id'])
if question is None:
return
if not g.lti.is_instructor() and type != 'Reviewable':
return
if question.state == 'Answerable' and (type == 'Inactive' or type == 'Reviewable' or type == 'Archived'):
AnswerModel.update_q_history(args['id'])
rv = None
if type == 'Inactive':
rv = question.inactive = True
question.answerable = question.reviewable = question.closed = False
question.state = 'Inactive'
if type == 'Answerable':
rv = question.answerable = True
question.activate_time = datetime.now()
question.inactive = question.reviewable = question.closed = False
question.state = 'Answerable'
elif type == 'Reviewable':
if not question.reviewable:
Scheduler(args['id'])
question.reviewable = True
rv = question.reviewable
question.inactive = question.answerable = question.closed = False
question.state = 'Reviewable'
elif type == 'Closed':
rv = question.closed = True
question.inactive = question.answerable = question.reviewable = False
question.state = 'Closed'
elif type == 'comments':
rv = question.comment = not question.comment
elif type == 'tags':
rv = question.tags = not question.tags
elif type == 'rating':
rv = question.rating = not question.rating
session.commit()
return json.dumps({"toggle": rv, "check": True})
def delete_question(qid):
'''removes the question with the provided id from the database'''
question = Question.by_id(int(qid))
if g.lti.is_instructor():
session.delete(question)
#Delete answers
quid = {"questionID": int(qid)}
answers = AnswerModel.get_filtered(**quid)
for x in answers:
session.delete(x)
session.commit()
return json.dumps({'deleted': g.lti.is_instructor()})
def get_list_to_answer():
"""Retrieves questions to be answered by the instructor (all questions )"""
if g.lti.is_instructor():
# TODO: pagination, etc..... same goes for get_questions
session.commit()
return render_template('answer_student_questions.html',
questions=session.query(Question).\
filter(Question.course_id == g.lti.get_course_id() ).\
filter(Question.course_id != g.lti.get_user_id() )) #Filter questions by instructor
#Only instructors can answer these questions
else:
return render_template('access_restricted.html')
def tearDown():
#close db connection
session.expunge_all()
session.commit()
session.flush()
Base.metadata.drop_all(engine)
#restore backup 'production'
dst = os.getcwd()+directory_separator+"db.sqlite"
src = os.getcwd()+directory_separator+"db_backup.sqlite"
if os.path.exists(dst):
os.remove(dst)
if os.path.exists(src):
os.rename(src, dst)
def calc_new_trust(self):
print "GET HERE "
winner = AnswerModel.get_by_answer_id(self.best_answer_id)
loser = AnswerModel.get_by_answer_id(self.other_answer_id)
winner_h = UserHistoryModel.get_by_user_id(winner.userID)
loser_h = UserHistoryModel.get_by_user_id(loser.userID)
new_trust = UserModel.newTrust(winner.userID, loser.userID)
#UserHistoryModel(winner.userID, new_trust[0], winner_h.answered, winner_h.asked)
#UserHistoryModel(loser.userID, new_trust[1], loser_h.answered, loser_h.asked)
session.add(UserHistoryModel(winner.userID, new_trust[0], 17, 22))
session.commit()
session.add(UserHistoryModel(loser.userID, new_trust[1], 17, 25))
session.commit()
def availability(args):
"""
Handles availability via the question_list form
"""
try:
type = args['type']
except KeyError:
return
question = Question.by_id(args['id'])
if question is None:
return
if not g.lti.is_instructor() and type != 'reviewable':
return
rv = None
if type == 'answerable':
rv = question.answerable = not question.answerable
question.activate_time = datetime.now()
elif type == 'reviewable':
if not question.reviewable:
Scheduler(args['id'])
question.reviewable = True
rv = question.reviewable
elif type == 'archived':
rv = question.archived = not question.archived
elif type == 'comments':
rv = question.comment = not question.comment
elif type == 'tags':
rv = question.tags = not question.tags
elif type == 'rating':
rv = question.rating = not question.rating
session.commit()
return rv
def save(uid,uname):
user = UserModel.by_user_id(uid)
if user is None:
# add user to UserModel
tmp = UserModel(userid=uid,username=uname)
tmp.trust = 1000.0
session.add(tmp)
session.commit()
# add user's first entry to UserHistoryModel
history = UserHistoryModel(uid, 1000.0, 0, 0)
session.add(history)
session.commit()
elif user.username != uname:
user.username = uname
session.commit()
def add_answertag(aid, tid):
if session.query(AnswerTag).filter(
AnswerTag.answer_id==aid,
AnswerTag.tag_id==tid).first() is None:
session.add(AnswerTag(aid, tid))
session.commit()
def remove_by_id(cls, id):
entry = cls.by_id(id)
if entry == None:
return
session.delete(entry)
session.commit()
def submit_rating(rating): session.add(Rating(rating)) session.commit()
def savereview(questionID, userID, answerText, edit):
session.add(AnswerModel(questionID=questionID,
userID=userID, text=answerText, edit=edit + 1))
session.commit()
def save(questionID, userID, answerText):
session.add(AnswerModel(
questionID=questionID, userID=userID, text=answerText, edit=0))
session.commit()
def remove(answer_id, tag_id):
for at in session.query(AnswerTag).filter(
AnswerTag.answer_id==answer_id,
AnswerTag.tag_id==tag_id):
session.delete(at)
session.commit()
