199 lines
6.7 KiB
Python
199 lines
6.7 KiB
Python
from django.http import HttpResponse
|
|
from django.template import Context, loader
|
|
from djangomako.shortcuts import render_to_response, render_to_string
|
|
import json, os, sys
|
|
from django.core.context_processors import csrf
|
|
|
|
from django.template import Context
|
|
from django.contrib.auth.models import User
|
|
from auth.models import UserProfile
|
|
from django.shortcuts import redirect
|
|
|
|
import StringIO
|
|
import track.views
|
|
|
|
from django.http import Http404
|
|
|
|
import urllib
|
|
|
|
import capa_module
|
|
import video_module
|
|
import html_module
|
|
import schematic_module
|
|
|
|
from models import StudentModule
|
|
|
|
import urllib
|
|
|
|
from django.conf import settings
|
|
|
|
import content_parser
|
|
|
|
import uuid
|
|
|
|
modx_modules={'problem':capa_module.LoncapaModule,
|
|
'video':video_module.VideoModule,
|
|
'html':html_module.HtmlModule,
|
|
'schematic':schematic_module.SchematicModule}
|
|
|
|
def make_track_function(request):
|
|
def f(event_type, event):
|
|
return track.views.server_track(request, event_type, event, page='x_module')
|
|
return f
|
|
|
|
def modx_dispatch(request, module=None, dispatch=None, id=None):
|
|
''' Generic view for extensions. '''
|
|
# Grab the student information for the module from the database
|
|
s = StudentModule.objects.filter(module_type=module,
|
|
student=request.user,
|
|
module_id=id)
|
|
if len(s) == 0:
|
|
print "ls404"
|
|
raise Http404
|
|
|
|
s=s[0]
|
|
|
|
dispatch=dispatch.split('?')[0]
|
|
|
|
ajax_url = '/modx/'+module+'/'+id+'/'
|
|
|
|
id_tag=modx_modules[module].id_attribute
|
|
|
|
# Grab the XML corresponding to the request from course.xml
|
|
xml = content_parser.module_xml(content_parser.course_file(request.user), module, id_tag, id)
|
|
|
|
# Create the module
|
|
instance=modx_modules[module](xml,
|
|
s.module_id,
|
|
ajax_url=ajax_url,
|
|
state=s.state,
|
|
track_function = make_track_function(request))
|
|
# Let the module handle the AJAX
|
|
ajax_return=instance.handle_ajax(dispatch, request.POST)
|
|
# Save the state back to the database
|
|
s.state=instance.get_state()
|
|
s.grade=instance.get_score()['score']
|
|
s.save()
|
|
# Return whatever the module wanted to return to the client/caller
|
|
return HttpResponse(ajax_return)
|
|
|
|
def vertical_module(request, module):
|
|
''' Layout module which lays out content vertically.
|
|
'''
|
|
contents=[(e.getAttribute("name"),render_module(request, e)) \
|
|
for e in module.childNodes \
|
|
if e.nodeType==1]
|
|
init_js="".join([e[1]['init_js'] for e in contents if 'init_js' in e[1]])
|
|
destroy_js="".join([e[1]['destroy_js'] for e in contents if 'destroy_js' in e[1]])
|
|
|
|
return {'init_js':init_js,
|
|
'destroy_js':destroy_js,
|
|
'content':render_to_string('vert_module.html',{'items':contents}),
|
|
'type':'vertical'}
|
|
|
|
def seq_module(request, module):
|
|
''' Layout module which lays out content in a temporal sequence
|
|
'''
|
|
def j(m):
|
|
# jsonify contents so it can be embedded in a js array
|
|
# We also need to split </script> tags so they don't break
|
|
# mid-string
|
|
if 'init_js' not in m: m['init_js']=""
|
|
if 'type' not in m: m['init_js']=""
|
|
content=json.dumps(m['content'])
|
|
content=content.replace('</script>', '<"+"/script>')
|
|
|
|
return {'content':content,
|
|
"destroy_js":m['destroy_js'],
|
|
'init_js':m['init_js'],
|
|
'type':m['type']}
|
|
contents=[(e.getAttribute("name"),j(render_module(request, e))) \
|
|
for e in module.childNodes \
|
|
if e.nodeType==1]
|
|
|
|
js=""
|
|
|
|
iid=uuid.uuid1().hex
|
|
|
|
params={'items':contents,
|
|
'id':"seq"}
|
|
|
|
# TODO/BUG: Destroy JavaScript should only be called for the active view
|
|
# This calls it for all the views
|
|
#
|
|
# To fix this, we'd probably want to have some way of assigning unique
|
|
# IDs to sequences.
|
|
destroy_js="".join([e[1]['destroy_js'] for e in contents if 'destroy_js' in e[1]])
|
|
|
|
if module.nodeName == 'sequential':
|
|
return {'init_js':js+render_to_string('seq_module.js',params),
|
|
"destroy_js":destroy_js,
|
|
'content':render_to_string('seq_module.html',params),
|
|
'type':'sequential'}
|
|
if module.nodeName == 'tab':
|
|
params['id'] = 'tab'
|
|
return {'init_js':js+render_to_string('tab_module.js',params),
|
|
"destroy_js":destroy_js,
|
|
'content':render_to_string('tab_module.html',params),
|
|
'type':'tab'}
|
|
|
|
|
|
def render_x_module(request, xml_module):
|
|
''' Generic module for extensions. This renders to HTML. '''
|
|
# Check if problem has an instance in DB
|
|
module_type=xml_module.nodeName
|
|
module_class=modx_modules[module_type]
|
|
module_id=xml_module.getAttribute(module_class.id_attribute)
|
|
|
|
# Grab state from database
|
|
s = StudentModule.objects.filter(student=request.user,
|
|
module_id=module_id,
|
|
module_type = module_type)
|
|
if len(s) == 0: # If nothing in the database...
|
|
state=None
|
|
else:
|
|
smod = s[0]
|
|
state = smod.state
|
|
|
|
# Create a new instance
|
|
ajax_url = '/modx/'+module_type+'/'+module_id+'/'
|
|
instance=module_class(xml_module.toxml(),
|
|
module_id,
|
|
ajax_url=ajax_url,
|
|
state=state,
|
|
track_function = make_track_function(request))
|
|
|
|
# If instance wasn't already in the database, create it
|
|
if len(s) == 0:
|
|
smod=StudentModule(student=request.user,
|
|
module_type = module_type,
|
|
module_id=module_id,
|
|
state=instance.get_state())
|
|
# Grab content
|
|
content = {'content':instance.get_html(),
|
|
"destroy_js":instance.get_destroy_js(),
|
|
'init_js':instance.get_init_js(),
|
|
'type':module_type}
|
|
|
|
smod.save() # This may be optional (at least in the case of no instance in the dB)
|
|
|
|
return content
|
|
|
|
module_types={'video':render_x_module,
|
|
'html':render_x_module,
|
|
'tab':seq_module,
|
|
'vertical':vertical_module,
|
|
'sequential':seq_module,
|
|
'problem':render_x_module,
|
|
'schematic':render_x_module
|
|
}
|
|
|
|
def render_module(request, module):
|
|
''' Generic dispatch for internal modules. '''
|
|
if module==None:
|
|
return {"content":""}
|
|
if str(module.localName) in module_types:
|
|
return module_types[module.localName](request, module)
|
|
print "rm404"
|
|
raise Http404
|