def accessibility_view(self):
category = self._secure_get_category(int(self.request.matchdict['id']))
if self.request.params.get('nojs','0') != '1':
if not self.request.user.needs_accessibility:
return HTTPFound(location=route_url('category', self.request))
id = self.request.user.current_test
test = Tests.by(id).first()
results = TestsResults.by({'tests_id':id}, sort='id asc').all()
if 'form.submit' in self.request.params:
for key, value in self.request.params.iteritems():
key_type, sep, rid = key.rpartition(".")
if key_type == 'question':
result = TestsResults.by(rid).first()
passed = TestManager.check_answer_byid(result.question_sets_id, int(value))
result.correctly_answered = passed
if not passed:
result.wrong_attempts = test.max_wrong_answer_allowed
result.attempted = True
result.duration = self._accessibility_duration_calculator(self.request.params['st'], len(results), test.question_time_allowed)
final = self._test_calculator(test,results,result)
transaction.commit()
return HTTPFound(location=route_url('score', self.request, id=id))
else:
self.response['time_started'] = int(time.time())
self.response['test'] = test
self.response['results'] = []
for result in results:
self.response['results'].append({'question_set': result,
'answer': result.get_answers()})
return self.template('playing-accessibility.pt')
def next(self):
id = int(self.request.matchdict['id'])
category = self._secure_get_category(id)
self.response['finished'] = False
result = TestsResults.by({'tests_id':self.request.user.current_test, 'attempted':False}, sort='id asc').first()
if result:
c = Categories.by(id, user=self.request.user, permission=ACL.PLAY).first()
self.response['category'] = Result2Dict(c, purge=['category_intro'])
self.response['category']['transition_in'] = Result2Dict(c.get_transition_in())
self.response['category']['transition_out'] = Result2Dict(c.get_transition_out())
self.response['question'] = result.question
#self.response['answers'] = TestManager.get_answers(result.question_sets_id)
self.response['answers'] = result.get_answers()
result.attempted = True
user = Users.by(self.request.user.id).first()
user.current_question = result.question_sets_id
transaction.commit()
else:
test = Tests.by(self.request.user.current_test).first()
self.response['test_id'] = self.request.user.current_test
test.completed = True
transaction.commit()
self.response['finished'] = True
return self.response
def score(self):
id = self.request.matchdict['id']
test = Tests.by(id).first()
if not test:
raise HTTPNotFound()
elif test.alias == self.request.user.alias:
results = TestsResults.by({'tests_id':id}, sort='id asc').all()
self.response['test'] = test
self.response['test_total_time'] = Seconds2Str(test.time_spent)
self.response['librarian'] = test.id % 2 == 0
self.response['results'] = []
total = len(results)
self.response['category'] = None
self.response['assessment'] = None
try:
category = Categories.by({'name':test.category}).first()
self.response['category'] = category
self.response['assessment'] = category.assess_this(test.percentage)
except exc.SQLAlchemyError as e:
pass # defensive
for result in results:
self.response['results'].append( self.get_question_scores(result,
total,
test.max_wrong_answer_allowed,
test.question_time_allowed
))
else:
raise HTTPForbidden()
return self.template('score.pt')
def _generate_pdf(self, id):
test = Tests.by({'id':id,'alias':self.request.user.alias}).first()
if not test:
return None
elif test.alias == self.request.user.alias:
self.response['test'] = test
self.response['results'] = []
self.response['total_correct'] = 0
results = TestsResults.by({'tests_id':id}).all()
total = len(results)
for result in results:
self.response['results'].append( self.get_question_scores(result,
total,
test.max_wrong_answer_allowed,
test.question_time_allowed
))
if bool(result.correctly_answered):
self.response['total_correct'] += 1
self.response['category'] = None
self.response['assessment'] = None
try:
category = Categories.by({'name':test.category}).first()
self.response['category'] = category
self.response['assessment'] = category.assess_this(test.percentage)
except exc.SQLAlchemyError as e:
pass # defensive
pdf_html = self.template('pdf.pt')
io = StringIO.StringIO()
pisa.pisaDocument(StringIO.StringIO( pdf_html.text.encode( "UTF-8" )), io)
return io.getvalue()
else:
return None
def result(self):
from quizsmith.app.views.leaderboard import LeaderBoard
category = self._secure_get_category(int(self.request.matchdict['id']))
self.response['question'] = None
self.response['wrong_attempts'] = 0
self.response['duration'] = 0
test = Tests.by(self.request.user.current_test).first()
result = TestsResults.by({'tests_id':self.request.user.current_test, 'attempted':True}, sort='id desc').first()
results = TestsResults.by({'tests_id':self.request.user.current_test}).all()
questionset = QuestionSets.by(result.question_sets_id).first()
self.response['answer_help'] = questionset.answer_help
self.response['result'] = Result2Dict(result,purge=['id','tests_id','question_sets_id'])
final = self._test_calculator(test,results,result)
self.response['percentage'] = final['percentage']
self.response['competitive'] = final['competitive']
self.response['ranking'] = LeaderBoard.get_ranking(test)
transaction.commit()
return self.response
def check(self):
self.response['was_correct'] = -1
category = self._secure_get_category(int(self.request.matchdict['id']))
if 'answer' in self.request.params:
answer = self.request.params.get('answer','0')
duration = float(self.request.params['time'])
self.response['was_correct'] = TestManager.check_answer_byid(self.request.user.current_question, answer)
result = TestsResults.by({'tests_id':self.request.user.current_test, 'question_sets_id':self.request.user.current_question}).first()
self.log_if_error('Current Test: %d' % self.request.user.current_test)
self.log_if_error('Current Question: %d' % self.request.user.current_question)
self.log_if_error('Chosen Answer: %s' % answer)
self.log_if_error('Duration: %s' % duration)
test = Tests.by(self.request.user.current_test).first()
if not self.response['was_correct'] and duration > 0:
if result.wrong_attempts < test.max_wrong_answer_allowed:
result.wrong_attempts += 1
duration = duration - test.wrong_answer_time_penalty
# cheaters hacking more than duration will result in failure
if duration <= 0 or duration > test.question_time_allowed:
duration = 0
self.response['continue_on'] = True
if result.wrong_attempts == test.max_wrong_answer_allowed or self.response['was_correct'] or duration == 0:
self.response['continue_on'] = False
result.correctly_answered = self.response['was_correct']
result.duration = duration
answers = result.get_answers()
changed = []
for a in answers:
if a['id'] == int(answer):
checked = -1
if self.response['was_correct']:
checked = 1
changed.append({'id':a['id'],'content':a['content'],'answered':checked})
else:
changed.append(a)
result.set_answers(changed)
transaction.commit()
self.response['duration'] = int(duration)
return self.response
def _get_question_variation(self, questionset, last_test):
if last_test == None:
# First test has no past variations so just randomized
return self._random_question(questionset)
else:
# Use next variation and wrap back to beginning when at end
past_question = TestsResults.by({'tests_id':last_test.id, 'question_sets_id':questionset.id}).first()
questions = Questions.by({'question_sets_id':questionset.id}).all()
for i, question in enumerate(questions):
if past_question == None:
return self._random_question(questionset)
if past_question.question == question.question:
if (i+1) >= len(questions):
return questions[0].question
return questions[i+1].question
# purely defensive, should never hit this...
return self._random_question(questionset)
def percentage(self):
from quizsmith.app.models import TestsResults
count = TestsResults.by({'tests_id':self.id}).count()
return round((self.total_percentage / count), 1)
