def student_list(request):
user = session_check(request)
if not user:
return redirect('base:login')
context = {'title': 'List of Students'}
answers = Answer.objects.filter(question__created_by=user,
is_active=True).order_by('-date')
students_pk_list = list(set(answers.values_list('created_by', flat=True)))
page = request.GET.get('page', 1)
rows = []
for student_id in students_pk_list:
student = get_object_or_None(TempUser, id=student_id)
answers_per_student = answers.filter(
created_by__id=student_id).order_by('-date')
latest_answer = answers_per_student.first()
latest_question = latest_answer.question
total_per_student = answers_per_student.count()
student_name = student.name if student else 'Anonymous Users'
rows.append({
'name': student_name,
'count': total_per_student,
'id': student_id,
'latest_question': latest_question,
'latest_answer': latest_answer
})
page_objects = paginate(page, rows)
context.update({'object_list': page_objects})
return render(request, 'base/student_list.html', context)
def answers_by_question_graph(request, question_id):
user = session_check(request)
if not user:
return redirect('base:login')
question = get_object_or_None(Question, id=question_id)
context = {'title': 'Answers: {}'.format(question.name)}
answers = Answer.objects.filter(question=question, is_active=True)
averages = []
emotion_labels = []
colors = []
response_count = []
for k, v in Emotion.EMOTION_COLORS:
answers_per_emotion = answers.filter(emotion=k)
intensity_list = answers_per_emotion.values_list('intensity',
flat=True)
response_count.append(answers_per_emotion.count())
if intensity_list:
intensity_average = sum(intensity_list) / len(intensity_list)
else:
intensity_average = 0
averages.append(intensity_average)
emotion_labels.append(k)
colors.append(v)
context.update({'total_count': answers.count()})
context.update({
'count': json.dumps(response_count),
'averages': json.dumps(averages),
'emotion_labels': json.dumps(emotion_labels),
'colors': json.dumps(colors),
})
return render(request, 'base/answers_graph.html', context)
def login(request):
context = {}
if 'user' in request.session:
request.session['user'] = ''
if 'student' in request.session:
request.session['student'] = ''
students = TempUser.objects.filter(user_type='s', is_active=True)
context['students'] = students
context['create_user_form'] = TempUserForm()
if request.method == 'POST':
name = request.POST.get('user', None)
code = request.POST.get('code', None)
if name:
login = get_object_or_None(TempUser, name=name, user_type='t')
if login:
request.session['user'] = login.id
request.session.set_expiry(6000)
return redirect('base:dashboard')
elif code:
questions = Question.objects.filter(code=code,
status='open',
is_active=True)
if questions and questions.count() == 1:
question = questions[0]
context.update({'question': question})
if not question.allow_anonymous:
student_id = request.POST.get('student', None)
student = get_object_or_None(TempUser,
id=student_id,
user_type='s')
if student:
request.session['student'] = student.id
request.session.set_expiry(600)
else:
msg = "You can't be anonymous in that session."
messages.error(request, msg)
return render(request, 'base/login_form.html', context)
url = reverse('base:answer_page', args=[question.id])
return redirect(url)
else:
msg = "Error! Either the session does not exist or it is already closed."
messages.error(request, msg)
return render(request, 'base/login_form.html', context)
def frequency_graph(request, question_id):
context = {}
user = session_check(request)
if not user:
return redirect('base:login')
question = get_object_or_None(Question, id=question_id)
answers = Answer.objects.filter(question=question, is_active=True)
context['emotions'] = Emotion.EMOTION_COLORS
return render(request, 'base/answer_page_old.html', context)
def answers_by_student(request, student_id):
user = session_check(request)
if not user:
return redirect('base:login')
page = request.GET.get('page')
student = get_object_or_None(TempUser, id=student_id)
context = {'title' : 'Student Responses: {}'.format(student.name)}
answers = Answer.objects.filter(question__created_by__id=user.id,
created_by=student, is_active=True).order_by('-date')
page_objects = paginate(page, answers)
context['object_list'] = page_objects
context['student'] = student
return render(request, 'base/answer_list.html', context)
def answer_list(request, *args, **kwargs):
user = session_check(request)
if not user:
return redirect('base:login')
context = {}
mode, mode_id = '', ''
if 'mode' in kwargs:
mode= kwargs.get('mode')
context['mode'] = True
if 'mode_id' in kwargs:
mode_id = kwargs.get('mode_id')
tag = request.GET.get('tag', None)
page = request.GET.get('page')
questions = Question.objects.filter(created_by=user, is_active=True)
tags = questions.values_list('tag', flat=True)
tags = list(set(filter(None, tags)))
context['tags'] = tags
title = 'All Answers'
answers = Answer.objects.filter(question__created_by__pk=user.id, is_active=True).order_by('-pk')
date_from = request.GET.get('date_from', None)
date_to = request.GET.get('date_to', None)
if date_from:
datefrom = date_from + " 00:00"
start_date = make_aware(datetime.datetime.strptime(datefrom, '%d-%m-%Y %H:%M'))
answers = answers.filter(date__gte=start_date)
context['date_from'] = date_from
if date_to:
dateto = date_to + " 23:59"
end_date = make_aware(datetime.datetime.strptime(dateto, '%d-%m-%Y %H:%M'))
answers = answers.filter(date__lte=end_date)
context['date_to'] = date_to
if mode == 'question':
question = get_object_or_None(Question, id=int(mode_id))
title = 'Answers to Question: {}'.format(question.name)
answers = answers.filter(question__id=int(mode_id))
context['question'] = question
elif (tag and tag != 'all') or mode == 'tag':
if tag:
mode_id = tag
context['tag'] = mode_id
title = 'Answers by Tag: {}'.format(mode_id)
answers = answers.filter(question__tag=mode_id)
page_objects = paginate(page, answers)
context['title'] = title
context['object_list'] = page_objects
context['count'] = answers.count()
context['mode'] = mode
return render(request, 'base/answer_list.html', context)
def answers_by_student_graph(request, student_id=None):
user = session_check(request)
if not user:
return redirect('base:login')
context = {}
if student_id:
student = get_object_or_None(TempUser, id=student_id)
context.update({'title': 'Student: {}'.format(student.name)})
answers = Answer.objects.filter(question__created_by=user,
created_by=student,
is_active=True)
else:
student = 0
context.update({'title': 'Anonymous responses'})
answers = Answer.objects.filter(question__created_by=user,
created_by=None,
is_active=True)
context['student'] = student
averages = []
emotion_labels = []
colors = []
response_count = []
for k, v in Emotion.EMOTION_COLORS:
answers_per_emotion = answers.filter(emotion=k)
intensity_list = answers_per_emotion.values_list('intensity',
flat=True)
response_count.append(answers_per_emotion.count())
if intensity_list:
intensity_average = sum(intensity_list) / len(intensity_list)
else:
intensity_average = 0
averages.append(intensity_average)
emotion_labels.append(k)
colors.append(v)
context.update({'total_count': answers.count()})
context.update({
'count': json.dumps(response_count),
'averages': json.dumps(averages),
'emotion_labels': json.dumps(emotion_labels),
'colors': json.dumps(colors),
})
return render(request, 'base/answers_graph.html', context)
def answer_page(request, question):
context = {}
student = student_session_check(request, question)
if not student:
return redirect('base:login')
question = get_object_or_404(Question, pk=question)
context.update({
'student':student,
'question':question,
'title': 'Answer Page',
'form': AnswerForm(initial={'question':question})})
if request.method == 'POST':
valid = False
form = AnswerForm(request.POST)
student = request.POST.get('student', None)
if not question.allow_anonymous:
if student:
form = AnswerForm(request.POST, student=student)
valid = True
else:
msg = 'Error! This question requires a username.'
context.update({'message':msg})
else:
valid = True
if valid:
if form.is_valid():
instance = form.save(commit=False)
other_text = request.POST.get('other_text', None)
if not question.allow_anonymous:
student_obj = get_object_or_None(TempUser, id=student)
instance.created_by = student_obj
if other_text:
instance.note = other_text
instance.save()
msg = 'Thank you! Your answer has been recorded.'
context.update({'message': msg })
context['form'] = form
return render(request, 'base/answer_page.html', context)
def __call__(self, request):
logger.debug('inside process_request %s' % request.path)
# create the tool provider instance
request_is_valid = True
# AuthenticationMiddleware is required so that request.user exists.
if not hasattr(request, 'user'):
logger.debug('improperly configured: requeset has no user attr')
raise ImproperlyConfigured(
"The Django LTI auth middleware requires the"
" authentication middleware to be installed. Edit your"
" MIDDLEWARE_CLASSES setting to insert"
" 'django.contrib.auth.middleware.AuthenticationMiddleware'"
" before the PINAuthMiddleware class.")
message_type = request.POST.get('lti_message_type')
consumer_key = request.POST.get('oauth_consumer_key')
lti_version = request.POST.get("lti_version")
roles = request.POST.get("roles")
consumer_db = get_object_or_None(Consumer, key=consumer_key)
if (request.method == 'POST' and lti_version and roles
and message_type == 'basic-lti-launch-request'
and consumer_key == consumer_db.key):
user_roles = request.POST.get('roles')
if 'Instructor' in user_roles.split(','):
user_type = 't'
else:
user_type = 's'
name = request.POST.get('lis_person_name_given')
family_name = request.POST.get('lis_person_name_family')
email = request.POST.get('tool_consumer_instance_contact_email')
user, created = TempUser.objects.get_or_create(
name=name,
family_name=family_name,
email=email,
user_type=user_type)
if user:
# User is valid. Set request.user and persist user in the session
# by logging the user in.
logger.debug(
'user was successfully authenticated; now log them in')
request.user = user
lti_launch = {
'context_id':
request.POST.get('context_id', None),
'context_label':
request.POST.get('context_label', None),
'context_title':
request.POST.get('context_title', None),
'context_type':
request.POST.get('context_type', None),
'custom_canvas_account_id':
request.POST.get('custom_canvas_account_id', None),
'custom_canvas_account_sis_id':
request.POST.get('custom_canvas_account_sis_id', None),
'custom_canvas_api_domain':
request.POST.get('custom_canvas_api_domain', None),
'custom_canvas_course_id':
request.POST.get('custom_canvas_course_id', None),
'custom_canvas_membership_roles':
request.POST.get('custom_canvas_membership_roles',
'').split(','),
'custom_canvas_enrollment_state':
request.POST.get('custom_canvas_enrollment_state', None),
'custom_canvas_user_id':
request.POST.get('custom_canvas_user_id', None),
'custom_canvas_user_login_id':
request.POST.get('custom_canvas_user_login_id', None),
'launch_presentation_css_url':
request.POST.get('launch_presentation_css_url', None),
'launch_presentation_document_target':
request.POST.get('launch_presentation_document_target',
None),
'launch_presentation_height':
request.POST.get('launch_presentation_height', None),
'launch_presentation_locale':
request.POST.get('launch_presentation_locale', None),
'launch_presentation_return_url':
request.POST.get('launch_presentation_return_url', None),
'launch_presentation_width':
request.POST.get('launch_presentation_width', None),
'lis_course_offering_sourcedid':
request.POST.get('lis_course_offering_sourcedid', None),
'lis_outcome_service_url':
request.POST.get('lis_outcome_service_url', None),
'lis_person_contact_email_primary':
request.POST.get('lis_person_contact_email_primary', None),
'lis_person_name_family':
request.POST.get('lis_person_name_family', None),
'lis_person_name_full':
request.POST.get('lis_person_name_full', None),
'lis_person_name_given':
request.POST.get('lis_person_name_given', None),
'lis_person_sourcedid':
request.POST.get('lis_person_sourcedid', None),
'lti_message_type':
request.POST.get('lti_message_type', None),
'resource_link_description':
request.POST.get('resource_link_description', None),
'resource_link_id':
request.POST.get('resource_link_id', None),
'resource_link_title':
request.POST.get('resource_link_title', None),
'roles':
request.POST.get('roles', '').split(','),
'selection_directive':
request.POST.get('selection_directive', None),
'tool_consumer_info_product_family_code':
request.POST.get('tool_consumer_info_product_family_code',
None),
'tool_consumer_info_version':
request.POST.get('tool_consumer_info_version', None),
'tool_consumer_instance_contact_email':
request.POST.get('tool_consumer_instance_contact_email',
None),
'tool_consumer_instance_description':
request.POST.get('tool_consumer_instance_description',
None),
'tool_consumer_instance_guid':
request.POST.get('tool_consumer_instance_guid', None),
'tool_consumer_instance_name':
request.POST.get('tool_consumer_instance_name', None),
'tool_consumer_instance_url':
request.POST.get('tool_consumer_instance_url', None),
'user_id':
request.POST.get('user_id', None),
'user_image':
request.POST.get('user_image', None),
}
request.session['LTI_LAUNCH'] = lti_launch
setattr(request, 'LTI', request.session.get('LTI_LAUNCH', {}))
if not hasattr(request, 'LTI'):
logger.warning("Could not find LTI launch parameters")
if not request.path.startswith(reverse(
'admin:index')) and 'LTI_LAUNCH' not in request.session:
return HttpResponse(
"Sorry, your request to enter has been denied.")
return self.get_response(request)
