def admin_authenticated(self, request):
activity = []
dashboard_accessed.send(sender=None, request=request, data=None)
start_date = timezone.now() - datetime.timedelta(
days=constants.ACTIVITY_GRAPH_DEFAULT_NO_DAYS)
end_date = timezone.now()
interval = 'days'
if request.method == 'POST':
form = DateRangeIntervalForm(request.POST)
if form.is_valid():
start_date = form.cleaned_data.get("start_date")
start_date = datetime.datetime.strptime(
start_date, constants.STR_DATE_FORMAT)
end_date = form.cleaned_data.get("end_date")
end_date = datetime.datetime.strptime(
end_date, constants.STR_DATE_FORMAT)
interval = form.cleaned_data.get("interval")
else:
data = {}
data['start_date'] = start_date
data['end_date'] = end_date
data['interval'] = interval
form = DateRangeIntervalForm(initial=data)
if interval == 'days':
activity = process_home_activity_days(activity, start_date,
end_date)
else:
activity = process_home_activity_months(activity, start_date,
end_date)
return form, activity
def tag_courses_view(request, tag_id):
courses = can_view_courses_list(request)
courses = courses.filter(coursetag__tag__pk=tag_id)
dashboard_accessed.send(sender=None, request=request, data=None)
return render_courses_list(request, courses, {'current_tag': tag_id})
def home_view_admin_authenticated(request):
activity = []
dashboard_accessed.send(sender=None, request=request, data=None)
start_date = timezone.now() - datetime.timedelta(days=31)
end_date = timezone.now()
interval = 'days'
if request.method == 'POST':
form = DateRangeIntervalForm(request.POST)
if form.is_valid():
start_date = form.cleaned_data.get("start_date")
start_date = datetime.datetime.strptime(start_date,
"%Y-%m-%d")
end_date = form.cleaned_data.get("end_date")
end_date = datetime.datetime.strptime(end_date, "%Y-%m-%d")
interval = form.cleaned_data.get("interval")
else:
data = {}
data['start_date'] = start_date
data['end_date'] = end_date
data['interval'] = interval
form = DateRangeIntervalForm(initial=data)
if interval == 'days':
activity = process_home_activity_days(activity, start_date, end_date)
else:
activity = process_home_activity_months(activity, start_date, end_date)
return form, activity
def get(self, request):
dashboard_accessed.send(sender=None, request=request, data=None)
courses = Course.objects.filter(is_draft=False,
is_archived=False).order_by('title')
courses_list = []
for course in courses:
obj = {}
obj['course'] = course
course_stats = UserCourseSummary.objects \
.filter(course=course) \
.values('course') \
.annotate(users=Count('user'),
completed=Sum('badges_achieved'))
for stats in course_stats:
no_users = stats['users']
obj['enroled'] = no_users
if no_users > 0:
obj['completion'] = (float(stats['completed']) /
float(no_users)) * 100
else:
obj['completion'] = 0
courses_list.append(obj)
return render(request, 'reports/completion_rates.html',
{'courses_list': courses_list})
def get(self, request):
uploaded_media = []
objs = UploadedMedia.objects.all().order_by('-created_date')
for o in objs:
embed_code = o.get_embed_code(
request.build_absolute_uri(o.file.url))
uploaded_media.append({
'uploaded_media': o,
'embed_code': embed_code
})
paginator = Paginator(uploaded_media, 25)
try:
page = int(request.GET.get('page', '1'))
except ValueError:
page = 1
try:
media = paginator.page(page)
except (EmptyPage, InvalidPage):
media = paginator.page(paginator.num_pages)
dashboard_accessed.send(sender=None, request=request, data=None)
return render(request, 'av/home.html', {
'title': STR_UPLOAD_MEDIA,
'page': media
})
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
dashboard_accessed.send(sender=None, request=self.request, data=None)
course_list = context['page_obj'].object_list
course_stats = UserCourseSummary.objects\
.filter(course__in=list(course_list))\
.aggregated_stats('total_downloads')
for course in course_list:
access_detail = can_view_course_detail(self.request, course.id)
course.can_edit = can_edit_course(self.request, course.id)
course.access_detail = access_detail is not None
for stats in course_stats:
if stats['course'] == course.id:
course.distinct_downloads = stats['distinct']
course.total_downloads = stats['total']
# remove the element to optimize next searches
course_stats.remove(stats)
context['page_ordering'] = self.get_ordering()
context['tag_list'] = Tag.objects.all() \
.exclude(coursetag=None) \
.order_by('name')
context['current_tag'] = self.get_current_tag()
context['course_filter'] = self.get_filter()
return context
def tag_courses_view(request, tag_id):
courses = can_view_courses_list(request)
courses = courses.filter(coursetag__tag__pk=tag_id)
dashboard_accessed.send(sender=None, request=request, data=None)
return render_courses_list(request, courses, {'current_tag': tag_id})
def get(self, request):
dashboard_accessed.send(sender=None, request=request, data=None)
user_count = User.objects.all().count()
group_by_form = ReportGroupByForm()
return render(request, 'reports/unique_users.html', {
'user_count': user_count,
'form': group_by_form
})
def add_dashboard_access_log(request):
if request.POST:
dashboard_accessed.send(sender=None,
request=request,
data=request.POST)
else:
dashboard_accessed.send(sender=None, request=request)
return {'dashboard_access_added': True}
def get(self, request):
form = UploadMediaForm()
dashboard_accessed.send(sender=None, request=request, data=None)
return render(request, 'common/upload.html', {
'form': form,
'title': STR_UPLOAD_MEDIA
})
def recent_activity(request, course_id):
course, response = can_view_course_detail(request, course_id)
if response is not None:
raise response
dashboard_accessed.send(sender=None, request=request, data=course)
start_date = datetime.datetime.now() - datetime.timedelta(days=31)
end_date = datetime.datetime.now()
interval = 'days'
if request.method == 'POST':
form = DateRangeIntervalForm(request.POST)
if form.is_valid():
start_date = form.cleaned_data.get("start_date")
start_date = datetime.datetime.strptime(start_date + " 00:00:00",
"%Y-%m-%d %H:%M:%S")
end_date = form.cleaned_data.get("end_date")
end_date = datetime.datetime.strptime(end_date + " 23:59:59",
"%Y-%m-%d %H:%M:%S")
interval = form.cleaned_data.get("interval")
else:
data = {}
data['start_date'] = start_date
data['end_date'] = end_date
data['interval'] = interval
form = DateRangeIntervalForm(initial=data)
dates = []
if interval == 'days':
daily_stats = CourseDailyStats.objects.filter(course=course, day__gte=start_date, day__lte=end_date) \
.values('day', 'type') \
.annotate(total=Sum('total'))
dates = generate_graph_data(daily_stats, False)
else:
monthly_stats = CourseDailyStats.objects.filter(course=course, day__gte=start_date, day__lte=end_date) \
.extra({'month': 'month(day)', 'year': 'year(day)'}) \
.values('month', 'year', 'type') \
.annotate(total=Sum('total')) \
.order_by('year', 'month')
dates = generate_graph_data(monthly_stats, True)
leaderboard = Points.get_leaderboard(10, course)
return render(
request, 'course/activity.html', {
'course': course,
'monthly': interval == 'months',
'form': form,
'data': dates,
'leaderboard': leaderboard
})
def get(self, request, course_id):
course = can_view_course_detail(request, course_id)
dashboard_accessed.send(sender=None, request=request, data=course)
start_date = datetime.datetime.now() - datetime.timedelta(days=31)
end_date = datetime.datetime.now()
interval = 'days'
return self.process(request, course, start_date, end_date, interval)
def get(self, request, course_id):
course = can_view_course_detail(request, course_id)
dashboard_accessed.send(sender=None, request=request, data=course)
start_date = timezone.now() - datetime.timedelta(
days=constants.ACTIVITY_GRAPH_DEFAULT_NO_DAYS)
end_date = timezone.now()
interval = 'days'
return self.process(request, course, start_date, end_date, interval)
def get(self, request, course_id, quiz_id):
activity = get_object_or_404(Activity,
pk=quiz_id,
type=Activity.QUIZ,
section__course__pk=course_id)
can_view_course_detail(request, course_id)
prop = QuizProps.objects.get(name='digest', value=activity.digest)
dashboard_accessed.send(sender=None, request=request, data=None)
quiz_questions = Question.objects.filter(
quizquestion__quiz__pk=prop.quiz_id) \
.order_by('quizquestion__order')
headers = ['Date', 'UserId', 'Max Score', 'User Score']
for question in quiz_questions:
headers.append(question.get_title())
headers.append('Question Score')
data = []
data = tablib.Dataset(*data, headers=headers)
quiz_attempts = QuizAttempt.objects.filter(quiz_id=prop.quiz_id) \
.order_by('attempt_date')
for quiz_attempt in quiz_attempts:
row = [
quiz_attempt.attempt_date.strftime(
constants.STR_DATETIME_FORMAT), quiz_attempt.user_id,
quiz_attempt.maxscore, quiz_attempt.score
]
for question in quiz_questions:
try:
user_response = QuizAttemptResponse.objects.get(
question=question, quizattempt=quiz_attempt)
row.append(user_response.text)
row.append(user_response.score)
except QuizAttemptResponse.DoesNotExist:
row.append('')
row.append('')
data.append(row)
response = HttpResponse(
data.export('xlsx'),
content_type='application/vnd.ms-excel;charset=utf-8')
response['Content-Disposition'] = "attachment; filename=export.xlsx"
return response
def get(self, request):
start_date = datetime.date.today() - datetime.timedelta(
days=constants.ANNUAL_NO_DAYS)
end_date = datetime.date.today()
data = {}
data['start_date'] = start_date.strftime(
oppia_constants.STR_DATE_FORMAT)
data['end_date'] = end_date.strftime(oppia_constants.STR_DATE_FORMAT)
form = dates.DateRangeForm(initial=data)
dashboard_accessed.send(sender=None, request=request, data=data)
return self.process(request, form, start_date, end_date)
def media_view(request, id):
media = get_object_or_404(UploadedMedia, pk=id)
embed_code = media.get_embed_code(
request.build_absolute_uri(media.file.url))
dashboard_accessed.send(sender=None, request=request, data=None)
return render(request, 'av/view.html', {
'title': _(u'Media'),
'media': media,
'embed_code': embed_code
})
def recent_activity(request, course_id):
course, response = can_view_course_detail(request, course_id)
if response is not None:
raise response
dashboard_accessed.send(sender=None, request=request, data=course)
start_date = datetime.datetime.now() - datetime.timedelta(days=31)
end_date = datetime.datetime.now()
interval = 'days'
if request.method == 'POST':
form = DateRangeIntervalForm(request.POST)
if form.is_valid():
start_date = form.cleaned_data.get("start_date")
start_date = datetime.datetime.strptime(start_date + " 00:00:00", "%Y-%m-%d %H:%M:%S")
end_date = form.cleaned_data.get("end_date")
end_date = datetime.datetime.strptime(end_date + " 23:59:59", "%Y-%m-%d %H:%M:%S")
interval = form.cleaned_data.get("interval")
else:
data = {}
data['start_date'] = start_date
data['end_date'] = end_date
data['interval'] = interval
form = DateRangeIntervalForm(initial=data)
dates = []
if interval == 'days':
daily_stats = CourseDailyStats.objects.filter(course=course, day__gte=start_date, day__lte=end_date) \
.values('day', 'type') \
.annotate(total=Sum('total'))
dates = generate_graph_data(daily_stats, False)
else:
monthly_stats = CourseDailyStats.objects.filter(course=course, day__gte=start_date, day__lte=end_date) \
.extra({'month': 'month(day)', 'year': 'year(day)'}) \
.values('month', 'year', 'type') \
.annotate(total=Sum('total')) \
.order_by('year', 'month')
dates = generate_graph_data(monthly_stats, True)
leaderboard = Points.get_leaderboard(10, course)
return render(request, 'oppia/course/activity.html',
{'course': course,
'monthly': interval == 'months',
'form': form,
'data': dates,
'leaderboard': leaderboard})
def courses_list_view(request):
if request.is_ajax():
#if we are requesting via ajax, just show the course list
ordering, courses = get_paginated_courses(request)
return render(request, 'oppia/course/courses-paginated-list.html',
{'page': courses,
'page_ordering': ordering,
'ajax_url': request.path})
else:
courses = can_view_courses_list(request)
dashboard_accessed.send(sender=None, request=request, data=None)
return render_courses_list(request, courses)
def courses_list_view(request):
if request.is_ajax():
#if we are requesting via ajax, just show the course list
ordering, courses = get_paginated_courses(request)
return render(request, 'course/list_page.html',
{'page': courses,
'page_ordering': ordering,
'ajax_url': request.path})
else:
courses = can_view_courses_list(request)
dashboard_accessed.send(sender=None, request=request, data=None)
return render_courses_list(request, courses)
def post(self, request):
dashboard_accessed.send(sender=None, request=request, data=None)
user_list = []
group_by_form = ReportGroupByForm(request.POST)
if group_by_form.is_valid():
group_by = group_by_form.cleaned_data.get("group_by")
user_list = UserProfileCustomField.objects \
.filter(key_name=group_by) \
.values('value_str') \
.annotate(total=Count('value_str')) \
.order_by('value_str')
return render(request, 'reports/unique_users.html', {
'user_list': user_list,
'form': group_by_form,
'filter': group_by
})
def process_profile_update(self, bundle):
data = {'email': bundle.data['email']
if 'email' in bundle.data else '',
'first_name': bundle.data['first_name'],
'last_name': bundle.data['last_name'],
'username': bundle.request.user}
custom_fields = CustomField.objects.all()
for custom_field in custom_fields:
try:
data[custom_field.id] = bundle.data[custom_field.id]
except KeyError:
pass
profile_form = ProfileForm(data=data)
dashboard_accessed.send(sender=None,
request=bundle.request,
data=bundle.data)
if not profile_form.is_valid():
error_str = ""
for key, value in profile_form.errors.items():
for error in value:
error_str += error + "\n"
raise BadRequest(error_str)
else:
email = bundle.data['email'] if 'email' in bundle.data else ''
first_name = bundle.data['first_name']
last_name = bundle.data['last_name']
try:
bundle.obj = User.objects.get(username=bundle.request.user)
bundle.obj.first_name = first_name
bundle.obj.last_name = last_name
bundle.obj.email = email
bundle.obj.save()
except User.DoesNotExist:
raise BadRequest(_(u'Username not found'))
# Create base UserProfile
user_profile = self.process_profile_update_base_profile(bundle)
# Create any CustomField entries
user_profile.update_customfields(bundle.data)
return bundle
def post(self, request):
start_date = datetime.date.today() - datetime.timedelta(
days=constants.ANNUAL_NO_DAYS)
end_date = datetime.date.today()
form = dates.DateRangeForm(request.POST)
if form.is_valid():
start_date = form.cleaned_data.get("start_date")
end_date = form.cleaned_data.get("end_date")
if isinstance(start_date, str):
start_date = datetime.datetime.strptime(
start_date, oppia_constants.STR_DATE_FORMAT)
if isinstance(end_date, str):
end_date = datetime.datetime.strptime(
end_date, oppia_constants.STR_DATE_FORMAT)
data = {}
data['start_date'] = start_date
data['end_date'] = end_date
dashboard_accessed.send(sender=None, request=request, data=data)
return self.process(request, form, start_date, end_date)
def process(self, request):
if not permissions.is_manager_only(request.user):
raise PermissionDenied
courses = Course.objects.filter(
coursepermissions__user=request.user,
coursepermissions__role=CoursePermissions.MANAGER)
start_date = timezone.now() - datetime.timedelta(
days=constants.ACTIVITY_GRAPH_DEFAULT_NO_DAYS)
end_date = timezone.now()
# get activity
activity = get_trackers(start_date, end_date, courses)
dashboard_accessed.send(sender=None, request=request, data=None)
return render(request, 'oppia/home-manager.html', {
'courses': courses,
'activity_graph_data': activity,
})
def post(self, request, course_id):
course = can_view_course_detail(request, course_id)
dashboard_accessed.send(sender=None, request=request, data=course)
form = DateRangeIntervalForm(request.POST)
if form.is_valid():
start_date = form.cleaned_data.get("start_date")
start_date = datetime.datetime.strptime(start_date + " 00:00:00",
"%Y-%m-%d %H:%M:%S")
end_date = form.cleaned_data.get("end_date")
end_date = datetime.datetime.strptime(end_date + " 23:59:59",
"%Y-%m-%d %H:%M:%S")
interval = form.cleaned_data.get("interval")
else:
start_date = datetime.datetime.now() - datetime.timedelta(days=31)
end_date = datetime.datetime.now()
interval = 'days'
return self.process(request, course, start_date, end_date, interval)
def process(self, request):
cohorts = permissions.get_cohorts(request)
start_date = timezone.now() - datetime.timedelta(
days=constants.ACTIVITY_GRAPH_DEFAULT_NO_DAYS)
end_date = timezone.now()
# get student activity
students = User.objects \
.filter(participant__role=Participant.STUDENT,
participant__cohort__in=cohorts).distinct()
courses = Course.objects \
.filter(coursecohort__cohort__in=cohorts).distinct()
activity = get_trackers(start_date, end_date, courses, students)
dashboard_accessed.send(sender=None, request=request, data=None)
return render(request, 'oppia/home-teacher.html', {
'cohorts': cohorts,
'activity_graph_data': activity,
})
def download_course_media(request, course_id):
course = can_view_course(request, course_id)
digests = Media.objects.filter(course=course).values_list('digest',
flat=True)
media = UploadedMedia.objects.filter(md5__in=digests)
filename = course.shortname + "_media.zip"
path = handler.zip_course_media(filename, media)
dashboard_accessed.send(sender=None, request=request, data=None)
if path:
with open(path, 'rb') as package:
response = HttpResponse(package.read(),
content_type='application/zip')
response['Content-Length'] = os.path.getsize(path)
response['Content-Disposition'] = 'attachment; filename="%s"' \
% (filename)
return response
else:
return redirect(
reverse('av:course_media', kwargs={'course_id': course.pk}) +
'?error=no_media')
def teacher_home_view(request):
cohorts = permissions.get_cohorts(request)
start_date = timezone.now() - datetime.timedelta(days=31)
end_date = timezone.now()
# get student activity
activity = []
no_days = (end_date - start_date).days + 1
students = User.objects \
.filter(participant__role=Participant.STUDENT,
participant__cohort__in=cohorts).distinct()
courses = Course.objects \
.filter(coursecohort__cohort__in=cohorts).distinct()
trackers = Tracker.objects.filter(course__in=courses,
user__in=students,
tracker_date__gte=start_date,
tracker_date__lte=end_date) \
.annotate(day=TruncDay('tracker_date'),
month=TruncMonth('tracker_date'),
year=TruncYear('tracker_date')) \
.values('day') \
.annotate(count=Count('id'))
for i in range(0, no_days, +1):
temp = start_date + datetime.timedelta(days=i)
temp_date = temp.date().strftime(STR_DATE_FORMAT)
count = next((dct['count'] for dct in trackers
if dct['day'].strftime(STR_DATE_FORMAT) == temp_date), 0)
activity.append([temp.strftime(STR_DATE_FORMAT), count])
dashboard_accessed.send(sender=None, request=request, data=None)
return render(request, 'oppia/home-teacher.html', {
'cohorts': cohorts,
'activity_graph_data': activity,
})
def get(self, request, course_id):
dashboard_accessed.send(sender=None, request=request, data=None)
try:
course = Course.objects.get(pk=course_id)
except Course.DoesNotExist:
raise Http404
users_completed = []
users_incompleted = []
course_activities = course.get_no_activities()
users_stats = UserCourseSummary.objects \
.filter(course=course_id).order_by('user')
for user_stats in users_stats:
user_activities = user_stats.completed_activities
user_obj = {'user': user_stats.user}
user_obj['activities_completed'] = user_activities
user_obj['completion_percent'] = (user_activities * 100 /
course_activities)
if (user_activities >= course_activities):
users_completed.append(user_obj)
else:
users_incompleted.append(user_obj)
return render(
request, 'reports/course_completion_rates.html', {
'course':
course,
'users_enroled_count':
len(users_completed) + len(users_incompleted),
'users_completed':
users_completed,
'users_incompleted':
users_incompleted
})
def post(self, request, course_id):
course = can_view_course_detail(request, course_id)
dashboard_accessed.send(sender=None, request=request, data=course)
form = DateRangeIntervalForm(request.POST)
if form.is_valid():
start_date = timezone.make_aware(
datetime.datetime.strptime(form.cleaned_data.get("start_date"),
constants.STR_DATE_FORMAT),
timezone.get_current_timezone())
end_date = timezone.make_aware(
datetime.datetime.strptime(form.cleaned_data.get("end_date"),
constants.STR_DATE_FORMAT),
timezone.get_current_timezone())
interval = form.cleaned_data.get("interval")
else:
start_date = timezone.now() - datetime.timedelta(
days=constants.ACTIVITY_GRAPH_DEFAULT_NO_DAYS)
end_date = timezone.now()
interval = 'days'
return self.process(request, course, start_date, end_date, interval)
def home_view(request):
activity = []
leaderboard = None
if request.user.is_authenticated:
# create profile if none exists (historical for very old users)
try:
up = request.user.userprofile
except UserProfile.DoesNotExist:
up = UserProfile()
up.user = request.user
up.save()
dashboard_accessed.send(sender=None, request=request, data=None)
# if user is student redirect to their scorecard
if up.is_student_only():
return HttpResponseRedirect(reverse('profile_user_activity', args=[request.user.id]))
# is user is teacher redirect to teacher home
if up.is_teacher_only():
return HttpResponseRedirect(reverse('oppia_teacher_home'))
start_date = timezone.now() - datetime.timedelta(days=31)
end_date = timezone.now()
interval = 'days'
if request.method == 'POST':
form = DateRangeIntervalForm(request.POST)
if form.is_valid():
start_date = form.cleaned_data.get("start_date")
start_date = datetime.datetime.strptime(start_date, "%Y-%m-%d")
end_date = form.cleaned_data.get("end_date")
end_date = datetime.datetime.strptime(end_date, "%Y-%m-%d")
interval = form.cleaned_data.get("interval")
else:
data = {}
data['start_date'] = start_date
data['end_date'] = end_date
data['interval'] = interval
form = DateRangeIntervalForm(initial=data)
if interval == 'days':
no_days = (end_date - start_date).days + 1
tracker_stats = CourseDailyStats.objects.filter(day__gte=start_date, day__lte=end_date).values('day').annotate(count=Sum('total'))
for i in range(0, no_days, +1):
temp = start_date + datetime.timedelta(days=i)
count = next((dct['count'] for dct in tracker_stats if dct['day'] == temp.date()), 0)
activity.append([temp.strftime("%d %b %Y"), count])
else:
delta = relativedelta(months=+1)
no_months = 0
tmp_date = start_date
while tmp_date <= end_date:
tmp_date += delta
no_months += 1
for i in range(0, no_months, +1):
temp = start_date + relativedelta(months=+i)
month = temp.strftime("%m")
year = temp.strftime("%Y")
count = CourseDailyStats.objects.filter(day__month=month, day__year=year).aggregate(total=Sum('total')).get('total', 0)
activity.append([temp.strftime("%b %Y"), 0 if count is None else count])
leaderboard = Points.get_leaderboard(10)
else:
form = None
return render(request, 'oppia/home.html',
{'form': form,
'activity_graph_data': activity,
'leaderboard': leaderboard})
def get(self, request):
dashboard_accessed.send(sender=None, request=request, data=None)
return render(request, 'reports/home.html')
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_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})
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})
