def edit_question(self):
self.response['category'] = self.request.matchdict['category']
Categories.by(self.response['category'], user=self.request.user, permission=ACL.EDIT, strict=True).first() # security
question = self.request.matchdict['id']
self.response['option'] = question
if question == 'new':
if 'form.submit' in self.request.params or 'form.submit.next' in self.request.params:
qs = QuestionSets(category_id=int(self.response['category']))
DBSession.add(qs)
DBSession.flush()
qs = QuestionSets.by(None, sort='id desc').first()
id = qs.id
self._transaction(qs, self.request.params)
if 'form.submit.next' in self.request.params:
return HTTPFound(location=self.request.application_url + self.request.path)
return HTTPFound(location=self.request.application_url + self.request.path + '/../' + str(id))
else:
qs = QuestionSets.by(question).first()
q = Questions.by({'question_sets_id':qs.id}).all()
wa = Answers.by({'question_sets_id':qs.id,'is_correct':False}, sort='position asc').all()
ca = Answers.by({'question_sets_id':qs.id,'is_correct':True}).first()
self.response['question_sets'] = qs
self.response['questions'] = q
self.response['wrong_answers'] = wa
self.response['correct_answer'] = ca
if 'form.submit' in self.request.params or 'form.submit.next' in self.request.params:
self.notify('Changes saved!')
self._transaction(qs, self.request.params)
if 'form.submit.next' in self.request.params:
return HTTPFound(location=self.request.application_url + self.request.path + '/../new')
return HTTPFound(location=self.request.application_url + self.request.path)
return self.template('/edit-question.pt', theme='AdminPanel')
def edit_home(self):
if 'form.submit' in self.request.params:
for k,v in self.request.params.iteritems():
if k.isdigit():
c = Categories.by(k).first()
c.position = v;
DBSession.flush()
transaction.commit()
self.notify('Changes saved!')
return HTTPFound(location=self.request.application_url + '/edit')
return self.template('/edit-home.pt', theme='AdminPanel')
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 export_category(self):
category_id = int(self.request.matchdict['category'])
category = Result2Dict(Categories.by(category_id).first())
sa_qs = QuestionSets.by({'category_id':category_id}).all()
question_sets = []
for qs in sa_qs:
questions = []
answers = []
# Get QuestionSet Transform
d_qs = Result2Dict(qs)
# Get All Questions in QuestionSet and Transform
sa_q = Questions.by({'question_sets_id':qs.id}).all()
for q in sa_q:
questions.append(Result2Dict(q))
d_qs['questions'] = questions
# Get All Answers in QuestionSet and Transform
sa_a = Answers.by({'question_sets_id':qs.id}).all()
for a in sa_a:
answers.append(Result2Dict(a))
d_qs['answers'] = answers
question_sets.append(d_qs)
return self._export_zip(json.dumps({'category' : category,
'question_sets' : question_sets},
sort_keys=True,
indent=4,
separators=(',', ': ')
))
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 edit_questions(self):
category = self.request.matchdict['category']
self.response['active_category'] = Categories.by(category, user=self.request.user, permission=ACL.EDIT, strict=True).first()
question_sets = QuestionSets.by({'category_id':category}).all()
self.response['question_sets'] = []
i = 1
for qs in question_sets:
self.response['question_sets'].append({
'rank' : i,
'id' : qs.id,
'answer_help' : qs.answer_help,
'questions' : Questions.by({'question_sets_id':qs.id}).all(),
'wrong_answers' : Answers.by({'question_sets_id':qs.id,'is_correct':False}).all(),
'correct_answer' : Answers.by({'question_sets_id':qs.id,'is_correct':True}).first(),
})
i += 1
return self.template('/edit-questions.pt', theme='AdminPanel')
def category_intro(self):
category = int(self.request.matchdict['id'])
if category:
self.response['category'] = Categories.by(category, user=self.request.user, permission=ACL.PLAY).first()
return self.template('category_intro.pt')
return HTTPFound(location=route_url('category', self.request))
def playing(self):
id = int(self.request.matchdict['id'])
category = self._secure_get_category(id)
if category:
use_accessibility_view = self.request.user.needs_accessibility
TestCreator(self.request.user, category.id)
if use_accessibility_view:
return HTTPFound(location=route_url('accessibility', self.request, id=id))
self.response['category'] = Categories.by(id).first()
return self.template('playing.pt')
def edit_category(self):
category_id = self.request.matchdict['category']
self.response['category_id'] = category_id
self.response['version'] = Addons.get_version('QuizSmith Core')
self.response['d2l_on'] = Validate.bool(self.settings('d2l_on'))
if 'form.submit' in self.request.params or 'form.submit.questions' in self.request.params:
active = None
if category_id == 'add':
active = Categories(name='New Category')
editors = []
for group in self.request.user.get_groups():
editors.append(str(group.id))
reviewers = []
for group in self.request.user.get_groups():
reviewers.append(str(group.id))
active.set_groups([], editors, reviewers)
DBSession.add(active)
DBSession.flush()
category_id = str(active.id)
else:
active = Categories.by(category_id, sort='position asc', user=self.request.user, permission=ACL.EDIT).first()
active.name = self.request.params.get('category.name','')
active.category_intro = self.request.params.get('category.intro','')
active.playable_questions = self.request.params.get('category.playable_questions',10)
active.wrong_answer_time_penalty = self.request.params.get('category.wrong_answer_time_penalty',5)
active.max_wrong_answer_allowed = self.request.params.get('category.max_wrong_answer_allowed',2)
active.question_time_allowed = self.request.params.get('category.question_time_allowed',30)
active.transition_in = self.request.params.get('category.transition_in','Random')
active.transition_out = self.request.params.get('category.transition_out','Random')
active.d2l_folder = self.request.params.get('category.d2l_folder','')
assesment_data = []
for key,v in self.request.params.iteritems():
if key.startswith('assessment'):
field_data = key.split('.')
row = {}
if not any(a['id'] == field_data[-1] for a in assesment_data):
assesment_data.append(row)
else:
row = filter(lambda x: x['id'] == field_data[-1], assesment_data)[0]
row['id'] = field_data[-1]
if v.isdigit():
row[field_data[1]] = int(v)
else:
row[field_data[1]] = str(v)
active.set_assessments(assesment_data)
editors = []
if self.request.params.getall('category.editable'):
editors = self.request.params.getall('category.editable')
else:
for g in active.groups:
if g.edit:
editors.append(str(g.groups_id))
reviewers = []
if self.request.params.getall('category.reviewable'):
reviewers = self.request.params.getall('category.reviewable')
else:
for g in active.groups:
if g.edit:
editors.append(str(g.groups_id))
active.set_groups(self.request.params.getall('category.playable'), editors, reviewers)
DBSession.flush()
transaction.commit()
self.notify('Changes saved!')
if 'form.submit.questions' in self.request.params:
return HTTPFound(location=self.request.application_url + '/edit/category/' + category_id + '/questions')
return HTTPFound(location=self.request.application_url + '/edit/category/' + category_id)
elif category_id == 'add':
self.response['active_category'] = Categories(name='New Category')
else:
self.response['active_category'] = Categories.by(category_id, sort='position asc', user=self.request.user, permission=ACL.EDIT, strict=True).first()
self.response['transitions_in'] = self.response['active_category'].transition_in
self.response['transitions_out'] = self.response['active_category'].transition_out
self.response['transitions'] = Transitions.all()
self.response['questions'] = QuestionSets.by({'category_id':category_id}).count()
self.response['all_edit_groups'] = Groups.by({'edit':True}).all()
self.response['all_play_groups'] = Groups.by({'play':True}).all()
self.response['all_review_groups'] = Groups.by({'review':True}).all()
self.response['play_groups'] = []
self.response['edit_groups'] = []
self.response['review_groups'] = []
if self.response['active_category'].groups:
for categorygroup in self.response['active_category'].groups:
group = Groups.by(categorygroup.groups_id).first()
if categorygroup.edit:
self.response['edit_groups'].append(group.name)
if categorygroup.play:
self.response['play_groups'].append(group.name)
if categorygroup.review:
self.response['review_groups'].append(group.name)
return self.template('/edit-category.pt', theme='AdminPanel')
def edit_groups(self):
self.response['email'] = self.request.params.get('edit.find.user','')
self.response['user'] = Users.by({'email':self.response['email']}).first()
self.response['editing_group'] = None
# add/remove users from groups
if 'edit.user.group.add.submit' in self.request.params:
id = self.request.params.get('edit.user.group.add','')
group = Groups.by(id).first()
self.response['user'].groups.append(Groups.by(id).first())
transaction.commit()
self.response['message'] = "Added user to group"
self.response['message_class'] = "info"
self.response['editing_group'] = Groups.by(id).first()
self.response['user'] = Users.by({'email':self.response['email']}).first()
if 'edit.user.group.remove.submit' in self.request.params:
id = self.request.params.get('edit.user.group.remove','')
self.response['user'].groups.remove(Groups.by(id).first())
transaction.commit()
self.response['message'] = "Removed user from group"
self.response['message_class'] = "info"
self.response['user'] = Users.by({'email':self.response['email']}).first()
if 'edit.group.find.submit' in self.request.params:
id = self.request.params.get('edit.group.find','')
self.response['editing_group'] = Groups.by(id).first()
if 'edit.group.edit.submit' in self.request.params:
id = self.request.params.get('edit.group.edit.id','')
group = Groups.by(id).first()
group.name = self.request.params.get('edit.group.edit.name','No name')
group.description = self.request.params.get('edit.group.edit.description','No Description')
group.play = Validate.bool(self.request.params.get('edit.group.edit.play', False))
group.edit = Validate.bool(self.request.params.get('edit.group.edit.edit', False))
group.review = Validate.bool(self.request.params.get('edit.group.edit.review', False))
cats = []
for cid in self.request.params.getall('edit.group.edit.categories'):
cats.append(Categories.by(int(cid)).first())
group.categories = cats
transaction.commit()
self.response['editing_group'] = Groups.by(id).first()
self.response['message'] = "Edit successful"
self.response['message_class'] = "info"
if 'edit.group.new.submit' in self.request.params:
i = Groups.newest().id + 1
DBSession.add(Groups(name='New Group' + str(i)))
transaction.commit()
self.response['editing_group'] = Groups.newest()
self.response['message'] = "Added new group"
self.response['message_class'] = "info"
if 'edit.group.delete.submit' in self.request.params:
id = int(self.request.params.get('edit.group.find','0'))
if id not in [1,2,3]:
try:
group = Groups.by(id).first()
DBSession.delete(group)
transaction.commit()
self.response['message'] = "Deleted group"
self.response['message_class'] = "info"
except exc.SQLAlchemyError:
self.response['message'] = "You can't delete this group. It has user and category dependencies."
else:
self.response['message'] = "You can't delete this permanent group"
self.response['groups'] = Groups.all()
self.response['categories'] = Categories.all()
return self.template('/edit-groups.pt', theme='AdminPanel')
def _secure_get_category(self,id):
category = Categories.by(id, user=self.request.user, permission=ACL.PLAY).first()
if category:
return category
raise HTTPForbidden()
def category(self):
if not self.request.user.alias:
return HTTPFound(location=route_url('alias', self.request))
self.response['categories'] = Categories.by(None, sort='position asc', user=self.request.user, permission=ACL.PLAY)
return self.template('category.pt')
def edit_groups(self):
lookup = self.request.params.get('edit.user.find','')
self.response['email'] = self.request.params.get('edit.user.find.email','')
self.response['user'] = Users.by({'email':self.response['email']}).first()
if self.response['user'] and lookup:
self.notify('User found')
if self.response['email'] and not self.response['user'] and lookup:
self.notify('No user found',warn=True)
self.response['editing_group'] = None
# add/remove users from groups
if 'edit.user.group.add.submit' in self.request.params:
id = self.request.params.get('edit.user.group.add','')
group = Groups.by(id).first()
self.response['user'].groups.append(Groups.by(id).first())
transaction.commit()
self.notify('Added user to group')
self.response['editing_group'] = Groups.by(id).first()
self.response['user'] = Users.by({'email':self.response['email']}).first()
if 'edit.user.group.remove.submit' in self.request.params:
id = self.request.params.get('edit.user.group.remove','')
self.response['user'].groups.remove(Groups.by(id).first())
transaction.commit()
self.notify('Removed user from group')
self.response['user'] = Users.by({'email':self.response['email']}).first()
if 'edit.group.find.submit' in self.request.params:
id = self.request.params.get('edit.group.find','')
self.response['editing_group'] = Groups.by(id).first()
if 'edit.group.edit.submit' in self.request.params:
id = self.request.params.get('edit.group.edit.id','')
group = Groups.by(id).first()
group.name = self.request.params.get('edit.group.edit.name','No name')
group.description = self.request.params.get('edit.group.edit.description','No Description')
group.play = Validate.bool(self.request.params.get('edit.group.edit.play', False))
group.edit = Validate.bool(self.request.params.get('edit.group.edit.edit', False))
group.review = Validate.bool(self.request.params.get('edit.group.edit.review', False))
cats = []
for cid in self.request.params.getall('edit.group.edit.categories'):
cats.append(Categories.by(int(cid)).first())
group.categories = cats
transaction.commit()
self.response['editing_group'] = Groups.by(id).first()
self.notify('Changes saved!')
if 'edit.group.new.submit' in self.request.params:
i = Groups.newest().id + 1
DBSession.add(Groups(name='New Group' + str(i)))
transaction.commit()
self.response['editing_group'] = Groups.newest()
self.notify('Added group!')
if 'edit.group.delete.submit' in self.request.params:
id = int(self.request.params.get('edit.group.find','0'))
if id not in [1,2,3]:
try:
group = Groups.by(id).first()
DBSession.delete(group)
transaction.commit()
self.notify('Removed group!')
except exc.SQLAlchemyError:
self.notify("You can't delete this group. It has user and category dependencies.",warn=True)
else:
self.notify("Can't remove permanent group!",warn=True)
self.response['groups'] = Groups.all()
self.response['categories'] = Categories.all()
return self.template('/edit-groups.pt', theme='AdminPanel')
def __init__(self, request):
super(EditBaseView, self).__init__(request)
self.response['categories'] = Categories.by(None, sort='position asc', user=self.request.user, permission=ACL.EDIT)
