def get(self, request, *args, **kwargs):
self.object = self.get_object(queryset=self.model.objects.filter(
course__code=self.kwargs["course_code"]))
self.assessment = self.object
# Determine if user has permission to view assessment or solution.
# Only users with administer privileges can view solution this way.
# All others can view solution only through injecting
# solution of individual questions via the "show solution" button
# (where solution views are tracked).
has_permission=False
if user_can_administer_assessment(request.user,
course=self.object.course):
has_permission=True
elif not self.solution and self.object.user_can_view(
request.user, solution=False):
has_permission=True
if not has_permission:
return redirect("mi-forbidden")
try:
self.number_in_thread=int(request.GET.get('n',1))
except TypeError:
self.number_in_thread=1
try:
self.determine_version_attempt(
user=request.user,seed=request.GET.get('seed'),
content_attempt_id = request.GET.get('content_attempt'),
question_attempt_ids = request.GET.get('question_attempts'),
)
except ValueError as e:
from django.template import Template, Context
template_string = "{% extends 'base.html' %}{% block content %}"
template_string += "<p>%s</p>" % e
template_string += "{% endblock %}"
context = Context({'STATIC_URL': settings.STATIC_URL})
return HttpResponse(Template(template_string).render(context))
# update selected course for course users
# self.course_enrollment set by determine_version_attempt
if self.course_enrollment \
and self.course_enrollment != \
request.user.courseuser.selected_course_enrollment:
request.user.courseuser.selected_course_enrollment =\
self.course_enrollment
with transaction.atomic():
request.user.courseuser.save()
# update session with last course viewed
request.session['last_course_viewed'] = self.object.course.id
context = self.get_context_data(object=self.object)
return self.render_to_response(context)
def get(self, request, *args, **kwargs):
self.get_object_thread_content()
try:
self.number_in_thread=int(request.GET.get('n',1))
except TypeError:
self.number_in_thread=1
# determine if user has instructor or designer access
if not user_can_administer_assessment(request.user, course=self.course):
return redirect("mi-forbidden")
self.coursewide_attempts_include = []
self.coursewide_attempts_avoid = []
form = self.get_form()
context = self.get_context_data(form=form)
return self.render_to_response(context)
def post(self, request, *args, **kwargs):
self.get_object_thread_content()
try:
self.number_in_thread=int(request.GET.get('n',1))
except TypeError:
self.number_in_thread=1
# determine if user has instructor or designer access
if not user_can_administer_assessment(request.user, course=self.course):
return redirect("mi-forbidden")
form = self.get_form()
self.coursewide_attempts_include = request.POST.getlist(
"include_cca_ids")
self.coursewide_attempts_avoid = request.POST.getlist("avoid_cca_ids")
if form.is_valid():
return self.form_valid(form)
else:
return self.form_invalid(form)
def get_context_data(self, **kwargs):
context = super(AssessmentView, self).get_context_data(**kwargs)
from midocs.functions import return_new_auxiliary_data
auxiliary_data = return_new_auxiliary_data()
context['_auxiliary_data_'] = auxiliary_data
import random
rng=random.Random()
# show post user response errors only if instructor permissions
if user_has_given_assessment_permission_level(
self.request.user, 2):
show_post_user_errors=True
else:
show_post_user_errors=False
from micourses.render_assessments import render_question_list
rendered_list=render_question_list(
self.assessment, self.question_list, rng=rng,
assessment_seed=self.assessment_seed,
user=self.request.user,
solution=self.solution,
auxiliary_data = auxiliary_data,
show_post_user_errors=show_post_user_errors)
# if question_only is set, then view only that question
if self.kwargs.get('question_only'):
question_only = int(self.kwargs['question_only'])
rendered_list=rendered_list[question_only-1:question_only]
context['question_only'] = question_only
context['rendered_list'] = rendered_list
context['seed'] = self.assessment_seed
# determine if there were any errors
success=True
question_errors=[]
for (ind,q) in enumerate(rendered_list):
if not q["question_data"]["success"]:
success=False
question_errors.append(str(ind+1))
if not success:
context['error_message'] = \
"Errors occurred in the following questions: %s" %\
", ".join(question_errors)
context['success'] = success
context['generate_course_attempt_link'] = False
context['show_solution_link'] = False
course = self.assessment.course
context['course'] = course
if user_can_administer_assessment(self.request.user, course=course):
if self.thread_content:
context['generate_course_attempt_link'] = True
if not self.solution:
context['show_solution_link'] = True
if self.thread_content:
context['assessment_name'] = self.thread_content.get_title()
else:
context['assessment_name'] = self.assessment.name
if self.solution:
context['assessment_name'] += " solution"
context['assessment_short_name'] = self.assessment.return_short_name()
if self.solution:
context['assessment_short_name'] += " sol."
if self.version:
context['version'] = self.version
context['assessment_name_with_version'] = "%s, version %s" % \
(context['assessment_name'], context['version'])
context['assessment_short_name_with_version'] = "%s, version %s" % \
(context['assessment_short_name'], context['version'])
else:
context['version'] = ''
context['assessment_name_with_version'] = context['assessment_name']
context['assessment_short_name_with_version'] \
= context['assessment_short_name']
if self.course_enrollment and self.thread_content:
if self.course_enrollment.role == STUDENT_ROLE and self.current_attempt:
due = self.thread_content.get_adjusted_due(
self.current_attempt.record)
if course.adjust_due_attendance and due:
due_date_url = reverse(
'micourses:adjusted_due_calculation',
kwargs={'course_code': course.code,
'content_id': self.thread_content.id }
)
from micourses.utils import format_datetime
current_tz = timezone.get_current_timezone()
due_string = format_datetime(current_tz.normalize(
due.astimezone(current_tz)))
due = mark_safe('<a href="%s">%s</a>' % \
(due_date_url, due_string))
context['due'] = due
else:
context['due'] = self.thread_content.get_adjusted_due()
context['thread_content'] = self.thread_content
context['number_in_thread'] = self.number_in_thread
context['current_attempt'] = self.current_attempt
context['users attempt'] = False
context['multiple_attempts'] = False
context['attempt_url']=None
context['record_url']=None
# set date from current_attempt, else as now
if self.current_attempt:
context['assessment_date'] = self.current_attempt.attempt_began
else:
context['assessment_date'] = timezone.now()
# Check if have current attempt that belongs to user
# (so can show score)
# Create links to record and attempts (if valid)
if self.current_attempt and \
self.current_attempt.record.enrollment == self.course_enrollment:
context['users_attempt'] = True
valid_attempt_list = list(
self.current_attempt.record.attempts.filter(valid=True))
context['multiple_attempts'] = len(valid_attempt_list)>1
context['record_url'] = reverse(
'micourses:content_record',
kwargs={'course_code': course.code,
'content_id': self.thread_content.id})
if self.current_attempt.valid:
attempt_number = valid_attempt_list.index(self.current_attempt)\
+1
context['attempt_url'] = reverse(
'micourses:content_attempt',
kwargs={'course_code': course.code,
'content_id': self.thread_content.id,
'attempt_number': attempt_number})
# add question attempt urls to rendered_list question_data
for (ind,q) in enumerate(rendered_list):
q["question_data"]["attempt_url"] = reverse(
'micourses:question_attempts',
kwargs={'course_code': course.code,
'content_id': self.thread_content.id,
'attempt_number': attempt_number,
'question_number': ind+1} )
from mitesting.utils import round_and_int
if self.thread_content:
context['thread_content_points'] = round_and_int(
self.thread_content.points)
if self.current_attempt is None or self.current_attempt.score is None:
context['attempt_score']=0
else:
context['attempt_score']=round_and_int(
self.current_attempt.score,1)
if self.current_attempt is None or \
self.current_attempt.record.score is None:
context['content_score']=0
else:
context['content_score']=round_and_int(
self.current_attempt.record.score,1)
# get list of the question numbers in assessment
# if instructor or designer in course
# if also staff, include links to admin pages
if user_can_administer_assessment(self.request.user, course=course):
question_numbers=[]
if self.request.user.is_staff:
context['assessment_admin_link'] = mark_safe(
"<p><a href='%s'>%s</a></p>" % (
reverse('admin:micourses_assessment_change',
args=(self.assessment.id,)),
'Admin link'))
for q in rendered_list:
# if staff, add link to admin page for quesiton
if self.request.user.is_staff:
question_numbers.append(
"<a href='%s'>%s</a>" % (
reverse('admin:mitesting_question_change',
args=(q['question'].id,)),
q['question'].id)
)
else:
question_numbers.append(str(q['question'].id))
question_numbers = ", ".join(question_numbers)
question_numbers = mark_safe(question_numbers)
else:
question_numbers=None
context['question_numbers']=question_numbers
# turn off Google analytics for localhost/development site
context['noanalytics']=(settings.SITE_ID <= 2)
from mitesting.utils import get_new_seed
context['new_seed']=get_new_seed(rng)
return context
def get_context_data(self, **kwargs):
context = super(AssessmentOverview, self).get_context_data(**kwargs)
# thread_content will be None
# if assessment is not in thread and number in thread is 1
try:
thread_content = self.assessment.determine_thread_content(
self.number_in_thread)
except ObjectDoesNotExist:
raise Http404("No assessment found")
context['thread_content']=thread_content
context['number_in_thread'] = self.number_in_thread
course = self.assessment.course
context['course'] = course
if thread_content:
context['assessment_name'] = thread_content.get_title()
else:
context['assessment_name'] = self.assessment.name
from mitesting.utils import round_and_int
if thread_content:
context['thread_content_points'] = round_and_int(
thread_content.points)
try:
student = self.request.user.courseuser
except AttributeError:
student = None
if student:
try:
cr= thread_content.contentrecord_set.get(
enrollment__student=student)
except ObjectDoesNotExist:
cr = None
if cr:
student_score = cr.score
if student_score is not None:
context['content_score']=round_and_int(student_score,1)
else:
context['content_score'] = '--'
context['have_user_score'] = True
context['record_url'] = reverse(
'micourses:content_record',
kwargs={'course_code': course.code,
'content_id': thread_content.id})
context['assigned'] = thread_content.assigned
due = thread_content.get_adjusted_due(student=student)
if student and course.adjust_due_attendance and due:
due_date_url = reverse(
'micourses:adjusted_due_calculation',
kwargs={'course_code': course.code,
'content_id' :thread_content.id }
)
from micourses.utils import format_datetime
current_tz = timezone.get_current_timezone()
due_string = format_datetime(current_tz.normalize(
due.astimezone(current_tz)))
due = mark_safe('<a href="%s">%s</a>' % \
(due_date_url, due_string))
context['due']=due
# user has permission to view the assessment, given privacy level
if self.assessment.user_can_view(self.user, solution=False):
if self.number_in_thread > 1:
get_string = "n=%s" % self.number_in_thread
else:
get_string=""
if thread_content and thread_content.substitute_title:
context['assessment_link'] = self.assessment.return_direct_link(
link_text=thread_content.substitute_title,
get_string=get_string)
else:
context['assessment_link'] = self.assessment.return_direct_link(
get_string=get_string)
else:
context['assessment_link'] = None
# generate assessment link if can administer and thread content exists
if thread_content and user_can_administer_assessment(
self.user, course=course):
context['generate_course_attempt_link'] = True
else:
context['generate_course_attempt_link'] = False
# turn off Google analytics for localhost/development site
context['noanalytics']=(settings.SITE_ID <= 2)
return context