def main(request):
"""
Launch the main page of the authoring app. Create a context that includes
all available edX courses and the module structure of the Canvas course from
which the tool was launched.
"""
try:
canvas_course_id = request.session['LTI_LAUNCH']['custom_canvas_course_id']
canvas_user_id = request.session['LTI_LAUNCH']['user_id']
except KeyError:
return http.HttpResponseBadRequest()
edx_courses = EdxCourse.objects.all()
try:
canvas_auth = CanvasApiAuthorization.objects.get(lti_user_id=canvas_user_id)
except CanvasApiAuthorization.DoesNotExist:
return canvas_api.start_oauth(request, canvas_user_id)
try:
canvas_courses = canvas_api.get_courses(canvas_auth)
canvas_modules = canvas_api.get_module_list(canvas_auth, canvas_course_id)
except CanvasAPIError as e:
if e.status_code == 401:
return canvas_api.start_oauth(request, canvas_user_id)
raise
return render(request, 'edx2canvas/index.html', {
'edx_courses': edx_courses,
'canvas_modules': json.dumps({'id': canvas_course_id, 'modules': canvas_modules})
})
def create_canvas_module(request):
"""
Create a new module in a Canvas course.
This method expects the following POST parameters:
- 'canvas_course_id': The ID of the course in which to create the module.
The currently-authenticated user must have write access to the course.
- 'module_name': A name to give to the newly-created module.
- 'position': A zero-based index into the module list, indicating where to
insert the new module.
"""
try:
canvas_course_id = request.POST['canvas_course_id']
name = request.POST['module_name']
position = request.POST['position']
canvas_user_id = request.session['LTI_LAUNCH']['user_id']
except KeyError:
return HttpResponseBadRequest()
try:
canvas_auth = CanvasApiAuthorization.objects.get(lti_user_id=canvas_user_id)
except CanvasApiAuthorization.DoesNotExist:
return HttpResponseForbidden()
module = canvas_api.create_canvas_module(
canvas_auth, canvas_course_id, name, position
)
module_list = canvas_api.get_module_list(canvas_auth, canvas_course_id)
return JsonResponse({'module_id': module['id'], 'modules': module_list}, safe=False)
def get_canvas_modules(request):
"""
Fetch the list of modules available in the Canvas course that launched the
tool.
Returns a JSON object with:
- id: the Canvas course ID.
- modules: a list of Canvas module objects.
"""
try:
canvas_course_id = request.GET['course_id']
canvas_user_id = request.session['LTI_LAUNCH']['user_id']
except KeyError:
return http.HttpResponseBadRequest()
try:
canvas_auth = CanvasApiAuthorization.objects.get(
lti_user_id=canvas_user_id)
except CanvasApiAuthorization.DoesNotExist:
return http.HttpResponseForbidden()
module_list = canvas_api.get_module_list(canvas_auth, canvas_course_id)
return http.JsonResponse(
{
'id': request.GET['course_id'],
'modules': module_list
}, safe=False)
def get_canvas_modules(request):
"""
Fetch the list of modules available in the Canvas course that launched the
tool.
Returns a JSON object with:
- id: the Canvas course ID.
- modules: a list of Canvas module objects.
"""
try:
canvas_course_id = request.GET['course_id']
canvas_user_id = request.session['LTI_LAUNCH']['user_id']
except KeyError:
return http.HttpResponseBadRequest()
try:
canvas_auth = CanvasApiAuthorization.objects.get(lti_user_id=canvas_user_id)
except CanvasApiAuthorization.DoesNotExist:
return http.HttpResponseForbidden()
module_list = canvas_api.get_module_list(canvas_auth, canvas_course_id)
return http.JsonResponse(
{'id': request.GET['course_id'], 'modules': module_list}, safe=False
)
def main(request):
"""
Launch the main page of the authoring app. Create a context that includes
all available edX courses and the module structure of the Canvas course from
which the tool was launched.
"""
try:
canvas_course_id = request.session['LTI_LAUNCH'][
'custom_canvas_course_id']
canvas_user_id = request.session['LTI_LAUNCH']['user_id']
except KeyError:
return http.HttpResponseBadRequest()
edx_courses = EdxCourse.objects.all()
try:
canvas_auth = CanvasApiAuthorization.objects.get(
lti_user_id=canvas_user_id)
except CanvasApiAuthorization.DoesNotExist:
return canvas_api.start_oauth(request, canvas_user_id)
try:
canvas_courses = canvas_api.get_courses(canvas_auth)
canvas_modules = canvas_api.get_module_list(canvas_auth,
canvas_course_id)
except CanvasAPIError as e:
if e.status_code == 401:
return canvas_api.start_oauth(request, canvas_user_id)
raise
return render(
request, 'edx2canvas/index.html', {
'edx_courses':
edx_courses,
'canvas_modules':
json.dumps({
'id': canvas_course_id,
'modules': canvas_modules
})
})
def add_to_canvas(request):
"""
Create a new module item in Canvas that launches one piece of edX content.
There are two possibilities:
- For a graded exercise (where 'graded' is 'true'), a new Canvas assignment
is created (worth one point), and a module item is created that points to
the new assignment.
- For a non-graded piece of content (when 'graded' is 'false'), a new
module item is created that launches the content directly.
In both cases, if the Open edX LTI tool is not installed on the course, it
is created. Any subsequently-created items will use that external tool (i.e.
there will only be one instance of the Open edX LTI tool installed).
The method expects the following POST parameters:
- edx_course_id: an ID into the EdxCourse model.
- canvas_course_id: a Canvas-defined course identifier.
- module_id: a Canvas-defined module identifier.
- title: the title for the new module item (and assignment, if necessary).
- position: the zero-based index of the new item in the module list.
- usage_id: an edX-defined identifier for the content to import.
- graded: 'true' if an assignment should be created, 'false' if not.
"""
try:
edx_course_id = request.POST['edx_course_id']
canvas_course_id = request.POST['canvas_course_id']
module_id = request.POST['module_id']
title = request.POST['title']
position = request.POST['position']
usage_id = request.POST['usage_id']
graded = request.POST['graded'].lower() not in ('false', '0')
if graded:
points = request.POST['points']
canvas_user_id = request.session['LTI_LAUNCH']['user_id']
except KeyError as e:
return HttpResponseBadRequest(e)
try:
edx_course = EdxCourse.objects.get(id=edx_course_id)
except EdxCourse.DoesNotExist:
return HttpResponseBadRequest()
edx_course_key = edx_course.course_key()
try:
canvas_auth = CanvasApiAuthorization.objects.get(lti_user_id=canvas_user_id)
except CanvasApiAuthorization.DoesNotExist:
return HttpResponseForbidden()
external_tool_id = canvas_api.get_external_tool_id(canvas_auth, canvas_course_id)
if graded:
canvas_api.create_assignment_with_module_item(
canvas_auth, title, canvas_course_id, module_id, position,
external_tool_id, get_lti_url_for_usage_id(edx_course_key, usage_id),
points
)
else:
canvas_api.create_canvas_module_item(
canvas_auth, title, canvas_course_id, module_id, position,
external_tool_id, get_lti_url_for_usage_id(edx_course_key, usage_id)
)
module_list = canvas_api.get_module_list(canvas_auth, canvas_course_id)
return JsonResponse({'id': canvas_course_id, 'modules': module_list}, safe=False)
