def _generate_test(self):
category = Categories.by(self.category_id).first()
last_test = Tests.by({'category':category.name, 'alias':self.alias},sort='id desc').first()
# Create New Test
test = Tests(alias=self.alias, category=category.name, d2l_folder=category.d2l_folder, used_accessibility_view=self.used_accessibility_view)
# Copy values at time of generation, this in case values change in the future, personal results aren't effected.
test.wrong_answer_time_penalty = category.wrong_answer_time_penalty
test.max_wrong_answer_allowed = category.max_wrong_answer_allowed
test.question_time_allowed = category.question_time_allowed
DBSession.add(test)
DBSession.flush()
# Get and Randomize Questions
questionsets = QuestionSets.by({'category_id':self.category_id}).all()
random.shuffle(questionsets) # randomize first to guarentee all questions
questionsets = questionsets[0:category.playable_questions] # limit randomized
# Setup Unfinished Questions
for questionset in questionsets:
question = self._get_question_variation(questionset, last_test)
result = TestsResults(tests_id=test.id,
question_sets_id=questionset.id,
question=question,
answer_choices=TestManager.get_answers(questionset.id)
)
DBSession.add(result)
# okay below
DBSession.flush()
user = Users.by({'alias':self.alias}).first()
user.current_test = test.id
transaction.commit()
def leaderboardYourScore(self):
try:
category = urllib2.unquote(self.request.params.get('category','0'))
if category == '0':
best = Tests.by({'alias':self.request.user.alias, 'completed':1}, sort='total_competitive desc').filter(Tests.created>=LeaderBoard.archive_date()).first()
result = LeaderBoard.get_all_ranking(best)
else:
best = Tests.by({'category':category, 'alias':self.request.user.alias, 'completed':1}, sort='total_competitive desc').filter(Tests.created>=LeaderBoard.archive_date()).first()
result = LeaderBoard.get_ranking(best)
return {'status': True, 'rank': result['ranking'], 'total_competitive': result['total_competitive'], 'time_spent': Seconds2Str(result['time_spent']),
'total_time': Seconds2Str(best.total_time)}
except Exception as e:
return {'status': False}
def check_for_d2l_folder(self, id, folders):
test = Tests.by(id).first()
for folder in folders:
if folder['Name'] == test.d2l_folder:
return folder['Id']
return None
def d2l_dropbox_submit(self):
self.set_default_responses()
uc = self.get_user_context()
if not isinstance(uc, d2lauth.D2LUserContext):
return uc # if no user_context is setup, return uc to d2l to get authorized.
try:
test_id = self.request.params.get('id','0')
course = self.request.params.get('course_info','0|0').split('|')
course_org_unit = course[0]
d2l_folder = course[1]
pdf = Score(self.request)._generate_pdf(test_id)
test = Tests.by(test_id).first()
submission = d2ldata.D2LDropboxSubmission({'Name':'ANVIL_Submission_ID-' + test_id + '.pdf',
'DescriptorDict':{'Text': None, 'HTML':None},
'Stream':StringIO.StringIO(pdf),
'ContentType':'application/pdf',
})
response = d2lservice.create_my_submission_for_dropbox(uc, course_org_unit, d2l_folder, submission, return_request=True)
self.response['id'] = test_id
self.response['status'] = response.status_code
self.response['category'] = test.category
return self.template('dropbox.pt', theme='D2L')
except Exception as e:
print "ERROR 2: " + str(e) # log later?
return HTTPForbidden()
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 email(self):
id = self.request.matchdict['id']
test = Tests.by({'id':id,'alias':self.request.user.alias}).first()
if not test:
raise HTTPForbidden()
file = self._generate_pdf(id)
self.response['id'] = id
self.response['emails'] = self.request.params.get('email.addresses',None)
if 'form.submitted' in self.request.params:
if self.request.params['email.ok'] == '1':
emails = self.request.params['email.addresses'].replace(' ','').split(',')
for email in emails:
if not Validate.email(email):
self.notify('Invalid email address',warn=True)
return self.template('email.pt')
try:
message = Message(subject=self._email_fmt(id, str(Properties.get('MAILER_TO_SUBJECT','Submission'))),
sender=str(Properties.get('MAILER_GLOBAL_FROM_ADDRESS','System')),
recipients=emails,
body=self._email_fmt(id, str(Properties.get('MAILER_BODY','Submission'))))
attachment = Attachment('submission_' + str(id) + '.pdf', 'application/pdf', file)
message.attach(attachment)
mailer = get_mailer(self.request)
mailer.send(message)
self.notify('Email sent!')
except Exception as e:
print "ERROR: " + str(e)
self.notify('Unable to send email!',warn=True)
else:
self.notify('Unable to send example email!',warn=True)
return self.template('email.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 d2l_instructor_grades(self):
uc = self.get_user_context()
if not isinstance(uc, d2lauth.D2LUserContext):
return uc # if no user_context is setup, return uc to d2l to get authorized.
try:
students = []
category = self.request.params.get('category','---')
if category != '---':
id = self.request.matchdict['id']
classlist = d2lservice.get_classlist(uc,org_unit_id=id)
for student in classlist:
email = str(student.props['Username']) + self.settings('d2l_append_email_address','')
student_summary = {'name': str(student.props['DisplayName']),
'email': email,
'bestgrade' : 'Incomplete',
}
user = Users.by({'email':email}).first()
if user:
test = Tests.by({'alias':user.alias,'category':category}, sort='total_percentage desc').first()
if test:
student_summary['bestgrade'] = str(test.percentage) + '%'
students.append(student_summary)
self.response['students'] = students
self.response['categories'] = Categories.all()
return self.template('instructors-grades.pt', theme='D2L')
except Exception as e:
print "ERROR: " + str(e) # log later?
return HTTPForbidden()
def profile(self):
self.response['played'] = True
self.response['category'] = 0
self.response['tests'] = []
self.response['categories'] = []
self.response['format_time'] = Seconds2Str
try:
if 'category' in self.request.params:
self.response['category'] = self.request.params['category']
self.response['tests'] = Tests.by({'category':self.response['category'], 'alias':self.request.user.alias}, sort='id desc').all()
else:
self.response['categories'] = Tests.best_by_user_alias(self.request.user.alias)
except:
self.response['played'] = False
return self.template('profile.pt')
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 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 _email_fmt(self,id,text):
test = Tests.by(id).first()
text = text.replace('${CATEGORY}', test.category)
text = text.replace('${ALIAS}', test.alias)
return text
def edit_reports(self):
self.response['played_categories'] = Tests.by(None, sort='category asc').group_by('category').all()
return self.template('/edit-reports.pt', theme='AdminPanel')
