def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
get_user(self.request, self.object.pk) #TODO: Change permissions check
course = can_view_course(self.request, self.kwargs['course_id'])
act_quizzes = Activity.objects \
.filter(section__course=course, type=Activity.QUIZ) \
.order_by('section__order', 'order')
quizzes_attempted = 0
quizzes_passed = 0
course_pretest = None
quizzes = []
for aq in act_quizzes:
quiz, course_pretest, quizzes_attempted, quizzes_passed = \
process_quiz_activity(self.object, aq, course_pretest, quizzes_attempted, quizzes_passed)
quizzes.append(quiz)
activities_completed = course.get_activities_completed(
course, self.object)
activities_total = course.get_no_activities()
activities_percent = (activities_completed * 100) / activities_total
start_date, end_date = self.get_daterange()
activity = get_tracker_activities(start_date,
end_date,
self.object,
course=course)
order_options = [
'quiz_order', 'no_attempts', 'max_score', 'min_score',
'first_score', 'latest_score', 'avg_score'
]
default_order = 'quiz_order'
ordering = self.request.GET.get('order_by', default_order)
inverse_order = ordering.startswith('-')
if inverse_order:
ordering = ordering[1:]
if ordering not in order_options:
ordering = default_order
inverse_order = False
quizzes.sort(key=operator.itemgetter(ordering), reverse=inverse_order)
context['page_ordering'] = ('-' if inverse_order else '') + ordering
context['course'] = course
context['quizzes'] = quizzes
context['quizzes_passed'] = quizzes_passed
context['quizzes_attempted'] = quizzes_attempted
context['pretest_score'] = course_pretest
context['activities_completed'] = activities_completed
context['activities_total'] = activities_total
context['activities_percent'] = activities_percent
context['activity_graph_data'] = activity
return context
def get_queryset(self):
user = self.kwargs['user_id']
# check permissions, get_user raises PermissionDenied
get_user(self.request, user)
return QuizAttempt.objects \
.filter(user__pk=user) \
.order_by('-submitted_date', '-attempt_date')
def get_queryset(self):
user = self.kwargs['user_id']
# check permissions, get_user raises PermissionDenied
get_user(self.request, user)
quizzes = Quiz.get_by_activity_type(Activity.FEEDBACK)
return QuizAttempt.objects \
.filter(user__pk=user, quiz__in=quizzes) \
.order_by('-submitted_date', '-attempt_date')
def get_queryset(self):
user = self.kwargs['user_id']
quiz = self.kwargs['quiz_id']
# check permissions, get_user raises PermissionDenied
get_user(self.request, user)
return QuizAttempt.objects \
.filter(user__pk=user, quiz__pk=quiz) \
.order_by('-submitted_date', '-attempt_date') \
.prefetch_related('responses')
def user_activity(request, user_id):
view_user, response = get_user(request, user_id)
if response is not None:
return response
dashboard_accessed.send(sender=None, request=request, data=None)
cohort_courses, other_courses, all_courses = get_user_courses(
request, view_user)
courses = []
for course in all_courses:
data = {
'course':
course,
'no_quizzes_completed':
course.get_no_quizzes_completed(course, view_user),
'pretest_score':
course.get_pre_test_score(course, view_user),
'no_activities_completed':
course.get_activities_completed(course, view_user),
'no_quizzes_completed':
course.get_no_quizzes_completed(course, view_user),
'no_points':
course.get_points(course, view_user),
'no_badges':
course.get_badges(course, view_user),
}
courses.append(data)
activity = []
start_date = timezone.now() - datetime.timedelta(days=31)
end_date = timezone.now()
no_days = (end_date - start_date).days + 1
course_ids = list(
chain(cohort_courses.values_list('id', flat=True),
other_courses.values_list('id', flat=True)))
trackers = Tracker.objects.filter(course__id__in=course_ids,
user=view_user,
tracker_date__gte=start_date,
tracker_date__lte=end_date) \
.extra({'activity_date':"date(tracker_date)"}) \
.values('activity_date') \
.annotate(count=Count('id'))
for i in range(0, no_days, +1):
temp = start_date + datetime.timedelta(days=i)
count = next(
(dct['count']
for dct in trackers if dct['activity_date'] == temp.date()), 0)
activity.append([temp.strftime("%d %b %Y"), count])
return render_to_response('oppia/profile/user-scorecard.html', {
'view_user': view_user,
'courses': courses,
'activity_graph_data': activity
},
context_instance=RequestContext(request))
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
get_user(self.request, self.object.pk) #TODO: Change permissions check
cohort_courses, other_courses, all_courses = get_user_courses(
self.request, self.object)
courses = []
for course in all_courses:
course.can_view_course_activity = can_view_course_activity(
self.request, course.id)
courses.append(
UserCourseSummary.objects.get_stats_summary(
self.object, course))
order_options = [
'course_display', 'no_quizzes_completed', 'pretest_score',
'no_activities_completed', 'no_points', 'no_badges',
'no_media_viewed'
]
default_order = 'course_display'
ordering = self.request.GET.get('order_by', default_order)
inverse_order = ordering.startswith('-')
if inverse_order:
ordering = ordering[1:]
if ordering not in order_options:
ordering = default_order
inverse_order = False
courses.sort(key=operator.itemgetter(ordering), reverse=inverse_order)
start_date, end_date = self.get_daterange()
course_ids = list(
chain(cohort_courses.values_list('id', flat=True),
other_courses.values_list('id', flat=True)))
activity = get_tracker_activities(start_date,
end_date,
self.object,
course_ids=course_ids)
context['courses'] = courses
context['page_ordering'] = ('-' if inverse_order else '') + ordering
context['activity_graph_data'] = activity
return context
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['user'] = get_user(self.request, self.get_user_id())
context['advanced_search'] = self.filtered
for tracker in context['page_obj'].object_list:
tracker.data_obj = []
try:
data_dict = json.loads(tracker.data)
for key, value in data_dict.items():
tracker.data_obj.append([key, value])
except ValueError:
pass
tracker.data_obj.append(['agent', tracker.agent])
tracker.data_obj.append(['ip', tracker.ip])
return context
def get_queryset(self):
self.filtered = False
user = get_user(self.request, self.get_user_id())
trackers = Tracker.objects.filter(user=user).exclude(type__exact='')
start_date, end_date = self.get_daterange()
print(start_date)
print(end_date)
trackers = trackers.filter(tracker_date__gte=start_date, tracker_date__lte=end_date)
# filters = utils.get_filters_from_row(form, convert_date=False)
# if filters:
# trackers = trackers.filter(**filters)
# self.filtered = True
return trackers.order_by('-tracker_date')
def user_activity(request, user_id):
view_user, response = get_user(request, user_id)
if response is not None:
return response
dashboard_accessed.send(sender=None, request=request, data=None)
cohort_courses, other_courses, all_courses = get_user_courses(request, view_user)
courses = []
for course in all_courses:
data = {'course': course,
'no_quizzes_completed': course.get_no_quizzes_completed(course,view_user),
'pretest_score': course.get_pre_test_score(course,view_user),
'no_activities_completed': course.get_activities_completed(course,view_user),
'no_quizzes_completed': course.get_no_quizzes_completed(course,view_user),
'no_points': course.get_points(course,view_user),
'no_badges': course.get_badges(course,view_user),}
courses.append(data)
activity = []
start_date = timezone.now() - datetime.timedelta(days=31)
end_date = timezone.now()
no_days = (end_date-start_date).days + 1
course_ids = list(chain(cohort_courses.values_list('id',flat=True),other_courses.values_list('id',flat=True)))
trackers = Tracker.objects.filter(course__id__in=course_ids,
user=view_user,
tracker_date__gte=start_date,
tracker_date__lte=end_date) \
.extra({'activity_date':"date(tracker_date)"}) \
.values('activity_date') \
.annotate(count=Count('id'))
for i in range(0,no_days,+1):
temp = start_date + datetime.timedelta(days=i)
count = next((dct['count'] for dct in trackers if dct['activity_date'] == temp.date()), 0)
activity.append([temp.strftime("%d %b %Y"),count])
return render_to_response('oppia/profile/user-scorecard.html',
{'view_user': view_user,
'courses': courses,
'activity_graph_data': activity },
context_instance=RequestContext(request))
def user_course_activity_view(request, user_id, course_id):
view_user, response = get_user(request, user_id)
if response is not None:
return response
dashboard_accessed.send(sender=None, request=request, data=None)
course = can_view_course(request, course_id)
act_quizzes = Activity.objects.filter(section__course=course,type=Activity.QUIZ).order_by('section__order','order')
quizzes = []
for aq in act_quizzes:
quiz = Quiz.objects.get(quizprops__value=aq.digest, quizprops__name="digest")
attempts = QuizAttempt.objects.filter(quiz=quiz, user=view_user).order_by('submitted_date')[:settings.ISCHOOL_MAX_QUIZ_ATTEMPTS]
max_score = None
min_score = None
avg_score = None
first_score = None
latest_score = None
if attempts.count() > 0:
max_score = 100*float(attempts.aggregate(max=Max('score'))['max']) / float(attempts[0].maxscore)
min_score = 100*float(attempts.aggregate(min=Min('score'))['min']) / float(attempts[0].maxscore)
avg_score = 100*float(attempts.aggregate(avg=Avg('score'))['avg']) / float(attempts[0].maxscore)
first_date = attempts.aggregate(date=Min('attempt_date'))['date']
recent_date = attempts.aggregate(date=Max('attempt_date'))['date']
first_score = 100*float(attempts.filter(attempt_date = first_date)[0].score) / float(attempts[0].maxscore)
latest_score = 100*float(attempts.filter(attempt_date = recent_date)[0].score) / float(attempts[0].maxscore)
else:
max_score = None
min_score = None
avg_score = None
first_score = None
latest_score = None
quiz = {'quiz': aq,
'no_attempts': attempts.count(),
'max_score': max_score,
'min_score': min_score,
'first_score': first_score,
'latest_score': latest_score,
'avg_score': avg_score,
}
quizzes.append(quiz);
activity = []
start_date = timezone.now() - datetime.timedelta(days=31)
end_date = timezone.now()
no_days = (end_date-start_date).days + 1
trackers = Tracker.objects.filter(course=course,
user=view_user,
tracker_date__gte=start_date,
tracker_date__lte=end_date) \
.extra({'activity_date':"date(tracker_date)"}) \
.values('activity_date') \
.annotate(count=Count('id'))
for i in range(0,no_days,+1):
temp = start_date + datetime.timedelta(days=i)
count = next((dct['count'] for dct in trackers if dct['activity_date'] == temp.date()), 0)
activity.append([temp.strftime("%d %b %Y"),count])
return render_to_response('oppia/profile/user-course-scorecard.html',
{'view_user': view_user,
'course': course,
'quizzes': quizzes,
'activity_graph_data': activity },
context_instance=RequestContext(request))
def user_activity(request, user_id):
view_user, response = get_user(request, user_id)
profile=UserProfile.objects.get(user=view_user)
try:
version=Tracker.objects.filter(user=view_user,agent__contains='OppiaMobile Android').latest('submitted_date')
except Tracker.DoesNotExist:
version= None
try:
device=Tracker.objects.filter(user=view_user,agent__contains='Dalvik').latest('submitted_date')
except Tracker.DoesNotExist:
device= None
try:
school=SchoolCode.objects.filter(school_code=profile.school_code)
except SchoolCode.DoesNotExist:
school=None
if response is not None:
return response
cohort_courses, other_courses, all_courses = get_user_courses(request, view_user)
courses = []
for course in all_courses:
completed=course.get_activities_completed(course,view_user)+course.get_no_quizzes_completed(course,view_user)
total=course.get_no_activities()+course.get_no_quizzes()
percentage=(float(completed)/100)*total
data = {'course': course,
'no_quizzes_completed': course.get_no_quizzes_completed(course,view_user),
'pretest_score': course.get_pre_test_score(course,view_user),
'no_activities_completed': course.get_activities_completed(course,view_user),
'no_quizzes_completed': course.get_no_quizzes_completed(course,view_user),
'no_points': course.get_points(course,view_user),
'no_badges': course.get_badges(course,view_user),
'percentage_complete':float("{0:.6f}".format(percentage)),}
courses.append(data)
activity = []
start_date = timezone.now() - datetime.timedelta(days=31)
end_date = timezone.now()
no_days = (end_date-start_date).days + 1
course_ids = list(chain(cohort_courses.values_list('id',flat=True),other_courses.values_list('id',flat=True)))
trackers = Tracker.objects.filter(course__id__in=course_ids,
user=view_user,
tracker_date__gte=start_date,
tracker_date__lte=end_date) \
.extra({'activity_date':"date(tracker_date)"}) \
.values('activity_date') \
.annotate(count=Count('id'))
for i in range(0,no_days,+1):
temp = start_date + datetime.timedelta(days=i)
count = next((dct['count'] for dct in trackers if dct['activity_date'] == temp.date()), 0)
activity.append([temp.strftime("%d %b %Y"),count])
return render_to_response('oppia/profile/user-scorecard.html',
{'view_user': view_user,
'profile':profile,
'version':version,
'device':device,
'courses': courses,
'activity_graph_data': activity },
context_instance=RequestContext(request))
def user_course_activity_view(request, user_id, course_id):
view_user = get_user(request, user_id)
dashboard_accessed.send(sender=None, request=request, data=None)
course = can_view_course(request, course_id)
act_quizzes = Activity.objects \
.filter(section__course=course, type=Activity.QUIZ) \
.order_by('section__order', 'order')
quizzes_attempted = 0
quizzes_passed = 0
course_pretest = None
quizzes = []
for aq in act_quizzes:
quiz, course_pretest, quizzes_attempted, quizzes_passed = \
process_quiz_activity(view_user,
aq,
course_pretest,
quizzes_attempted,
quizzes_passed)
quizzes.append(quiz)
activities_completed = course.get_activities_completed(course, view_user)
activities_total = course.get_no_activities()
activities_percent = (activities_completed * 100) / activities_total
start_date = timezone.now() - datetime.timedelta(days=31)
end_date = timezone.now()
activity = get_tracker_activities(start_date,
end_date,
view_user,
course=course)
order_options = [
'quiz_order', 'no_attempts', 'max_score', 'min_score', 'first_score',
'latest_score', 'avg_score'
]
default_order = 'quiz_order'
ordering = request.GET.get('order_by', default_order)
inverse_order = ordering.startswith('-')
if inverse_order:
ordering = ordering[1:]
if ordering not in order_options:
ordering = default_order
inverse_order = False
quizzes.sort(key=operator.itemgetter(ordering), reverse=inverse_order)
return render(
request, 'profile/user-course-scorecard.html', {
'view_user': view_user,
'course': course,
'quizzes': quizzes,
'quizzes_passed': quizzes_passed,
'quizzes_attempted': quizzes_attempted,
'pretest_score': course_pretest,
'activities_completed': activities_completed,
'activities_total': activities_total,
'activities_percent': activities_percent,
'page_ordering': ('-' if inverse_order else '') + ordering,
'activity_graph_data': activity
})
def user_activity(request, user_id):
view_user = get_user(request, user_id)
dashboard_accessed.send(sender=None, request=request, data=None)
cohort_courses, other_courses, all_courses = get_user_courses(
request, view_user)
courses = []
for course in all_courses:
course_stats = UserCourseSummary.objects.filter(user=view_user,
course=course)
if course_stats:
course_stats = course_stats[0]
data = {
'course': course,
'course_display': str(course),
'no_quizzes_completed': course_stats.quizzes_passed,
'pretest_score': course_stats.pretest_score,
'no_activities_completed': course_stats.completed_activities,
'no_media_viewed': course_stats.media_viewed,
'no_points': course_stats.points,
'no_badges': course_stats.badges_achieved,
}
else:
data = {
'course': course,
'course_display': str(course),
'no_quizzes_completed': 0,
'pretest_score': None,
'no_activities_completed': 0,
'no_media_viewed': 0,
'no_points': 0,
'no_badges': 0,
}
courses.append(data)
order_options = [
'course_display', 'no_quizzes_completed', 'pretest_score',
'no_activities_completed', 'no_points', 'no_badges', 'no_media_viewed'
]
default_order = 'course_display'
ordering = request.GET.get('order_by', default_order)
inverse_order = ordering.startswith('-')
if inverse_order:
ordering = ordering[1:]
if ordering not in order_options:
ordering = default_order
inverse_order = False
courses.sort(key=operator.itemgetter(ordering), reverse=inverse_order)
start_date = timezone.now() - datetime.timedelta(days=31)
end_date = timezone.now()
course_ids = list(
chain(cohort_courses.values_list('id', flat=True),
other_courses.values_list('id', flat=True)))
activity = get_tracker_activities(start_date,
end_date,
view_user,
course_ids=course_ids)
return render(
request, 'profile/user-scorecard.html', {
'view_user': view_user,
'courses': courses,
'page_ordering': ('-' if inverse_order else '') + ordering,
'activity_graph_data': activity
})
def user_course_activity_view(request, user_id, course_id):
view_user, response = get_user(request, user_id)
if response is not None:
return response
dashboard_accessed.send(sender=None, request=request, data=None)
course = can_view_course(request, course_id)
act_quizzes = Activity.objects.filter(section__course=course,
type=Activity.QUIZ).order_by(
'section__order', 'order')
quizzes_attempted = 0
quizzes_passed = 0
course_pretest = None
quizzes = []
for aq in act_quizzes:
try:
quizobjs = Quiz.objects.filter(quizprops__value=aq.digest,
quizprops__name="digest")
if quizobjs.count() <= 0:
continue
else:
quiz = quizobjs[0]
except Quiz.DoesNotExist:
quiz = None
no_attempts = quiz.get_no_attempts_by_user(quiz, view_user)
attempts = QuizAttempt.objects.filter(quiz=quiz, user=view_user)
passed = False
if no_attempts > 0:
quiz_maxscore = float(attempts[0].maxscore)
attemps_stats = attempts.aggregate(max=Max('score'),
min=Min('score'),
avg=Avg('score'))
max_score = 100 * float(attemps_stats['max']) / quiz_maxscore
min_score = 100 * float(attemps_stats['min']) / quiz_maxscore
avg_score = 100 * float(attemps_stats['avg']) / quiz_maxscore
first_date = attempts.aggregate(date=Min('attempt_date'))['date']
recent_date = attempts.aggregate(date=Max('attempt_date'))['date']
first_score = 100 * float(
attempts.filter(
attempt_date=first_date)[0].score) / quiz_maxscore
latest_score = 100 * float(
attempts.filter(
attempt_date=recent_date)[0].score) / quiz_maxscore
passed = max_score is not None and max_score > 75
if aq.section.order == 0:
course_pretest = first_score
else:
quizzes_attempted += 1
quizzes_passed = (quizzes_passed +
1) if passed else quizzes_passed
else:
max_score = None
min_score = None
avg_score = None
first_score = None
latest_score = None
quiz = {
'quiz': aq,
'quiz_order': aq.order,
'no_attempts': no_attempts,
'max_score': max_score,
'min_score': min_score,
'first_score': first_score,
'latest_score': latest_score,
'avg_score': avg_score,
'passed': passed
}
quizzes.append(quiz)
activities_completed = course.get_activities_completed(course, view_user)
activities_total = course.get_no_activities()
activities_percent = (activities_completed * 100) / activities_total
start_date = timezone.now() - datetime.timedelta(days=31)
end_date = timezone.now()
activity = get_tracker_activities(start_date,
end_date,
view_user,
course=course)
order_options = [
'quiz_order', 'no_attempts', 'max_score', 'min_score', 'first_score',
'latest_score', 'avg_score'
]
default_order = 'quiz_order'
ordering = request.GET.get('order_by', default_order)
inverse_order = ordering.startswith('-')
if inverse_order:
ordering = ordering[1:]
if ordering not in order_options:
ordering = default_order
inverse_order = False
quizzes.sort(key=operator.itemgetter(ordering), reverse=inverse_order)
return render(
request, 'profile/user-course-scorecard.html', {
'view_user': view_user,
'course': course,
'quizzes': quizzes,
'quizzes_passed': quizzes_passed,
'quizzes_attempted': quizzes_attempted,
'pretest_score': course_pretest,
'activities_completed': activities_completed,
'activities_total': activities_total,
'activities_percent': activities_percent,
'page_ordering': ('-' if inverse_order else '') + ordering,
'activity_graph_data': activity
})
def user_course_activity_view(request, user_id, course_id):
view_user, response = get_user(request, user_id)
if response is not None:
return response
dashboard_accessed.send(sender=None, request=request, data=None)
course = can_view_course(request, course_id)
act_quizzes = Activity.objects.filter(section__course=course,
type=Activity.QUIZ).order_by(
'section__order', 'order')
quizzes = []
for aq in act_quizzes:
quiz = Quiz.objects.get(quizprops__value=aq.digest,
quizprops__name="digest")
attempts = QuizAttempt.objects.filter(
quiz=quiz, user=view_user).order_by(
'submitted_date')[:settings.ISCHOOL_MAX_QUIZ_ATTEMPTS]
max_score = None
min_score = None
avg_score = None
first_score = None
latest_score = None
if attempts.count() > 0:
max_score = 100 * float(
attempts.aggregate(max=Max('score'))['max']) / float(
attempts[0].maxscore)
min_score = 100 * float(
attempts.aggregate(min=Min('score'))['min']) / float(
attempts[0].maxscore)
avg_score = 100 * float(
attempts.aggregate(avg=Avg('score'))['avg']) / float(
attempts[0].maxscore)
first_date = attempts.aggregate(date=Min('attempt_date'))['date']
recent_date = attempts.aggregate(date=Max('attempt_date'))['date']
first_score = 100 * float(
attempts.filter(attempt_date=first_date)[0].score) / float(
attempts[0].maxscore)
latest_score = 100 * float(
attempts.filter(attempt_date=recent_date)[0].score) / float(
attempts[0].maxscore)
else:
max_score = None
min_score = None
avg_score = None
first_score = None
latest_score = None
quiz = {
'quiz': aq,
'no_attempts': attempts.count(),
'max_score': max_score,
'min_score': min_score,
'first_score': first_score,
'latest_score': latest_score,
'avg_score': avg_score,
}
quizzes.append(quiz)
activity = []
start_date = timezone.now() - datetime.timedelta(days=31)
end_date = timezone.now()
no_days = (end_date - start_date).days + 1
trackers = Tracker.objects.filter(course=course,
user=view_user,
tracker_date__gte=start_date,
tracker_date__lte=end_date) \
.extra({'activity_date':"date(tracker_date)"}) \
.values('activity_date') \
.annotate(count=Count('id'))
for i in range(0, no_days, +1):
temp = start_date + datetime.timedelta(days=i)
count = next(
(dct['count']
for dct in trackers if dct['activity_date'] == temp.date()), 0)
activity.append([temp.strftime("%d %b %Y"), count])
return render_to_response('oppia/profile/user-course-scorecard.html', {
'view_user': view_user,
'course': course,
'quizzes': quizzes,
'activity_graph_data': activity
},
context_instance=RequestContext(request))
def user_course_activity_view(request, user_id, course_id):
view_user, response = get_user(request, user_id)
if response is not None:
return response
dashboard_accessed.send(sender=None, request=request, data=None)
course = can_view_course(request, course_id)
act_quizzes = Activity.objects.filter(section__course=course,
type=Activity.QUIZ).order_by(
'section__order', 'order')
quizzes_attempted = 0
quizzes_passed = 0
course_pretest = None
quizzes = []
for aq in act_quizzes:
try:
quiz = Quiz.objects.get(quizprops__value=aq.digest,
quizprops__name="digest")
except Quiz.DoesNotExist:
quiz = None
attempts = QuizAttempt.objects.filter(quiz=quiz, user=view_user)
num_attempts = attempts.count()
passed = False
if num_attempts > 0:
quiz_maxscore = float(attempts[0].maxscore)
attemps_stats = attempts.aggregate(max=Max('score'),
min=Min('score'),
avg=Avg('score'))
max_score = 100 * float(attemps_stats['max']) / quiz_maxscore
min_score = 100 * float(attemps_stats['min']) / quiz_maxscore
avg_score = 100 * float(attemps_stats['avg']) / quiz_maxscore
first_date = attempts.aggregate(date=Min('attempt_date'))['date']
recent_date = attempts.aggregate(date=Max('attempt_date'))['date']
first_score = 100 * float(
attempts.filter(
attempt_date=first_date)[0].score) / quiz_maxscore
latest_score = 100 * float(
attempts.filter(
attempt_date=recent_date)[0].score) / quiz_maxscore
passed = max_score is not None and max_score > 75
if aq.section.order == 0:
course_pretest = first_score
else:
quizzes_attempted += 1
quizzes_passed = (quizzes_passed +
1) if passed else quizzes_passed
else:
max_score = None
min_score = None
avg_score = None
first_score = None
latest_score = None
quiz = {
'quiz': aq,
'quiz_order': aq.order,
'no_attempts': num_attempts,
'max_score': max_score,
'min_score': min_score,
'first_score': first_score,
'latest_score': latest_score,
'avg_score': avg_score,
'passed': passed
}
quizzes.append(quiz)
activities_completed = course.get_activities_completed(course, view_user)
activities_total = course.get_no_activities()
activities_percent = (activities_completed * 100) / activities_total
activity = []
start_date = timezone.now() - datetime.timedelta(days=31)
end_date = timezone.now()
no_days = (end_date - start_date).days + 1
trackers = Tracker.objects.filter(course=course,
user=view_user,
tracker_date__gte=start_date,
tracker_date__lte=end_date) \
.extra({'activity_date':"date(tracker_date)"}) \
.values('activity_date') \
.annotate(count=Count('id'))
for i in range(0, no_days, +1):
temp = start_date + datetime.timedelta(days=i)
count = next(
(dct['count']
for dct in trackers if dct['activity_date'] == temp.date()), 0)
activity.append([temp.strftime("%d %b %Y"), count])
order_options = [
'quiz_order', 'no_attempts', 'max_score', 'min_score', 'first_score',
'latest_score', 'avg_score'
]
default_order = 'quiz_order'
ordering = request.GET.get('order_by', default_order)
inverse_order = ordering.startswith('-')
if inverse_order:
ordering = ordering[1:]
if ordering not in order_options:
ordering = default_order
inverse_order = False
quizzes.sort(key=operator.itemgetter(ordering), reverse=inverse_order)
return render_to_response(
'oppia/profile/user-course-scorecard.html', {
'view_user': view_user,
'course': course,
'quizzes': quizzes,
'quizzes_passed': quizzes_passed,
'quizzes_attempted': quizzes_attempted,
'pretest_score': course_pretest,
'activities_completed': activities_completed,
'activities_total': activities_total,
'activities_percent': activities_percent,
'page_ordering': ('-' if inverse_order else '') + ordering,
'activity_graph_data': activity
},
context_instance=RequestContext(request))
def user_activity(request, user_id):
view_user, response = get_user(request, user_id)
profile = UserProfile.objects.get(user=view_user)
try:
version = Tracker.objects.filter(
user=view_user,
agent__contains='OppiaMobile Android').latest('submitted_date')
except Tracker.DoesNotExist:
version = None
try:
device = Tracker.objects.filter(
user=view_user, agent__contains='Dalvik').latest('submitted_date')
except Tracker.DoesNotExist:
device = None
try:
school = SchoolCode.objects.filter(school_code=profile.school_code)
except SchoolCode.DoesNotExist:
school = None
if response is not None:
return response
cohort_courses, other_courses, all_courses = get_user_courses(
request, view_user)
courses = []
for course in all_courses:
completed = course.get_activities_completed(
course, view_user) + course.get_no_quizzes_completed(
course, view_user)
total = course.get_no_activities() + course.get_no_quizzes()
percentage = (float(completed) / 100) * total
data = {
'course':
course,
'no_quizzes_completed':
course.get_no_quizzes_completed(course, view_user),
'pretest_score':
course.get_pre_test_score(course, view_user),
'no_activities_completed':
course.get_activities_completed(course, view_user),
'no_quizzes_completed':
course.get_no_quizzes_completed(course, view_user),
'no_points':
course.get_points(course, view_user),
'no_badges':
course.get_badges(course, view_user),
'percentage_complete':
float("{0:.6f}".format(percentage)),
}
courses.append(data)
activity = []
start_date = timezone.now() - datetime.timedelta(days=31)
end_date = timezone.now()
no_days = (end_date - start_date).days + 1
course_ids = list(
chain(cohort_courses.values_list('id', flat=True),
other_courses.values_list('id', flat=True)))
trackers = Tracker.objects.filter(course__id__in=course_ids,
user=view_user,
tracker_date__gte=start_date,
tracker_date__lte=end_date) \
.extra({'activity_date':"date(tracker_date)"}) \
.values('activity_date') \
.annotate(count=Count('id'))
for i in range(0, no_days, +1):
temp = start_date + datetime.timedelta(days=i)
count = next(
(dct['count']
for dct in trackers if dct['activity_date'] == temp.date()), 0)
activity.append([temp.strftime("%d %b %Y"), count])
return render_to_response('oppia/profile/user-scorecard.html', {
'view_user': view_user,
'profile': profile,
'version': version,
'device': device,
'courses': courses,
'activity_graph_data': activity
},
context_instance=RequestContext(request))
def user_activity(request, user_id):
view_user, response = get_user(request, user_id)
if response is not None:
return response
dashboard_accessed.send(sender=None, request=request, data=None)
cohort_courses, other_courses, all_courses = get_user_courses(
request, view_user)
courses = []
for course in all_courses:
course_stats = UserCourseSummary.objects.filter(user=view_user,
course=course)[0]
data = {
'course': course,
'no_quizzes_completed': course_stats.quizzes_passed,
'pretest_score': course_stats.pretest_score,
'no_activities_completed': course_stats.completed_activities,
'no_media_viewed': course_stats.media_viewed,
'no_points': course_stats.points,
'no_badges': course_stats.badges_achieved,
}
courses.append(data)
order_options = [
'course', 'no_quizzes_completed', 'pretest_score',
'no_activities_completed', 'no_points', 'no_badges', 'no_media_viewed'
]
default_order = 'course'
ordering = request.GET.get('order_by', default_order)
inverse_order = ordering.startswith('-')
if inverse_order:
ordering = ordering[1:]
if ordering not in order_options:
ordering = default_order
inverse_order = False
courses.sort(key=operator.itemgetter(ordering), reverse=inverse_order)
activity = []
start_date = timezone.now() - datetime.timedelta(days=31)
end_date = timezone.now()
no_days = (end_date - start_date).days + 1
course_ids = list(
chain(cohort_courses.values_list('id', flat=True),
other_courses.values_list('id', flat=True)))
trackers = Tracker.objects.filter(course__id__in=course_ids,
user=view_user,
tracker_date__gte=start_date,
tracker_date__lte=end_date) \
.extra({'activity_date':"date(tracker_date)"}) \
.values('activity_date') \
.annotate(count=Count('id'))
for i in range(0, no_days, +1):
temp = start_date + datetime.timedelta(days=i)
count = next(
(dct['count']
for dct in trackers if dct['activity_date'] == temp.date()), 0)
activity.append([temp.strftime("%d %b %Y"), count])
return render_to_response(
'oppia/profile/user-scorecard.html', {
'view_user': view_user,
'courses': courses,
'page_ordering': ('-' if inverse_order else '') + ordering,
'activity_graph_data': activity
},
context_instance=RequestContext(request))
def user_activity(request, user_id):
view_user, response = get_user(request, user_id)
if response is not None:
return response
dashboard_accessed.send(sender=None, request=request, data=None)
cohort_courses, other_courses, all_courses = get_user_courses(request, view_user)
courses = []
for course in all_courses:
course_stats = UserCourseSummary.objects.filter(user=view_user, course=course)[0]
data = {'course': course,
'no_quizzes_completed': course_stats.quizzes_passed ,
'pretest_score': course_stats.pretest_score,
'no_activities_completed': course_stats.completed_activities,
'no_media_viewed': course_stats.media_viewed,
'no_points': course_stats.points,
'no_badges': course_stats.badges_achieved,}
courses.append(data)
order_options = ['course', 'no_quizzes_completed', 'pretest_score',
'no_activities_completed','no_points', 'no_badges', 'no_media_viewed']
default_order = 'course'
ordering = request.GET.get('order_by', default_order)
inverse_order = ordering.startswith('-')
if inverse_order:
ordering = ordering[1:]
if ordering not in order_options:
ordering = default_order
inverse_order = False
courses.sort(key=operator.itemgetter(ordering), reverse=inverse_order)
activity = []
start_date = timezone.now() - datetime.timedelta(days=31)
end_date = timezone.now()
no_days = (end_date-start_date).days + 1
course_ids = list(chain(cohort_courses.values_list('id',flat=True),other_courses.values_list('id',flat=True)))
trackers = Tracker.objects.filter(course__id__in=course_ids,
user=view_user,
tracker_date__gte=start_date,
tracker_date__lte=end_date) \
.extra({'activity_date':"date(tracker_date)"}) \
.values('activity_date') \
.annotate(count=Count('id'))
for i in range(0,no_days,+1):
temp = start_date + datetime.timedelta(days=i)
count = next((dct['count'] for dct in trackers if dct['activity_date'] == temp.date()), 0)
activity.append([temp.strftime("%d %b %Y"),count])
return render_to_response('oppia/profile/user-scorecard.html',
{'view_user': view_user,
'courses': courses,
'page_ordering': ('-' if inverse_order else '') + ordering,
'activity_graph_data': activity },
context_instance=RequestContext(request))
def user_course_activity_view(request, user_id, course_id):
view_user, response = get_user(request, user_id)
if response is not None:
return response
dashboard_accessed.send(sender=None, request=request, data=None)
course = can_view_course(request, course_id)
act_quizzes = Activity.objects.filter(section__course=course,type=Activity.QUIZ).order_by('section__order','order')
quizzes_attempted = 0
quizzes_passed = 0
course_pretest = None
quizzes = []
for aq in act_quizzes:
try:
quiz = Quiz.objects.get(quizprops__value=aq.digest, quizprops__name="digest")
except Quiz.DoesNotExist:
quiz = None
attempts = QuizAttempt.objects.filter(quiz=quiz, user=view_user)
num_attempts = attempts.count()
passed = False
if num_attempts > 0:
quiz_maxscore = float(attempts[0].maxscore)
attemps_stats = attempts.aggregate(max=Max('score'), min=Min('score'), avg=Avg('score'))
max_score = 100*float(attemps_stats['max']) / quiz_maxscore
min_score = 100*float(attemps_stats['min']) / quiz_maxscore
avg_score = 100*float(attemps_stats['avg']) / quiz_maxscore
first_date = attempts.aggregate(date=Min('attempt_date'))['date']
recent_date = attempts.aggregate(date=Max('attempt_date'))['date']
first_score = 100*float(attempts.filter(attempt_date = first_date)[0].score) / quiz_maxscore
latest_score = 100*float(attempts.filter(attempt_date = recent_date)[0].score) / quiz_maxscore
passed = max_score is not None and max_score > 75
if aq.section.order == 0:
course_pretest = first_score
else:
quizzes_attempted += 1
quizzes_passed = (quizzes_passed + 1) if passed else quizzes_passed
else:
max_score = None
min_score = None
avg_score = None
first_score = None
latest_score = None
quiz = {'quiz': aq,
'quiz_order': aq.order,
'no_attempts': num_attempts,
'max_score': max_score,
'min_score': min_score,
'first_score': first_score,
'latest_score': latest_score,
'avg_score': avg_score,
'passed': passed
}
quizzes.append(quiz)
activities_completed = course.get_activities_completed(course,view_user)
activities_total = course.get_no_activities()
activities_percent = (activities_completed * 100) / activities_total
activity = []
start_date = timezone.now() - datetime.timedelta(days=31)
end_date = timezone.now()
no_days = (end_date-start_date).days + 1
trackers = Tracker.objects.filter(course=course,
user=view_user,
tracker_date__gte=start_date,
tracker_date__lte=end_date) \
.extra({'activity_date':"date(tracker_date)"}) \
.values('activity_date') \
.annotate(count=Count('id'))
for i in range(0,no_days,+1):
temp = start_date + datetime.timedelta(days=i)
count = next((dct['count'] for dct in trackers if dct['activity_date'] == temp.date()), 0)
activity.append([temp.strftime("%d %b %Y"),count])
order_options = ['quiz_order', 'no_attempts', 'max_score', 'min_score',
'first_score', 'latest_score', 'avg_score']
default_order = 'quiz_order'
ordering = request.GET.get('order_by', default_order)
inverse_order = ordering.startswith('-')
if inverse_order:
ordering = ordering[1:]
if ordering not in order_options:
ordering = default_order
inverse_order = False
quizzes.sort(key=operator.itemgetter(ordering), reverse=inverse_order)
return render_to_response('oppia/profile/user-course-scorecard.html',
{'view_user': view_user,
'course': course,
'quizzes': quizzes,
'quizzes_passed':quizzes_passed,
'quizzes_attempted':quizzes_attempted,
'pretest_score': course_pretest,
'activities_completed': activities_completed,
'activities_total': activities_total,
'activities_percent': activities_percent,
'page_ordering': ('-' if inverse_order else '') + ordering,
'activity_graph_data': activity },
context_instance=RequestContext(request))
def user_course_activity_view(request, user_id, course_id):
view_user, response = get_user(request, user_id)
if response is not None:
return response
dashboard_accessed.send(sender=None, request=request, data=None)
course = can_view_course(request, course_id)
act_quizzes = Activity.objects.filter(section__course=course, type=Activity.QUIZ).order_by('section__order', 'order')
quizzes_attempted = 0
quizzes_passed = 0
course_pretest = None
quizzes = []
for aq in act_quizzes:
try:
quizobjs = Quiz.objects.filter(quizprops__value=aq.digest, quizprops__name="digest")
if quizobjs.count() <= 0:
continue
else:
quiz = quizobjs[0]
except Quiz.DoesNotExist:
quiz = None
no_attempts = quiz.get_no_attempts_by_user(quiz, view_user)
attempts = QuizAttempt.objects.filter(quiz=quiz, user=view_user)
passed = False
if no_attempts > 0:
quiz_maxscore = float(attempts[0].maxscore)
attemps_stats = attempts.aggregate(max=Max('score'), min=Min('score'), avg=Avg('score'))
max_score = 100 * float(attemps_stats['max']) / quiz_maxscore
min_score = 100 * float(attemps_stats['min']) / quiz_maxscore
avg_score = 100 * float(attemps_stats['avg']) / quiz_maxscore
first_date = attempts.aggregate(date=Min('attempt_date'))['date']
recent_date = attempts.aggregate(date=Max('attempt_date'))['date']
first_score = 100 * float(attempts.filter(attempt_date=first_date)[0].score) / quiz_maxscore
latest_score = 100 * float(attempts.filter(attempt_date=recent_date)[0].score) / quiz_maxscore
passed = max_score is not None and max_score > 75
if aq.section.order == 0:
course_pretest = first_score
else:
quizzes_attempted += 1
quizzes_passed = (quizzes_passed + 1) if passed else quizzes_passed
else:
max_score = None
min_score = None
avg_score = None
first_score = None
latest_score = None
quiz = {'quiz': aq,
'quiz_order': aq.order,
'no_attempts': no_attempts,
'max_score': max_score,
'min_score': min_score,
'first_score': first_score,
'latest_score': latest_score,
'avg_score': avg_score,
'passed': passed
}
quizzes.append(quiz)
activities_completed = course.get_activities_completed(course, view_user)
activities_total = course.get_no_activities()
activities_percent = (activities_completed * 100) / activities_total
start_date = timezone.now() - datetime.timedelta(days=31)
end_date = timezone.now()
activity = get_tracker_activities(start_date, end_date, view_user, course=course)
order_options = ['quiz_order', 'no_attempts', 'max_score', 'min_score',
'first_score', 'latest_score', 'avg_score']
default_order = 'quiz_order'
ordering = request.GET.get('order_by', default_order)
inverse_order = ordering.startswith('-')
if inverse_order:
ordering = ordering[1:]
if ordering not in order_options:
ordering = default_order
inverse_order = False
quizzes.sort(key=operator.itemgetter(ordering), reverse=inverse_order)
return render(request, 'oppia/profile/user-course-scorecard.html',
{'view_user': view_user,
'course': course,
'quizzes': quizzes,
'quizzes_passed': quizzes_passed,
'quizzes_attempted': quizzes_attempted,
'pretest_score': course_pretest,
'activities_completed': activities_completed,
'activities_total': activities_total,
'activities_percent': activities_percent,
'page_ordering': ('-' if inverse_order else '') + ordering,
'activity_graph_data': activity})
def user_activity(request, user_id):
view_user, response = get_user(request, user_id)
if response is not None:
return response
dashboard_accessed.send(sender=None, request=request, data=None)
cohort_courses, other_courses, all_courses = get_user_courses(request, view_user)
courses = []
for course in all_courses:
course_stats = UserCourseSummary.objects.filter(user=view_user, course=course)
if course_stats:
course_stats = course_stats[0]
data = {'course': course,
'course_display': str(course),
'no_quizzes_completed': course_stats.quizzes_passed,
'pretest_score': course_stats.pretest_score,
'no_activities_completed': course_stats.completed_activities,
'no_media_viewed': course_stats.media_viewed,
'no_points': course_stats.points,
'no_badges': course_stats.badges_achieved, }
else:
data = {'course': course,
'course_display': str(course),
'no_quizzes_completed': 0,
'pretest_score': None,
'no_activities_completed': 0,
'no_media_viewed': 0,
'no_points': 0,
'no_badges': 0, }
courses.append(data)
order_options = ['course_display', 'no_quizzes_completed', 'pretest_score',
'no_activities_completed', 'no_points', 'no_badges', 'no_media_viewed']
default_order = 'course_display'
ordering = request.GET.get('order_by', default_order)
inverse_order = ordering.startswith('-')
if inverse_order:
ordering = ordering[1:]
if ordering not in order_options:
ordering = default_order
inverse_order = False
courses.sort(key=operator.itemgetter(ordering), reverse=inverse_order)
start_date = timezone.now() - datetime.timedelta(days=31)
end_date = timezone.now()
course_ids = list(chain(cohort_courses.values_list('id', flat=True), other_courses.values_list('id', flat=True)))
activity = get_tracker_activities(start_date, end_date, view_user, course_ids=course_ids)
return render(request, 'oppia/profile/user-scorecard.html',
{'view_user': view_user,
'courses': courses,
'page_ordering': ('-' if inverse_order else '') + ordering,
'activity_graph_data': activity})
