def register_course_view(request, pk):
course = get_object_or_404(CanvasCourse, pk=pk)
course_reg = get_course_registration(request.user, course)
if course_reg is None:
course_reg = CanvasCourseRegistration(user=request.user, course=course)
course_reg.save()
if course_reg.is_blocked:
messages.add_message(
request, messages.ERROR,
'Registration has been blocked for you. Please contact your instructor.'
)
return render(request, 'canvas/course_registration/empty.html')
if not course_reg.canvas_user_id:
return _name_registration_view(request, course, course_reg)
if not course_reg.is_verified:
return _verify_registration_view(request, course, course_reg)
messages.add_message(request, messages.SUCCESS,
'You are already registered.')
return render(request, 'canvas/course_registration/empty.html', {
'course': course,
})
def get_course_reg(self, course):
user = self.get_user()
# if user is not logged in or the request has no user attached
if not user.is_authenticated:
return None
course_reg = get_course_registration(user, course)
return CanvasCourseRegistrationSerializer(course_reg).data
def update_token_use(user, course, data):
from canvas.models import TokenUseOption
course_reg = get_course_registration(user, course)
total_tokens_used = 0
for token_use_option_id, num in data.items():
total_tokens_used += TokenUseOption.objects.get(
id=token_use_option_id).tokens_required * num
if total_tokens_used > course_reg.total_tokens_received:
raise TokenUseException()
for token_use_option_id, num in data.items():
token_use = get_token_use(user, token_use_option_id)
token_use.num_used = num
token_use.apply()
token_use.save()
def verify(self, request, pk=None):
"""
This endpoint completes the verification step of course registration.
"""
code = request.data.get("code", None)
if code is None:
raise ValidationError(
ERROR_MESSAGES.COURSE_REGISTRATION.INVALID_CODE)
course = get_object_or_404(CanvasCourse, pk=pk)
course_reg = get_course_registration(request.user, course)
if course_reg is None:
raise ValidationError(ERROR_MESSAGES.COURSE_REGISTRATION.INVALID)
valid = course_reg.check_verification_code(code)
return Response({
"success": valid,
"attempts_remaining": course_reg.verification_attempts,
})
def get_registration_status(self, request, pk=None):
"""
Returns the status of this logged-in user's course registration for a specific course.
This is encoded as a string.
"""
course = get_object_or_404(CanvasCourse, pk=pk)
course_reg = get_course_registration(request.user, course)
if course_reg is None:
# create a CanvasCourseRegistration for this (user, course) pair if one does not already exist
course_reg = CanvasCourseRegistration(user=request.user,
course=course)
course_reg.save()
if course_reg.is_blocked:
return Response({
"status":
"Blocked",
"message":
"Registration has been blocked for you. Please contact your instructor.",
})
if not course_reg.canvas_user_id:
# if the CanvasCourseRegistration does not have a student number associated, then the user is not registered
return Response({
"status": "Not Registered",
"message": None,
})
if not course_reg.is_verified:
return Response({
"status": "Awaiting Verification",
"message": None,
})
else:
return Response({
"status": "Registered",
"message": None,
})
def course_view(request, pk):
course = get_object_or_404(CanvasCourse, pk=pk)
if not course.has_view_permission(request.user):
return render(request, "403.html", status=403)
if request.method == 'POST':
token_use_data = {}
for key in request.POST.keys():
match = re.fullmatch(r"token_use#(\d+)", key)
if match:
token_use_option_id = int(match.group(1))
token_use_num = int(request.POST.get(key, '0') or 0)
token_use_data[token_use_option_id] = token_use_num
try:
update_token_use(request.user, course, token_use_data)
messages.add_message(request, messages.SUCCESS,
"Tokens Updated Successfully")
except TokenUseException:
messages.add_message(request, messages.ERROR,
"Invalid Use of Tokens")
is_instructor = course.has_edit_permission(request.user)
if is_instructor:
uqjs = UserQuestionJunction.objects.filter(
user=request.user, question__course=course).all()
else:
uqjs = UserQuestionJunction.objects.none()
course_reg = get_course_registration(request.user, course)
return render(
request, 'canvas/course.html', {
'course': course,
'course_reg': course_reg,
'uqjs': uqjs,
'is_instructor': is_instructor,
})
def register(self, request, pk=None):
"""
This endpoint completes the 'next' stage of course registration for this (user, course) pair. It decides what
the 'next' step is based on the status of the CanvasCourseRegistration and the request's POST data.
- In each case, setting success = True lets the front-end know to advance the UI to the next stage.
- Raising ValidationError() returns a pre-defined Response.
"""
name = request.data.get("name", None)
student_number = request.data.get("student_number", None)
confirmed_name = request.data.get("confirmed_name", None)
course = get_object_or_404(CanvasCourse, pk=pk)
course_reg = get_course_registration(request.user, course)
if course_reg is None:
# create a CanvasCourseRegistration for this (user, course) pair if one does not already exist
course_reg = CanvasCourseRegistration(user=request.user,
course=course)
course_reg.save()
if student_number is not None:
# if a student number was given in the request data, try to find this canvas user using it
canvas_user = course.get_user(student_id=student_number)
if canvas_user is None:
raise ValidationError()
course_reg.set_canvas_user(canvas_user)
return Response({
"success": True,
})
if confirmed_name is not None:
# if a confirmed name was given in the request data, try to find this canvas user using it. The confirmed
# name should be the same as the guessed name that the API responded with earlier in the process.
canvas_user = course.get_user(name=confirmed_name)
if not canvas_user:
raise ValidationError(ERROR_MESSAGES.USER.INVALID)
course_reg.set_canvas_user(canvas_user)
return Response({
"success": True,
})
if name is not None:
# if an inputted name is in the request data, try to guess the name properly.
guessed_names = course.guess_user(name)
if len(guessed_names) == 0:
raise ValidationError(ERROR_MESSAGES.USER.INVALID)
elif len(guessed_names) > 1:
# If more than 1 name is guessed, then the UI moves to the student number confirmation
# since the student number confirmation is not the standard process, success = False lets the front-end
# know what to render.
return Response({
"success": False,
"guessed_name": None,
})
return Response({
"success": True,
"guessed_name": guessed_names[0],
})
raise ValidationError(ERROR_MESSAGES.USER.INVALID)