def question_list(request, course_slug, **kwargs):
course = get_object_or_404(Course, slug=course_slug)
group, bridge = group_and_bridge(kwargs)
questions = Question.objects.filter(course=course)
questions = questions.order_by("-score", "created", "id")
if group:
questions = group.content_objects(questions)
else:
questions = questions.filter(group_content_type=None)
is_enrolled = course.students.filter(id=request.user.id).exists()
is_teacher = is_teacher_test(request.user, course)
ctx = group_context(group, bridge)
ctx.update({
"course": course,
"show_material": True,
"is_enrolled": is_enrolled,
"is_teacher": is_teacher,
"group": group,
"questions": questions,
})
ctx = RequestContext(request, ctx)
return render_to_response("discussion/question_list.html", ctx)
def question_list(request, course_slug, **kwargs):
course = get_object_or_404(Course, slug=course_slug)
group, bridge = group_and_bridge(kwargs)
questions = Question.objects.filter(course=course)
questions = questions.order_by("-score", "created", "id")
if group:
questions = group.content_objects(questions)
else:
questions = questions.filter(group_content_type=None)
is_enrolled = course.students.filter(id=request.user.id).exists()
is_teacher = is_teacher_test(request.user, course)
ctx = group_context(group, bridge)
ctx.update({
"course": course,
"show_material": True,
"is_enrolled": is_enrolled,
"is_teacher": is_teacher,
"group": group,
"questions": questions,
})
ctx = RequestContext(request, ctx)
return render_to_response("discussion/question_list.html", ctx)
def course_progress(request, course_slug):
course = get_object_or_404(Course, slug=course_slug)
is_enrolled = course.students.filter(id=request.user.id).exists()
if not is_enrolled:
messages.error(request, _('You are not enrolled in this course'))
return HttpResponseRedirect(reverse('course_overview', args=[course_slug]))
is_ready, ask_admin = is_course_ready(course)
if not is_ready:
return render_to_response('courses/no_content.html', {
'course': course,
'is_enrolled': is_enrolled,
'ask_admin': ask_admin,
}, context_instance=RequestContext(request))
units = []
for u in get_units_available_for_user(course, request.user):
unit = {
'id': u.id,
'title': u.title,
'unittype': u.unittype,
'badge_class': get_unit_badge_class(u),
'badge_tooltip': u.get_unit_type_name(),
}
units.append(unit)
return render_to_response('courses/progress.html', {
'course': course,
'unit_list': units,
'is_enrolled': is_enrolled, # required due course nav templatetag
'is_teacher': is_teacher_test(request.user, course),
}, context_instance=RequestContext(request))
def question_create(request, course_slug, **kwargs):
course = get_object_or_404(Course, slug=course_slug)
group, bridge = group_and_bridge(kwargs)
if request.method == "POST":
form = AskQuestionForm(request.POST)
if form.is_valid():
question = form.save(commit=False)
question.user = request.user
question.course = course
question.save()
return HttpResponseRedirect(question.get_absolute_url())
else:
form = AskQuestionForm()
is_enrolled = course.students.filter(id=request.user.id).exists()
is_teacher = is_teacher_test(request.user, course)
ctx = group_context(group, bridge)
ctx.update({
"course": course,
"show_material": True,
"is_enrolled": is_enrolled,
"is_teacher": is_teacher,
"group": group,
"form": form,
})
ctx = RequestContext(request, ctx)
return render_to_response("discussion/question_create.html", ctx)
def course_progress(request, course_slug):
course = get_object_or_404(Course, slug=course_slug)
unit_list = get_list_or_404(Unit, course=course)
units = []
for u in unit_list:
unit = {
'id': u.id,
'title': u.title,
'unittype': u.unittype,
'badge_class': unit_badge_classes[u.unittype],
}
units.append(unit)
is_enrolled = course.students.filter(id=request.user.id).exists()
if not is_enrolled:
return HttpResponseForbidden(_('You are not enrolled in this course'))
show_material = show_material_checker(course, request.user)
if not show_material:
return HttpResponseForbidden(
_('You are enrolled in this course but it has not yet begun') +
course.start_date.strftime(' (%d / %m / %Y)'))
return render_to_response(
'courses/progress.html',
{
'course': course,
'unit_list': units,
'is_enrolled': is_enrolled, #required due course nav templatetag
'show_material': show_material,
'is_teacher': is_teacher_test(request.user, course),
},
context_instance=RequestContext(request))
def course_progress(request, course_slug):
course = get_object_or_404(Course, slug=course_slug)
is_enrolled = course.students.filter(id=request.user.id).exists()
if not is_enrolled:
return HttpResponseForbidden(_("You are not enrolled in this course"))
is_ready, ask_admin = is_course_ready(course)
if not is_ready:
return render_to_response(
"courses/no_content.html",
{"course": course, "is_enrolled": is_enrolled, "ask_admin": ask_admin},
context_instance=RequestContext(request),
)
units = []
for u in course.unit_set.all():
unit = {"id": u.id, "title": u.title, "unittype": u.unittype, "badge_class": get_unit_badge_class(u)}
units.append(unit)
return render_to_response(
"courses/progress.html",
{
"course": course,
"unit_list": units,
"is_enrolled": is_enrolled, # required due course nav templatetag
"is_teacher": is_teacher_test(request.user, course),
},
context_instance=RequestContext(request),
)
def drglearning_careers(request, course_slug, **kwargs):
course = get_object_or_404(Course, slug=course_slug)
careers = Career.get_objects_for(course)
if not careers:
raise Http404(u"Dr. Glearning course not found")
if not request.user.players.count():
reversed_url = reverse("drglearning_settings", args=[course_slug])
return HttpResponseRedirect(reversed_url)
else:
#TODO: Manage multiple players
default_player = request.user.players.filter(default=True)[0]
import_player_form = ImportPlayerForm()
is_enrolled = course.students.filter(id=request.user.id).exists()
is_teacher = is_teacher_test(request.user, course)
ctx = {
"course": course,
"show_material": True,
"is_enrolled": is_enrolled,
"is_teacher": is_teacher,
"careers": careers,
"players": request.user.players.all(),
"default_player": default_player,
"import_player_form": import_player_form,
"drglearning_host": DRGLEARNING_HOST,
"drglearning_embed_url": DRGLEARNING_EMBED_URL,
}
ctx = RequestContext(request, ctx)
return render_to_response("drglearning/careers.html", ctx)
def course_progress(request, course_slug):
course = get_object_or_404(Course, slug=course_slug)
unit_list = get_list_or_404(Unit, course=course)
units = []
for u in unit_list:
unit = {
'id': u.id,
'title': u.title,
'unittype': u.unittype,
'badge_class': unit_badge_classes[u.unittype],
}
units.append(unit)
is_enrolled = course.students.filter(id=request.user.id).exists()
if not is_enrolled:
return HttpResponseForbidden(_('You are not enrolled in this course'))
show_material = show_material_checker(course, request.user)
if not show_material:
return HttpResponseForbidden(_('You are enrolled in this course but it has not yet begun') + course.start_date.strftime(' (%d / %m / %Y)'))
return render_to_response('courses/progress.html', {
'course': course,
'unit_list': units,
'is_enrolled': is_enrolled, #required due course nav templatetag
'show_material': show_material,
'is_teacher': is_teacher_test(request.user, course),
}, context_instance=RequestContext(request))
def course_progress(request, course_slug):
course = get_object_or_404(Course, slug=course_slug)
is_enrolled = course.students.filter(id=request.user.id).exists()
if not is_enrolled:
return HttpResponseForbidden(_('You are not enrolled in this course'))
is_ready, ask_admin = is_course_ready(course)
if not is_ready:
return render_to_response('courses/no_content.html', {
'course': course,
'is_enrolled': is_enrolled,
'ask_admin': ask_admin,
}, context_instance=RequestContext(request))
units = []
for u in course.unit_set.all():
unit = {
'id': u.id,
'title': u.title,
'unittype': u.unittype,
'badge_class': get_unit_badge_class(u),
}
units.append(unit)
return render_to_response('courses/progress.html', {
'course': course,
'unit_list': units,
'is_enrolled': is_enrolled, # required due course nav templatetag
'is_teacher': is_teacher_test(request.user, course),
}, context_instance=RequestContext(request))
def drglearning_careers(request, course_slug, **kwargs):
course = get_object_or_404(Course, slug=course_slug)
careers = Career.get_objects_for(course)
if not careers:
raise Http404(u"Dr. Glearning course not found")
if not request.user.players.count():
reversed_url = reverse("drglearning_settings", args=[course_slug])
return HttpResponseRedirect(reversed_url)
else:
#TODO: Manage multiple players
default_player = request.user.players.filter(default=True)[0]
import_player_form = ImportPlayerForm()
is_enrolled = course.students.filter(id=request.user.id).exists()
is_teacher = is_teacher_test(request.user, course)
ctx = {
"course": course,
"show_material": True,
"is_enrolled": is_enrolled,
"is_teacher": is_teacher,
"careers": careers,
"players": request.user.players.all(),
"default_player": default_player,
"import_player_form": import_player_form,
"drglearning_host": DRGLEARNING_HOST,
"drglearning_embed_url": DRGLEARNING_EMBED_URL,
}
ctx = RequestContext(request, ctx)
return render_to_response("drglearning/careers.html", ctx)
def course_overview(request, course_slug):
course = get_object_or_404(Course, slug=course_slug)
check_user_can_view_course(course, request)
if request.user.is_authenticated():
is_enrolled = course.students.filter(id=request.user.id).exists()
is_teacher = is_teacher_test(request.user, course)
else:
is_enrolled = False
is_teacher = False
course_teachers = CourseTeacher.objects.filter(course=course)
announcements = Announcement.objects.filter(course=course).order_by("datetime").reverse()[:5]
units = get_units_available_for_user(course, request.user, True)
use_old_calculus = course.slug in settings.COURSES_USING_OLD_TRANSCRIPT
return render_to_response(
"courses/overview.html",
{
"course": course,
"units": units,
"is_enrolled": is_enrolled,
"is_teacher": is_teacher,
"request": request,
"course_teachers": course_teachers,
"announcements": announcements,
"use_old_calculus": use_old_calculus,
},
context_instance=RequestContext(request),
)
def question_create(request, course_slug, **kwargs):
course = get_object_or_404(Course, slug=course_slug)
group, bridge = group_and_bridge(kwargs)
if request.method == "POST":
form = AskQuestionForm(request.POST)
if form.is_valid():
question = form.save(commit=False)
question.user = request.user
question.course = course
question.save()
return HttpResponseRedirect(question.get_absolute_url())
else:
form = AskQuestionForm()
is_enrolled = course.students.filter(id=request.user.id).exists()
is_teacher = is_teacher_test(request.user, course)
ctx = group_context(group, bridge)
ctx.update({
"course": course,
"show_material": True,
"is_enrolled": is_enrolled,
"is_teacher": is_teacher,
"group": group,
"form": form,
})
ctx = RequestContext(request, ctx)
return render_to_response("discussion/question_create.html", ctx)
def course_extra_info(request, course_slug):
course = get_object_or_404(Course, slug=course_slug)
is_enrolled = course.students.filter(id=request.user.id).exists()
return render_to_response('courses/static_page.html', {
'course': course,
'is_enrolled': is_enrolled, # required due course nav templatetag
'is_teacher': is_teacher_test(request.user, course),
'static_page': course.static_page,
}, context_instance=RequestContext(request))
def course_classroom(request, course_slug):
"""
Main view of the course content (class). If the user is not enrolled we
show him a message. If the course is not ready and the user is not admin
we redirect the user to a denied access page.
:permissions: login
:context: course, is_enrolled, ask_admin, unit_list, is_teacher, peer_view
.. versionadded:: 0.1
"""
course = get_object_or_404(Course, slug=course_slug)
is_enrolled = course.students.filter(id=request.user.id).exists()
if not is_enrolled:
messages.error(request, _("You are not enrolled in this course"))
return HttpResponseRedirect(reverse("course_overview", args=[course_slug]))
is_ready, ask_admin = is_course_ready(course)
if not is_ready and not request.user.is_superuser:
return render_to_response(
"courses/no_content.html",
{"course": course, "is_enrolled": is_enrolled, "ask_admin": ask_admin},
context_instance=RequestContext(request),
)
units = []
for u in get_units_available_for_user(course, request.user):
unit = {
"id": u.id,
"title": u.title,
"unittype": u.unittype,
"badge_class": get_unit_badge_class(u),
"badge_tooltip": u.get_unit_type_name(),
}
units.append(unit)
peer_review = {
"text_max_size": settings.PEER_REVIEW_TEXT_MAX_SIZE,
"file_max_size": settings.PEER_REVIEW_FILE_MAX_SIZE,
}
return render_to_response(
"courses/classroom.html",
{
"course": course,
"unit_list": units,
"is_enrolled": is_enrolled,
"is_teacher": is_teacher_test(request.user, course),
"peer_review": peer_review,
},
context_instance=RequestContext(request),
)
def course_classroom(request, course_slug):
"""
Main view of the course content (class). If the user is not enrolled we
show him a message. If the course is not ready and the user is not admin
we redirect the user to a denied access page.
:permissions: login
:context: course, is_enrolled, ask_admin, unit_list, is_teacher, peer_view
.. versionadded:: 0.1
"""
course = get_object_or_404(Course, slug=course_slug)
is_enrolled = course.students.filter(id=request.user.id).exists()
if not is_enrolled:
messages.error(request, _('You are not enrolled in this course'))
return HttpResponseRedirect(
reverse('course_overview', args=[course_slug]))
is_ready, ask_admin = is_course_ready(course)
if not is_ready and not request.user.is_superuser:
return render_to_response('courses/no_content.html', {
'course': course,
'is_enrolled': is_enrolled,
'ask_admin': ask_admin,
},
context_instance=RequestContext(request))
units = []
for u in get_units_available_for_user(course, request.user):
unit = {
'id': u.id,
'title': u.title,
'unittype': u.unittype,
'badge_class': get_unit_badge_class(u),
'badge_tooltip': u.get_unit_type_name(),
}
units.append(unit)
peer_review = {
'text_max_size': settings.PEER_REVIEW_TEXT_MAX_SIZE,
'file_max_size': settings.PEER_REVIEW_FILE_MAX_SIZE,
}
return render_to_response(
'courses/classroom.html', {
'course': course,
'unit_list': units,
'is_enrolled': is_enrolled,
'is_teacher': is_teacher_test(request.user, course),
'peer_review': peer_review
},
context_instance=RequestContext(request))
def course_overview(request, course_slug):
course = get_object_or_404(Course, slug=course_slug)
show_material = False
if request.user.is_authenticated():
is_enrolled = course.students.filter(id=request.user.id).exists()
is_teacher = is_teacher_test(request.user, course)
if is_enrolled:
show_material = show_material_checker(course, request.user)
else:
is_enrolled = False
is_teacher = False
if request.method == 'POST':
if not is_enrolled:
is_member = course.institutions.is_member(request.user)
if not is_member:
institutions = [i.name for i in course.institutions.all()]
error(
request,
_(u'Unfortunately, this course is only available for '
u'%(institutions)s. Change your e-mail or contact to a '
u'teacher.') %
{'institutions': u", ".join(institutions)})
else:
course.students.add(request.user)
course.save()
success(
request,
_(u'Congratulations, you have successfully enroll in the course %(course)s'
) % {'course': unicode(course)})
else:
course.students.remove(request.user)
course.save()
success(
request,
_(u'You have successfully unenroll in the course %(course)s') %
{'course': unicode(course)})
return HttpResponseRedirect(
reverse('course_overview', args=(course.slug, )))
announcements = Announcement.objects.filter(
course=course).order_by('datetime').reverse()[:5]
return render_to_response('courses/overview.html', {
'course': course,
'is_enrolled': is_enrolled,
'show_material': show_material,
'is_teacher': is_teacher,
'request': request,
'announcements': announcements,
},
context_instance=RequestContext(request))
def question_detail(request, course_slug, question_id, **kwargs):
course = get_object_or_404(Course, slug=course_slug)
group, bridge = group_and_bridge(kwargs)
questions = Question.objects.all()
if group:
questions = group.content_objects(questions)
else:
questions = questions.filter(group_content_type=None)
question = get_object_or_404(questions, pk=question_id)
responses = question.responses.order_by("-score", "created", "id")
# if question.user == request.user:
# is_me = True
# else:
# is_me = False
if request.method == "POST":
add_response_form = AddResponseForm(request.POST)
if add_response_form.is_valid():
response = add_response_form.save(commit=False)
response.question = question
response.user = request.user
response.save()
return HttpResponseRedirect(response.get_absolute_url())
else:
add_response_form = AddResponseForm()
# if not is_me or request.user.is_staff:
# add_response_form = AddResponseForm()
# else:
# add_response_form = None
is_enrolled = course.students.filter(id=request.user.id).exists()
is_teacher = is_teacher_test(request.user, course)
can_mark_accepted = workflow.can_mark_accepted(request.user, question)
ctx = group_context(group, bridge)
ctx.update({
"course": course,
"show_material": True,
"is_enrolled": is_enrolled,
"is_teacher": is_teacher,
"group": group,
"can_mark_accepted": can_mark_accepted,
"question": question,
"responses": responses,
"add_response_form": add_response_form,
})
ctx = RequestContext(request, ctx)
return render_to_response("discussion/question_detail.html", ctx)
def question_detail(request, course_slug, question_id, **kwargs):
course = get_object_or_404(Course, slug=course_slug)
group, bridge = group_and_bridge(kwargs)
questions = Question.objects.all()
if group:
questions = group.content_objects(questions)
else:
questions = questions.filter(group_content_type=None)
question = get_object_or_404(questions, pk=question_id)
responses = question.responses.order_by("-score", "created", "id")
# if question.user == request.user:
# is_me = True
# else:
# is_me = False
if request.method == "POST":
add_response_form = AddResponseForm(request.POST)
if add_response_form.is_valid():
response = add_response_form.save(commit=False)
response.question = question
response.user = request.user
response.save()
return HttpResponseRedirect(response.get_absolute_url())
else:
add_response_form = AddResponseForm()
# if not is_me or request.user.is_staff:
# add_response_form = AddResponseForm()
# else:
# add_response_form = None
is_enrolled = course.students.filter(id=request.user.id).exists()
is_teacher = is_teacher_test(request.user, course)
can_mark_accepted = workflow.can_mark_accepted(request.user, question)
ctx = group_context(group, bridge)
ctx.update({
"course": course,
"show_material": True,
"is_enrolled": is_enrolled,
"is_teacher": is_teacher,
"group": group,
"can_mark_accepted": can_mark_accepted,
"question": question,
"responses": responses,
"add_response_form": add_response_form,
})
ctx = RequestContext(request, ctx)
return render_to_response("discussion/question_detail.html", ctx)
def course_extra_info(request, course_slug):
course = get_course_if_user_can_view_or_404(course_slug, request)
is_enrolled = course.students.filter(id=request.user.id).exists()
return render_to_response(
'courses/static_page.html',
{
'course': course,
'is_enrolled': is_enrolled, # required due course nav templatetag
'is_teacher': is_teacher_test(request.user, course),
'static_page': course.static_page,
},
context_instance=RequestContext(request))
def course_classroom(request, course_slug):
"""
Main view of the course content (class). If the user is not enrolled we
show him a message. If the course is not ready and the user is not admin
we redirect the user to a denied access page.
:permissions: login
:context: course, is_enrolled, ask_admin, unit_list, is_teacher, peer_view
.. versionadded:: 0.1
"""
course = get_course_if_user_can_view_or_404(course_slug, request)
is_enrolled = course.students.filter(id=request.user.id).exists()
if not is_enrolled:
messages.error(request, _('You are not enrolled in this course'))
return HttpResponseRedirect(reverse('course_overview', args=[course_slug]))
is_ready, ask_admin = is_course_ready(course)
if not is_ready and not request.user.is_superuser:
return render_to_response('courses/no_content.html', {
'course': course,
'is_enrolled': is_enrolled,
'ask_admin': ask_admin,
}, context_instance=RequestContext(request))
units = []
for u in get_units_available_for_user(course, request.user):
unit = {
'id': u.id,
'title': u.title,
'unittype': u.unittype,
'badge_class': get_unit_badge_class(u),
'badge_tooltip': u.get_unit_type_name(),
}
units.append(unit)
peer_review = {
'text_max_size': settings.PEER_REVIEW_TEXT_MAX_SIZE,
'file_max_size': settings.PEER_REVIEW_FILE_MAX_SIZE,
}
return render_to_response('courses/classroom.html', {
'course': course,
'unit_list': units,
'is_enrolled': is_enrolled,
'is_teacher': is_teacher_test(request.user, course),
'peer_review': peer_review
}, context_instance=RequestContext(request))
def course_progress(request, course_slug):
"""
Main view for the user progress in the course. This will return the units for
the user in the current course.
:permissions: login
:context: course, is_enrolled, ask_admin, course, unit_list, is_teacher
.. versionadded:: 0.1
"""
course = get_object_or_404(Course, slug=course_slug)
is_enrolled = course.students.filter(id=request.user.id).exists()
if not is_enrolled:
messages.error(request, _("You are not enrolled in this course"))
return HttpResponseRedirect(reverse("course_overview", args=[course_slug]))
is_ready, ask_admin = is_course_ready(course)
if not is_ready:
return render_to_response(
"courses/no_content.html",
{"course": course, "is_enrolled": is_enrolled, "ask_admin": ask_admin},
context_instance=RequestContext(request),
)
units = []
for u in get_units_available_for_user(course, request.user):
unit = {
"id": u.id,
"title": u.title,
"unittype": u.unittype,
"badge_class": get_unit_badge_class(u),
"badge_tooltip": u.get_unit_type_name(),
}
units.append(unit)
return render_to_response(
"courses/progress.html",
{
"course": course,
"unit_list": units,
"is_enrolled": is_enrolled, # required due course nav templatetag
"is_teacher": is_teacher_test(request.user, course),
},
context_instance=RequestContext(request),
)
def course_overview(request, course_slug):
course = get_object_or_404(Course, slug=course_slug)
show_material = False
if request.user.is_authenticated():
is_enrolled = course.students.filter(id=request.user.id).exists()
is_teacher = is_teacher_test(request.user, course)
if is_enrolled:
show_material = show_material_checker(course, request.user)
else:
is_enrolled = False
is_teacher = False
if request.method == 'POST':
if not is_enrolled:
is_member = course.institutions.is_member(request.user)
if not is_member:
institutions = [i.name for i in course.institutions.all()]
error(request,
_(u'Unfortunately, this course is only available for '
u'%(institutions)s. Change your e-mail or contact to a '
u'teacher.')
% {'institutions': u", ".join(institutions)})
else:
course.students.add(request.user)
course.save()
success(request,
_(u'Congratulations, you have successfully enroll in the course %(course)s')
% {'course': unicode(course)})
else:
course.students.remove(request.user)
course.save()
success(request,
_(u'You have successfully unenroll in the course %(course)s')
% {'course': unicode(course)})
return HttpResponseRedirect(reverse('course_overview',
args=(course.slug, )))
announcements = Announcement.objects.filter(course=course).order_by('datetime').reverse()[:5]
return render_to_response('courses/overview.html', {
'course': course,
'is_enrolled': is_enrolled,
'show_material': show_material,
'is_teacher': is_teacher,
'request': request,
'announcements': announcements,
}, context_instance=RequestContext(request))
def course_reviews(request, course_slug, kq_id=None, ignore_langs=False):
course = get_course_if_user_can_view_or_404(course_slug, request)
is_enrolled = course.students.filter(id=request.user.id).exists()
if not is_enrolled:
messages.error(request, _('You are not enrolled in this course'))
return HttpResponseRedirect(reverse('course_overview', args=[course_slug]))
is_ready, ask_admin, is_outdated = is_course_ready(course)
is_teacher = is_teacher_test(request.user, course)
if not is_ready and not is_teacher and not request.user.is_staff and not request.user.is_superuser:
return render_to_response('courses/no_content.html', {
'course': course,
'is_enrolled': is_enrolled,
'ask_admin': ask_admin,
}, context_instance=RequestContext(request))
assignments = course_get_visible_peer_review_assignments(request.user,
course)
collection = get_db().get_collection('peer_review_submissions')
submissions = collection.find({
'author': request.user.id,
'course': course.id,
}, {'kq': True, '_id': False})
submissions = [s['kq'] for s in submissions]
user_submissions = [a.id for a in assignments if a.kq.id in submissions]
tasks = get_tasks_available_for_user(course, request.user)
group = get_group_by_user_and_course(request.user.id, course.id)
return render_to_response('peerreview/reviews.html', {
'course': course,
'assignments': assignments,
'user_submissions': user_submissions,
'kq_id': kq_id,
'ignore_langs': ignore_langs,
'is_enrolled': is_enrolled,
'is_ready': is_ready,
'is_outdated': is_outdated,
'can_review': date.today() < course.end_date+timedelta(days=14),
'task_list': tasks[0],
'tasks_done': tasks[1],
'progress': get_course_progress_for_user(course, request.user),
'passed': has_user_passed_course(request.user, course),
'group': group,
}, context_instance=RequestContext(request))
def course_progress(request, course_slug):
"""
Main view for the user progress in the course. This will return the units for
the user in the current course.
:permissions: login
:context: course, is_enrolled, ask_admin, course, unit_list, is_teacher
.. versionadded:: 0.1
"""
course = get_course_if_user_can_view_or_404(course_slug, request)
is_enrolled = course.students.filter(id=request.user.id).exists()
if not is_enrolled:
messages.error(request, _('You are not enrolled in this course'))
return HttpResponseRedirect(
reverse('course_overview', args=[course_slug]))
is_ready, ask_admin = is_course_ready(course)
if not is_ready:
return render_to_response('courses/no_content.html', {
'course': course,
'is_enrolled': is_enrolled,
'ask_admin': ask_admin,
},
context_instance=RequestContext(request))
units = []
for u in get_units_available_for_user(course, request.user):
unit = {
'id': u.id,
'title': u.title,
'unittype': u.unittype,
'badge_class': get_unit_badge_class(u),
'badge_tooltip': u.get_unit_type_name(),
}
units.append(unit)
return render_to_response(
'courses/progress.html',
{
'course': course,
'unit_list': units,
'is_enrolled': is_enrolled, # required due course nav templatetag
'is_teacher': is_teacher_test(request.user, course),
},
context_instance=RequestContext(request))
def drglearning_settings(request, course_slug):
course = get_object_or_404(Course, slug=course_slug)
import_player_form = ImportPlayerForm()
if "nope" in request.GET:
player_json = create_player(request.get_host())
if "token" in player_json and "code" in player_json:
player = Player.objects.create(
code=player_json["code"],
display_name=request.user.get_full_name(),
email=request.user.email,
token=player_json["token"],
image_url=player_json["image_url"],
user=request.user
)
player_json = update_player(code=player.code, token=player.token,
display_name=player.display_name,
email=player.email)
if player_json.get("code", None) == player.code:
reversed_url = reverse("drglearning_careers",
args=[course_slug])
return HttpResponseRedirect(reversed_url)
elif request.POST:
import_player_form = ImportPlayerForm(request.POST)
if import_player_form.is_valid():
player = import_player_form.save(commit=False)
player_json = get_player(code=player.code)
if player_json.get("code", None) == player.code:
player.user = request.user
player.display_name = request.user.get_full_name()
player.email = request.user.email
player.save()
reversed_url = reverse("drglearning_careers",
args=[course_slug])
return HttpResponseRedirect(reversed_url)
is_enrolled = course.students.filter(id=request.user.id).exists()
is_teacher = is_teacher_test(request.user, course)
ctx = {
"course": course,
"show_material": True,
"players": request.user.players,
"import_player_form": import_player_form,
"is_enrolled": is_enrolled,
"is_teacher": is_teacher,
}
ctx = RequestContext(request, ctx)
return render_to_response("drglearning/settings.html", ctx)
def drglearning_settings(request, course_slug):
course = get_object_or_404(Course, slug=course_slug)
import_player_form = ImportPlayerForm()
if "nope" in request.GET:
player_json = create_player(request.get_host())
if "token" in player_json and "code" in player_json:
player = Player.objects.create(
code=player_json["code"],
display_name=request.user.get_full_name(),
email=request.user.email,
token=player_json["token"],
image_url=player_json["image_url"],
user=request.user)
player_json = update_player(code=player.code,
token=player.token,
display_name=player.display_name,
email=player.email)
if player_json.get("code", None) == player.code:
reversed_url = reverse("drglearning_careers",
args=[course_slug])
return HttpResponseRedirect(reversed_url)
elif request.POST:
import_player_form = ImportPlayerForm(request.POST)
if import_player_form.is_valid():
player = import_player_form.save(commit=False)
player_json = get_player(code=player.code)
if player_json.get("code", None) == player.code:
player.user = request.user
player.display_name = request.user.get_full_name()
player.email = request.user.email
player.save()
reversed_url = reverse("drglearning_careers",
args=[course_slug])
return HttpResponseRedirect(reversed_url)
is_enrolled = course.students.filter(id=request.user.id).exists()
is_teacher = is_teacher_test(request.user, course)
ctx = {
"course": course,
"show_material": True,
"players": request.user.players,
"import_player_form": import_player_form,
"is_enrolled": is_enrolled,
"is_teacher": is_teacher,
}
ctx = RequestContext(request, ctx)
return render_to_response("drglearning/settings.html", ctx)
def course_overview(request, course_slug):
"""
Show the course main page. This will show the main information about the
course and the 'register to this course' button.
.. note:: **use_old_calculus** is a compatibility method with old evaluation
methods, which allowed the normal units to be evaluated. The new
system does not evaluate normal units, only tasks and exams.
:context: course, units, is_enrolled, is_teacher, request, course_teachers,
announcements, use_old_calculus
.. versionadded:: 0.1
"""
course = get_object_or_404(Course, slug=course_slug)
check_user_can_view_course(course, request)
if request.user.is_authenticated():
is_enrolled = course.students.filter(id=request.user.id).exists()
is_teacher = is_teacher_test(request.user, course)
else:
is_enrolled = False
is_teacher = False
course_teachers = CourseTeacher.objects.filter(course=course)
announcements = Announcement.objects.filter(course=course).order_by("datetime").reverse()[:5]
units = get_units_available_for_user(course, request.user, True)
use_old_calculus = course.slug in settings.COURSES_USING_OLD_TRANSCRIPT
return render_to_response(
"courses/overview.html",
{
"course": course,
"units": units,
"is_enrolled": is_enrolled,
"is_teacher": is_teacher,
"request": request,
"course_teachers": course_teachers,
"announcements": announcements,
"use_old_calculus": use_old_calculus,
},
context_instance=RequestContext(request),
)
def course_classroom(request, course_slug):
course = get_object_or_404(Course, slug=course_slug)
is_enrolled = course.students.filter(id=request.user.id).exists()
if not is_enrolled:
return HttpResponseForbidden(_("You are not enrolled in this course"))
is_ready, ask_admin = is_course_ready(course)
if not is_ready:
return render_to_response(
"courses/no_content.html",
{"course": course, "is_enrolled": is_enrolled, "ask_admin": ask_admin},
context_instance=RequestContext(request),
)
units = []
for u in get_units_available_for_user(course, request.user):
unit = {
"id": u.id,
"title": u.title,
"unittype": u.unittype,
"badge_class": get_unit_badge_class(u),
"badge_tooltip": u.get_unit_type_name(),
}
units.append(unit)
peer_review = {
"text_max_size": settings.PEER_REVIEW_TEXT_MAX_SIZE,
"file_max_size": settings.PEER_REVIEW_FILE_MAX_SIZE,
}
return render_to_response(
"courses/classroom.html",
{
"course": course,
"unit_list": units,
"is_enrolled": is_enrolled,
"is_teacher": is_teacher_test(request.user, course),
"peer_review": peer_review,
},
context_instance=RequestContext(request),
)
def course_overview(request, course_slug):
"""
Show the course main page. This will show the main information about the
course and the 'register to this course' button.
.. note:: **use_old_calculus** is a compatibility method with old evaluation
methods, which allowed the normal units to be evaluated. The new
system does not evaluate normal units, only tasks and exams.
:context: course, units, is_enrolled, is_teacher, request, course_teachers,
announcements, use_old_calculus
.. versionadded:: 0.1
"""
course = get_object_or_404(Course, slug=course_slug)
check_user_can_view_course(course, request)
if request.user.is_authenticated():
is_enrolled = course.students.filter(id=request.user.id).exists()
is_teacher = is_teacher_test(request.user, course)
else:
is_enrolled = False
is_teacher = False
course_teachers = CourseTeacher.objects.filter(course=course)
announcements = Announcement.objects.filter(
course=course).order_by('datetime').reverse()[:5]
units = get_units_available_for_user(course, request.user, True)
use_old_calculus = course.slug in settings.COURSES_USING_OLD_TRANSCRIPT
return render_to_response('courses/overview.html', {
'course': course,
'units': units,
'is_enrolled': is_enrolled,
'is_teacher': is_teacher,
'request': request,
'course_teachers': course_teachers,
'announcements': announcements,
'use_old_calculus': use_old_calculus,
},
context_instance=RequestContext(request))
def course_overview(request, course_slug):
course = get_object_or_404(Course, slug=course_slug)
if request.user.is_authenticated():
is_enrolled = course.students.filter(id=request.user.id).exists()
is_teacher = is_teacher_test(request.user, course)
else:
is_enrolled = False
is_teacher = False
course_teachers = CourseTeacher.objects.filter(course=course)
announcements = Announcement.objects.filter(course=course).order_by('datetime').reverse()[:5]
return render_to_response('courses/overview.html', {
'course': course,
'is_enrolled': is_enrolled,
'is_teacher': is_teacher,
'request': request,
'course_teachers': course_teachers,
'announcements': announcements,
}, context_instance=RequestContext(request))
def course_classroom(request, course_slug):
course = get_object_or_404(Course, slug=course_slug)
is_enrolled = course.students.filter(id=request.user.id).exists()
if not is_enrolled:
messages.error(request, _('You are not enrolled in this course'))
return HttpResponseRedirect(reverse('course_overview', args=[course_slug]))
is_ready, ask_admin = is_course_ready(course)
if not is_ready:
return render_to_response('courses/no_content.html', {
'course': course,
'is_enrolled': is_enrolled,
'ask_admin': ask_admin,
}, context_instance=RequestContext(request))
units = []
for u in get_units_available_for_user(course, request.user):
unit = {
'id': u.id,
'title': u.title,
'unittype': u.unittype,
'badge_class': get_unit_badge_class(u),
'badge_tooltip': u.get_unit_type_name(),
}
units.append(unit)
peer_review = {
'text_max_size': settings.PEER_REVIEW_TEXT_MAX_SIZE,
'file_max_size': settings.PEER_REVIEW_FILE_MAX_SIZE,
}
return render_to_response('courses/classroom.html', {
'course': course,
'unit_list': units,
'is_enrolled': is_enrolled,
'is_teacher': is_teacher_test(request.user, course),
'peer_review': peer_review
}, context_instance=RequestContext(request))
def profile_courses(request, id, byid=False):
if(not id):
if(not request.user.id):
return HttpResponseRedirect("/auth/login")
user = request.user
id = request.user.id
else:
if byid:
user = User.objects.get(pk=id)
else:
user = User.objects.get(username=id)
id = user.id
case = _getCase(request,id)
courses = get_courses_user_is_enrolled(user)
courses_completed = 0
for course in courses:
if request.user.is_authenticated():
course.is_enrolled = course.students.filter(id=user.id).exists()
course.is_teacher = is_teacher_test(user, course)
course.progress = get_course_progress_for_user(course, user)
if course.progress == 100:
courses_completed +=1
course.has_passed = has_user_passed_course(user, course)
else:
course.is_enrolled = False
course.is_teacher = False
return render_to_response('profile/courses.html', {
"id":id,
"case":case,
'request': request,
'courses': courses,
'courses_completed': courses_completed,
"user_view_profile": user,
"badges_count": get_db().get_collection('badge').find({"id_user": id}).count()
}, context_instance=RequestContext(request))
def can_delete_question(user, question):
return is_teacher_test(user, question.course)
def can_delete_response(user, response):
return is_teacher_test(user, response.question.course)