def add(request):
course_prefix = request.POST.get("course_prefix")
course_suffix = request.POST.get("course_suffix")
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
if not common_page_data['is_course_admin']:
return redirect('courses.views.view', course_prefix, course_suffix)
menu_slug = None
if request.POST.get("menu_slug") != "":
menu_slug = request.POST.get("menu_slug")
section = None
if request.POST.get("section_id") != "":
section = ContentSection.objects.get(id=request.POST.get("section_id"))
if request.POST.get("menu_slug") != "":
index = len(AdditionalPage.objects.filter(course=common_page_data['course'],menu_slug=request.POST.get("menu_slug")))
else:
index = section.getNextIndex()
staging_page = AdditionalPage(course=common_page_data['staging_course'], menu_slug=menu_slug, section=section, title=request.POST.get("title"), slug=request.POST.get("slug"), index=index, mode='staging')
staging_page.save()
staging_page.create_production_instance()
if request.POST.get("menu_slug") == "":
return redirect('courses.views.course_materials', course_prefix, course_suffix)
else:
return redirect(request.META['HTTP_REFERER'])
def save_content_order(request):
try:
common_page_data = get_common_page_data(request, request.POST.get("course_prefix"), request.POST.get("course_suffix"))
except:
raise Http404
if not common_page_data['is_course_admin']:
return redirect('courses.views.main', request.POST.get("course_prefix"), request.POST.get("course_suffix"))
SECTION = ContentSection.objects.get(pk=request.POST.get('section_id'))
section_structures = get_course_materials(common_page_data=common_page_data, get_video_content=True, get_additional_page_content = True, get_file_content=True, get_exam_content=True, SECTION=SECTION)
def set_index_from_POST(item):
tag = item['type']
image = item[tag].image
new_index = request.POST.get("order_"+tag+"_"+str(item[tag].id))
item[tag].index = new_index
item[tag].save()
image.index = new_index
image.save()
for section_structure in section_structures:
for item in section_structure['items']:
set_index_from_POST(item)
return redirect(request.META['HTTP_REFERER'])
def upload(request):
course_prefix = request.POST.get("course_prefix")
course_suffix = request.POST.get("course_suffix")
common_page_data = get_common_page_data(request, course_prefix,
course_suffix)
if request.method == "POST":
form = FileUploadForm(request.POST,
request.FILES,
course=common_page_data['course'])
if form.is_valid():
new_file = form.save(commit=False)
new_file.course = common_page_data['course']
new_file.index = new_file.section.getNextIndex()
new_file.mode = 'draft'
new_file.handle = course_prefix + "--" + course_suffix
new_file.save()
new_file.create_ready_instance()
create_contentgroup_entries_from_post(
request, 'parent', new_file.image, 'file',
request.POST.get('display_style', 'list'))
return redirect('courses.views.course_materials', course_prefix,
course_suffix)
form = FileUploadForm(course=common_page_data['course'])
reverseview = 'courses.files.actions.upload'
return render(
request, 'files/upload.html', {
'reverseview': reverseview,
'common_page_data': common_page_data,
'form': form,
})
def list(request, course_prefix, course_suffix):
try:
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
except:
raise Http404
if "id" in request.GET:
# process Video model instance with this youtube id
# and other stuff
try:
video = Video.objects.get(pk=request.GET["vid"])
except Video.DoesNotExist:
raise Http404
video.url = request.GET["id"]
video.save()
video.create_ready_instance()
section_structures = get_course_materials(common_page_data=common_page_data, get_video_content=True)
form = None
if request.common_page_data["course_mode"] == "draft":
form = LiveDateForm()
return render_to_response(
"videos/" + common_page_data["course_mode"] + "/list.html",
{
"common_page_data": common_page_data,
"section_structures": section_structures,
"context": "video_list",
"form": form,
},
context_instance=RequestContext(request),
)
def add_video(request):
course_prefix = request.POST.get("course_prefix")
course_suffix = request.POST.get("course_suffix")
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
if not common_page_data['is_course_admin']:
return redirect('courses.views.view', course_prefix, course_suffix)
index = len(Video.objects.filter(topic_id=request.POST.get("topic_id")))
draft_video = Video(
course=common_page_data['draft_course'],
topic_id=int(request.POST.get("topic_id")),
title=request.POST.get("title"),
#description=request.POST.get("description"),
type='youtube',
url=request.POST.get("yt_id"),
slug=request.POST.get("slug"),
mode='draft',
index=index
)
draft_video.save()
draft_video.create_ready_instance()
return redirect(request.META['HTTP_REFERER'])
def upload(request):
course_prefix = request.POST.get("course_prefix")
course_suffix = request.POST.get("course_suffix")
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
if request.method == "POST":
form = FileUploadForm(request.POST, request.FILES, course=common_page_data['course'])
if form.is_valid():
new_file = form.save(commit=False)
new_file.course = common_page_data['course']
new_file.index = new_file.section.getNextIndex()
new_file.mode = 'draft'
new_file.handle = course_prefix + "--" + course_suffix
new_file.save()
new_file.create_ready_instance()
parent_type = request.POST.get('parent')
if parent_type and parent_type[:4] != 'none':
parent_type, parent_id = parent_type.split(',')
else:
parent_type, parent_id = None, None
if parent_type:
parent_ref = ContentGroup.groupable_types[parent_type].objects.get(id=long(parent_id)).image
content_group_groupid = ContentGroup.add_parent(new_file.image.course, parent_type, parent_ref.image)
ContentGroup.add_child(content_group_groupid, 'file', new_file.image, display_style=request.POST.get('display_style'))
return redirect('courses.views.course_materials', course_prefix, course_suffix)
else:
form = FileUploadForm(course=common_page_data['course'])
return render(request, 'files/upload.html',
{'common_page_data': common_page_data,
'form': form,
})
def create_action(request):
course_prefix = request.POST.get("course_prefix")
course_suffix = request.POST.get("course_suffix")
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
data = {'common_page_data': common_page_data, 'course_prefix': course_prefix, 'course_suffix': course_suffix}
if request.method == 'POST':
pset = ProblemSet(course = common_page_data['course'])
form = CreateProblemSet(request.POST, request.FILES, course=common_page_data['course'], instance=pset)
if form.is_valid():
new_pset = form.save(commit=False)
new_pset.course = common_page_data['course']
new_pset.mode = 'draft'
new_pset.handle = course_prefix + "--" + course_suffix
new_pset.path = "/"+request.POST['course_prefix']+"/"+request.POST['course_suffix']+"/problemsets/"+new_pset.slug+"/load_problem_set"
new_pset.save()
section = new_pset.section
new_pset.index = section.getNextIndex()
new_pset.save()
new_pset.create_ready_instance()
return HttpResponseRedirect(reverse('problemsets.views.manage_exercises', args=(request.POST['course_prefix'], request.POST['course_suffix'], new_pset.slug,)))
else:
form = CreateProblemSet(course=common_page_data['course'])
data['form'] = form
return render_to_response('problemsets/create.html', data, context_instance=RequestContext(request))
def process_view (self, request, view_func, view_args, view_kwargs):
if (('course_prefix' not in view_kwargs) or
('course_suffix' not in view_kwargs)):
#No course information in the URL. There is a special case that has it as a POST parameter (Why?)
#Handle those here
if ((not request.POST.__contains__('course_prefix')) or
(not request.POST.get('course_prefix')) or
(not request.POST.__contains__('course_suffix')) or
(not request.POST.get('course_suffix'))):
return None
else:
#The course info is in the POST in this case
cp = request.POST.get('course_prefix')
cs = request.POST.get('course_suffix')
else:
cp = view_kwargs['course_prefix']
cs = view_kwargs['course_suffix']
try:
request.common_page_data=get_common_page_data(request, cp, cs)
#logger.info('Ran get_common_page_data course: ' + request.common_page_data['course_mode'])
return None
except Course.DoesNotExist:
raise Http404
def upload(request):
course_prefix = request.POST.get("course_prefix")
course_suffix = request.POST.get("course_suffix")
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
if request.method == "POST":
form = FileUploadForm(request.POST, request.FILES, course=common_page_data["course"])
if form.is_valid():
new_file = form.save(commit=False)
new_file.course = common_page_data["course"]
new_file.index = new_file.section.getNextIndex()
new_file.mode = "draft"
new_file.handle = course_prefix + "--" + course_suffix
new_file.save()
new_file.create_ready_instance()
create_contentgroup_entries_from_post(
request, "parent", new_file.image, "file", request.POST.get("display_style", "list")
)
return redirect("courses.views.course_materials", course_prefix, course_suffix)
else:
form = FileUploadForm(course=common_page_data["course"])
reverseview = "courses.files.actions.upload"
return render(
request, "files/upload.html", {"reverseview": reverseview, "common_page_data": common_page_data, "form": form}
)
def add_announcement(request):
try:
common_page_data = get_common_page_data(request, request.POST.get("course_prefix"), request.POST.get("course_suffix"))
except:
raise Http404
if not common_page_data['is_course_admin']:
return redirect('courses.views.main', request.POST.get("course_prefix"), request.POST.get("course_suffix"))
index = len(Announcement.objects.getByCourse(course=common_page_data['course']))
announcement = Announcement(
course=common_page_data['course'],
title=request.POST.get("title"),
description=request.POST.get("description"),
index=index,
mode='draft',
owner=request.user,
)
announcement.save()
announcement.create_ready_instance()
if request.POST.get("commit") == '1':
announcement.commit()
return redirect(request.META['HTTP_REFERER'])
def save_exercises(request):
# Function should only be accessed from submitting a form
if request.method != "POST":
return redirect(request.META["HTTP_REFERER"])
course_prefix = request.POST["course_prefix"]
course_suffix = request.POST["course_suffix"]
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
pset = ProblemSet.objects.get(id=request.POST["pset_id"])
action = request.POST["action"]
if action == "Reset to Ready":
pset.revert()
return HttpResponseRedirect(
reverse(
"problemsets.views.manage_exercises",
args=(request.POST["course_prefix"], request.POST["course_suffix"], pset.slug),
)
)
else:
psetToExs = list(ProblemSetToExercise.objects.getByProblemset(pset))
for n in range(0, len(psetToExs)):
listName = "exercise_order[" + str(n) + "]"
psetToExs[n].number = request.POST[listName]
psetToExs[n].save()
if action == "Save and Set as Ready":
pset.commit()
return HttpResponseRedirect(
reverse("problemsets.views.listAll", args=(request.POST["course_prefix"], request.POST["course_suffix"]))
)
def add_announcement(request):
try:
common_page_data = get_common_page_data(
request, request.POST.get("course_prefix"),
request.POST.get("course_suffix"))
except:
raise Http404
if not common_page_data['is_course_admin']:
return redirect('courses.views.main',
request.POST.get("course_prefix"),
request.POST.get("course_suffix"))
index = len(
Announcement.objects.getByCourse(course=common_page_data['course']))
announcement = Announcement(
course=common_page_data['course'],
title=request.POST.get("title"),
description=request.POST.get("description"),
index=index,
mode='draft',
owner=request.user,
)
announcement.save()
announcement.create_ready_instance()
if request.POST.get("commit") == '1':
announcement.commit()
return redirect(request.META['HTTP_REFERER'])
def create_form(request, course_prefix, course_suffix):
try:
common_page_data = get_common_page_data(request, course_prefix,
course_suffix)
except:
raise Http404
data = {'common_page_data': common_page_data}
form = CreateProblemSet(course=common_page_data['course'],
initial={
'late_penalty':
10,
'assessment_type':
'formative',
'submissions_permitted':
0,
'resubmission_penalty':
0,
'due_date': (datetime.today() + timedelta(7)),
'grace_period':
(datetime.today() + timedelta(14)),
'partial_credit_deadline':
(datetime.today() + timedelta(21))
})
data['form'] = form
data['course_prefix'] = course_prefix
data['course_suffix'] = course_suffix
return render_to_response('problemsets/create.html',
data,
context_instance=RequestContext(request))
def manage_nav_menu(request, course_prefix, course_suffix):
try:
common_page_data = get_common_page_data(request, course_prefix, course_suffix, use_cache=False)
except e, msg:
# Remark to console exception characterization so we can make this clause more specific
print "Error in manage_nav_menu getting common_page_data, exception caught: %s" % msg
raise Http404
def save_announcement(request):
try:
common_page_data = get_common_page_data(
request, request.POST.get("course_prefix"), request.POST.get("course_suffix")
)
except:
raise Http404
if not common_page_data["is_course_admin"]:
return redirect("courses.views.main", request.POST.get("course_prefix"), request.POST.get("course_suffix"))
announcement = Announcement.objects.get(id=request.POST.get("announcement_id"))
announcement.title = request.POST.get("title")
announcement.description = request.POST.get("description")
announcement.save()
if request.POST.get("commit") == "1":
announcement.commit()
if request.POST.get("revert") == "1":
announcement.revert()
return redirect(
"courses.announcements.views.list", request.POST.get("course_prefix"), request.POST.get("course_suffix")
)
def save_content_order(request):
try:
common_page_data = get_common_page_data(
request, request.POST.get("course_prefix"), request.POST.get("course_suffix")
)
except:
raise Http404
if not common_page_data["is_course_admin"]:
return redirect("courses.views.main", request.POST.get("course_prefix"), request.POST.get("course_suffix"))
section_structures = get_course_materials(
common_page_data=common_page_data,
get_video_content=True,
get_pset_content=True,
get_additional_page_content=True,
get_file_content=True,
get_exam_content=True,
)
for section_structure in section_structures:
if section_structure["section"].id == long(request.POST.get("section_id")):
for item in section_structure["items"]:
if item["type"] == "video":
item["video"].index = request.POST.get("order_video_" + str(item["video"].id))
item["video"].save()
video_image = item["video"].image
video_image.index = request.POST.get("order_video_" + str(item["video"].id))
video_image.save()
elif item["type"] == "problem_set":
item["problem_set"].index = request.POST.get("order_problem_set_" + str(item["problem_set"].id))
item["problem_set"].save()
problem_set_image = item["problem_set"].image
problem_set_image.index = request.POST.get("order_problem_set_" + str(item["problem_set"].id))
problem_set_image.save()
elif item["type"] == "additional_page":
item["additional_page"].index = request.POST.get(
"order_additional_page_" + str(item["additional_page"].id)
)
item["additional_page"].save()
additional_page_image = item["additional_page"].image
additional_page_image.index = request.POST.get(
"order_additional_page_" + str(item["additional_page"].id)
)
additional_page_image.save()
elif item["type"] == "file":
item["file"].index = request.POST.get("order_file_" + str(item["file"].id))
item["file"].save()
file_image = item["file"].image
file_image.index = request.POST.get("order_file_" + str(item["file"].id))
file_image.save()
elif item["type"] == "exam":
item["exam"].index = request.POST.get("order_exam_" + str(item["exam"].id))
item["exam"].save()
exam_image = item["exam"].image
exam_image.index = request.POST.get("order_exam_" + str(item["exam"].id))
exam_image.save()
break
return redirect(request.META["HTTP_REFERER"])
def save_exercises(request):
#Function should only be accessed from submitting a form
if request.method != 'POST':
return redirect(request.META['HTTP_REFERER'])
course_prefix = request.POST['course_prefix']
course_suffix = request.POST['course_suffix']
common_page_data = get_common_page_data(request, course_prefix,
course_suffix)
pset = ProblemSet.objects.get(id=request.POST['pset_id'])
action = request.POST['action']
if action == 'Reset to Ready':
pset.revert()
return HttpResponseRedirect(
reverse('problemsets.views.manage_exercises',
args=(
request.POST['course_prefix'],
request.POST['course_suffix'],
pset.slug,
)))
else:
psetToExs = list(ProblemSetToExercise.objects.getByProblemset(pset))
for n in range(0, len(psetToExs)):
listName = "exercise_order[" + str(n) + "]"
psetToExs[n].number = request.POST[listName]
psetToExs[n].save()
if action == 'Save and Set as Ready':
pset.commit()
return HttpResponseRedirect(
reverse('problemsets.views.listAll',
args=(request.POST['course_prefix'],
request.POST['course_suffix'])))
def admin(request, course_prefix, course_suffix):
try:
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
except:
raise Http404
return render_to_response('courses/admin.html', {'common_page_data':common_page_data}, context_instance=RequestContext(request))
def save_announcement(request):
try:
common_page_data = get_common_page_data(
request, request.POST.get("course_prefix"),
request.POST.get("course_suffix"))
except:
raise Http404
if not common_page_data['is_course_admin']:
return redirect('courses.views.main',
request.POST.get("course_prefix"),
request.POST.get("course_suffix"))
announcement = Announcement.objects.get(
id=request.POST.get("announcement_id"))
announcement.title = request.POST.get("title")
announcement.description = request.POST.get("description")
announcement.save()
if request.POST.get("commit") == '1':
announcement.commit()
if request.POST.get("revert") == '1':
announcement.revert()
return redirect('courses.announcements.views.list',
request.POST.get("course_prefix"),
request.POST.get("course_suffix"))
def edit_action(request):
course_prefix = request.POST.get("course_prefix")
course_suffix = request.POST.get("course_suffix")
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
data = {'common_page_data': common_page_data, 'course_prefix': course_prefix, 'course_suffix': course_suffix}
pset_id = request.POST.get("pset_id")
if not common_page_data['is_course_admin']:
return redirect('courses.views.main', course_prefix, course_suffix)
if request.method == 'POST':
pset = ProblemSet.objects.get(id=pset_id)
action = request.POST['action']
if action == "Reset to Ready":
pset.revert()
form = CreateProblemSet(course=common_page_data['course'], instance=pset)
else:
form = CreateProblemSet(request.POST, course=common_page_data['course'], instance=pset)
if form.is_valid():
form.save()
pset.path = "/"+course_prefix+"/"+course_suffix+"/problemsets/"+pset.slug+"/load_problem_set"
pset.save()
if action == "Save and Set as Ready":
pset.commit()
return HttpResponseRedirect(reverse('problemsets.views.list', args=(course_prefix, course_suffix)))
data['form'] = form
data['pset'] = pset
return render(request, 'problemsets/edit.html', data)
def view(request, course_prefix, course_suffix, slug):
try:
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
except:
raise Http404
try:
video = Video.objects.get(course=common_page_data['course'], slug=slug)
except Video.DoesNotExist:
raise Http404
if not common_page_data['is_course_admin']:
visit_log = PageVisitLog(
course = common_page_data['ready_course'],
user = request.user,
page_type= 'video',
object_id = str(video.id),
)
visit_log.save()
video_rec = request.user.videoactivity_set.filter(video=video)
if video_rec:
video_rec = video_rec[0]
else:
#note student field to be renamed to user, VideoActivity for all users now
video_rec = VideoActivity(student=request.user, course=common_page_data['course'], video=video)
video_rec.save()
if video.mode == 'ready':
draft_version = video.image
video = draft_version
return render_to_response('videos/view.html', {'common_page_data': common_page_data, 'video': video, 'video_rec':video_rec}, context_instance=RequestContext(request))
def upload(request):
course_prefix = request.POST.get("course_prefix")
course_suffix = request.POST.get("course_suffix")
common_page_data = get_common_page_data(request, course_prefix,
course_suffix)
if request.method == "POST":
form = FileUploadForm(request.POST,
request.FILES,
course=common_page_data['course'])
if form.is_valid():
new_file = form.save(commit=False)
new_file.course = common_page_data['course']
new_file.index = new_file.section.getNextIndex()
new_file.mode = 'draft'
new_file.handle = course_prefix + "--" + course_suffix
new_file.save()
new_file.create_ready_instance()
return redirect('courses.views.course_materials', course_prefix,
course_suffix)
else:
form = FileUploadForm(course=common_page_data['course'])
return render(request, 'files/upload.html', {
'common_page_data': common_page_data,
'form': form,
})
def edit_video(request):
course_prefix = request.POST.get("course_prefix")
course_suffix = request.POST.get("course_suffix")
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
slug = request.POST.get("video_slug")
if not common_page_data['is_course_admin']:
return redirect('courses.views.main', course_prefix, course_suffix)
if request.method == 'POST':
video = common_page_data['course'].video_set.all().get(slug=slug)
action = request.POST['action']
if action == "Reset to Ready":
video.revert()
form = S3UploadForm(course=common_page_data['course'], instance=video)
else:
form = S3UploadForm(request.POST, request.FILES, course=common_page_data['course'], instance=video)
if form.is_valid():
form.save()
if action == "Save and Set as Ready":
video.commit()
return redirect('courses.videos.views.list', course_prefix, course_suffix)
return render(request, 'videos/edit.html',
{'common_page_data': common_page_data,
'slug': slug,
'form': form,
})
def create_action(request):
course_prefix = request.POST.get("course_prefix")
course_suffix = request.POST.get("course_suffix")
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
data = {'common_page_data': common_page_data, 'course_prefix': course_prefix, 'course_suffix': course_suffix}
if request.method == 'POST':
pset = ProblemSet(course = common_page_data['course'])
form = CreateProblemSet(request.POST, request.FILES, course=common_page_data['course'], instance=pset)
if form.is_valid():
new_pset = form.save(commit=False)
new_pset.course = common_page_data['course']
new_pset.mode = 'draft'
new_pset.handle = course_prefix + "--" + course_suffix
new_pset.path = "/"+request.POST['course_prefix']+"/"+request.POST['course_suffix']+"/problemsets/"+new_pset.slug+"/load_problem_set"
new_pset.save()
section = new_pset.section
new_pset.index = section.getNextIndex()
new_pset.save()
new_pset.create_ready_instance()
return HttpResponseRedirect(reverse('problemsets.views.manage_exercises', args=(request.POST['course_prefix'], request.POST['course_suffix'], new_pset.slug,)))
else:
form = CreateProblemSet(course=common_page_data['course'])
data['form'] = form
return render_to_response('problemsets/create.html', data, context_instance=RequestContext(request))
def upload(request):
course_prefix = request.POST.get("course_prefix")
course_suffix = request.POST.get("course_suffix")
exam_id = request.POST.get("exam_id", "")
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
data = {"common_page_data": common_page_data}
if request.method == "POST":
request.session["video_privacy"] = request.POST.get("video_privacy")
# Need partial instance with course for form slug validation
new_video = Video(course=common_page_data["course"])
form = S3UploadForm(request.POST, request.FILES, course=common_page_data["course"], instance=new_video)
if form.is_valid():
new_video.index = new_video.section.getNextIndex()
new_video.mode = "draft"
new_video.handle = course_prefix + "--" + course_suffix
if exam_id:
try:
exam = Exam.objects.get(id=exam_id)
except Exam.DoesNotExist:
return HttpResponseBadRequest("The exam you wanted to link to this video was not found!")
new_video.exam = exam
exam.live_datetime = new_video.live_datetime
exam.save()
if exam.image:
exam.image.live_datetime = new_video.live_datetime
exam.image.save()
# Bit of jiggery pokery to so that the id is set when the upload_path function is called.
# Now storing file with id appended to the file path so that thumbnail and associated manifest files
# are easily associated with the video by putting them all in the same directory.
new_video.file = None
new_video.save()
new_video.file = form.cleaned_data["file"]
new_video.save()
new_video.create_ready_instance()
# print new_video.file.url
# kick off remote jobs
kelvinator.tasks.kelvinate.delay(new_video.file.name)
kelvinator.tasks.resize.delay(new_video.file.name, "large")
kelvinator.tasks.resize.delay(new_video.file.name, "small")
if new_video.url:
return redirect("courses.videos.views.list", course_prefix, course_suffix)
authUrl = GetOAuth2Url(request, new_video)
# eventually should store an access token, so they don't have to give permission everytime
return redirect(authUrl)
# return redirect("http://" + request.META['HTTP_HOST'])
else:
form = S3UploadForm(course=common_page_data["course"])
data["form"] = form
return render_to_response("videos/s3upload.html", data, context_instance=RequestContext(request))
def prototype(request, course_prefix, course_suffix):
"""FIXME write a doc string"""
user = request.user
if not request.common_page_data:
try:
request.common_page_data = get_common_page_data(
request, course_prefix, course_suffix)
except:
raise Http404
jabber_base = getattr(settings, 'JABBER_DOMAIN', '')
if not jabber_base:
raise Http404
if user.is_authenticated():
environment = {
'request': request,
'course_prefix': course_prefix,
'course_suffix': course_suffix,
'jabber_base': jabber_base,
'user': user,
'nick': user.username + '@' + jabber_base,
'course': request.common_page_data['course'],
}
return render_to_response('chat/prototype.html',
environment,
context_instance=RequestContext(request))
else:
return redirect('courses.views.main', course_prefix, course_suffix)
def show(request, course_prefix, course_suffix, pset_slug):
try:
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
except:
raise Http404
try:
ps = ProblemSet.objects.getByCourse(course=common_page_data['course']).get(slug=pset_slug)
except:
messages.add_message(request,messages.ERROR, 'This Problemset is not visible in the student view at this time. Please note that students will not see this message.')
return HttpResponseRedirect(reverse('problemsets.views.list', args=(course_prefix, course_suffix)))
problem_activities = ProblemActivity.objects.select_related('problemset_to_exercise').filter(student=request.user, problemset_to_exercise__problemSet=ps)
psetToExs = ProblemSetToExercise.objects.getByProblemset(ps)
activity_list = []
for psetToEx in psetToExs:
#attempts = problem_activities.filter(problemset_to_exercise=psetToEx).order_by('-time_created')
attempts = problem_activities.filter(problemset_to_exercise=psetToEx).order_by('-complete', '-attempt_number')
if len(attempts) > 0:
activity_list.append(attempts[0])
return render_to_response('problemsets/problemset.html',
{'common_page_data':common_page_data,
'pset': ps,
'pset_url':ps.path,
'pset_type':ps.assessment_type,
'pset_penalty':ps.resubmission_penalty,
'pset_attempts_allowed':ps.submissions_permitted,
'activity_list': activity_list,
},
context_instance=RequestContext(request))
def view(request, course_prefix, course_suffix, slug):
try:
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
except:
raise Http404
try:
video = Video.objects.get(course=common_page_data["course"], slug=slug)
except Video.DoesNotExist:
raise Http404
if not common_page_data["is_course_admin"]:
visit_log = PageVisitLog(
course=common_page_data["ready_course"], user=request.user, page_type="video", object_id=str(video.id)
)
visit_log.save()
video_rec = request.user.videoactivity_set.filter(video=video)
if video_rec:
video_rec = video_rec[0]
else:
# note student field to be renamed to user, VideoActivity for all users now
video_rec = VideoActivity(student=request.user, course=common_page_data["course"], video=video)
video_rec.save()
return render(
request, "videos/view.html", {"common_page_data": common_page_data, "video": video, "video_rec": video_rec}
)
def save_exercises(request):
#Function should only be accessed from submitting a form
if request.method != 'POST':
return redirect(request.META['HTTP_REFERER'])
course_prefix = request.POST['course_prefix']
course_suffix = request.POST['course_suffix']
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
#don't catch video DoesNotExist here because we want some tangible error action to happen if
#the video id changes in form submission, like mailing us
video = Video.objects.get(id=request.POST['video_id'])
action = request.POST['action']
if action == 'Reset to Ready':
video.revert()
return HttpResponseRedirect(reverse('courses.videos.views.manage_exercises', args=(request.POST['course_prefix'], request.POST['course_suffix'], video.slug,)))
else:
videoToExs = VideoToExercise.objects.getByVideo(video)
for videoToEx in videoToExs:
videoToEx.video_time = request.POST[videoToEx.exercise.fileName]
videoToEx.save()
if action == 'Save and Set as Ready':
video.commit()
return HttpResponseRedirect(reverse('courses.videos.views.list', args=(request.POST['course_prefix'], request.POST['course_suffix'],)))
def list(request, course_prefix, course_suffix):
try:
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
except:
raise Http404
if 'id' in request.GET:
#process Video model instance with this youtube id
#and other stuff
try:
video = Video.objects.get(pk=request.GET['vid'])
except Video.DoesNotExist:
raise Http404
video.url = request.GET['id']
video.save()
video.create_ready_instance()
section_structures = get_course_materials(common_page_data=common_page_data, get_video_content=True)
form = None
if request.common_page_data['course_mode'] == "draft":
form = LiveDateForm()
return render_to_response('videos/'+common_page_data['course_mode']+'/list.html', {'common_page_data': common_page_data, 'section_structures':section_structures, 'context':'video_list', 'form': form}, context_instance=RequestContext(request))
def list(request, course_prefix, course_suffix):
try:
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
except:
raise Http404
if 'id' in request.GET:
#process Video model instance with this youtube id
#and other stuff
try:
video = Video.objects.get(pk=request.GET['vid'])
except Video.DoesNotExist:
raise Http404
video.url = request.GET['id']
video.save()
video.create_ready_instance()
section_structures = get_course_materials(common_page_data=common_page_data, get_video_content=True)
form = None
if request.common_page_data['course_mode'] == "draft":
form = LiveDateForm()
return render_to_response('videos/'+common_page_data['course_mode']+'/list.html', {'common_page_data': common_page_data, 'section_structures':section_structures, 'context':'video_list', 'form': form}, context_instance=RequestContext(request))
def add_announcement(request):
try:
common_page_data = get_common_page_data(request, request.POST.get("course_prefix"), request.POST.get("course_suffix"))
except:
raise Http404
if not common_page_data['is_course_admin']:
return redirect('courses.views.main', request.POST.get("course_prefix"), request.POST.get("course_suffix"))
index = len(Announcement.objects.getByCourse(course=common_page_data['course']))
announcement = Announcement(
course=common_page_data['course'],
title=request.POST.get("title"),
description=request.POST.get("description"),
index=index,
mode='draft',
owner=request.user,
)
announcement.save()
announcement.create_ready_instance()
if request.POST.get("commit") == '1':
announcement.commit()
if request.POST.get("email"):
request.session['email_subject'] = announcement.title
request.session['email_message'] = announcement.description
messages.add_message(request, messages.SUCCESS, 'Your announcement is published! Now send it to the students.')
return redirect('courses.email_members.views.email_members', request.POST.get("course_prefix"), request.POST.get("course_suffix"))
return redirect(request.META['HTTP_REFERER'])
def preview_login(request, course_prefix, course_suffix):
"""
Login to c2g in preview mode
"""
login_form = AuthenticationForm(data=request.POST)
if login_form.is_valid():
auth_login(request, login_form.get_user())
if not request.common_page_data['course'].preview_only_mode and \
date.today() >= request.common_page_data['course'].calendar_start :
redirect_to = 'courses.views.main'
else:
redirect_to = 'courses.preview.views.preview'
return redirect(reverse(redirect_to, args=[course_prefix, course_suffix]))
else:
form = form_class(initial={'course_prefix':course_prefix,'course_suffix':course_suffix})
context = RequestContext(request)
class_template='previews/'+request.common_page_data['course'].handle+'.html'
if os.path.isfile(settings.TEMPLATE_DIRS+'/'+class_template):
return render_to_response(class_template,
{'form': form,
'login_form': login_form,
'common_page_data': request.common_page_data,
'display_login': True},
context_instance=context)
else:
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
page = AdditionalPage.objects.get(course=common_page_data['course'], slug="overview")
return render_to_response("previews/overview.html",
{'common_page_data': common_page_data,
'page': page,
'form': form,
'login_form': login_form,
'common_page_data': request.common_page_data,
'display_login': request.GET.__contains__('login'),
}, context_instance=context)
def add_video(request):
course_prefix = request.POST.get("course_prefix")
course_suffix = request.POST.get("course_suffix")
common_page_data = get_common_page_data(request, course_prefix,
course_suffix)
if not common_page_data['is_course_admin']:
return redirect('courses.views.view', course_prefix, course_suffix)
index = len(Video.objects.filter(topic_id=request.POST.get("topic_id")))
draft_video = Video(
course=common_page_data['draft_course'],
topic_id=int(request.POST.get("topic_id")),
title=request.POST.get("title"),
#description=request.POST.get("description"),
type='youtube',
url=request.POST.get("yt_id"),
slug=request.POST.get("slug"),
mode='draft',
index=index)
draft_video.save()
draft_video.create_ready_instance()
return redirect(request.META['HTTP_REFERER'])
def upload(request):
course_prefix = request.POST.get("course_prefix")
course_suffix = request.POST.get("course_suffix")
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
if request.method == "POST":
form = FileUploadForm(request.POST, request.FILES, course=common_page_data['course'])
if form.is_valid():
new_file = form.save(commit=False)
new_file.course = common_page_data['course']
new_file.index = new_file.section.getNextIndex()
new_file.mode = 'draft'
new_file.handle = course_prefix + "--" + course_suffix
new_file.save()
new_file.create_ready_instance()
create_contentgroup_entries_from_post(request, 'parent', new_file.image, 'file', request.POST.get('display_style','list'))
return redirect('courses.views.course_materials', course_prefix, course_suffix)
else:
form = FileUploadForm(course=common_page_data['course'])
reverseview = 'courses.files.actions.upload'
return render(request, 'files/upload.html',
{'reverseview':reverseview,
'common_page_data': common_page_data,
'form': form,
})
def view(request, course_prefix, course_suffix, slug):
try:
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
except:
raise Http404
video = None
video_rec = None
if request.user.is_authenticated():
#video = Video.objects.get(course=common_page_data['production_course'], slug=slug)
video = Video.objects.get(course=common_page_data['course'], slug=slug)
#video_rec = request.user.videoactivity_set.filter(video=video)
video_rec = request.user.videoactivity_set.filter(video=video)
if video_rec:
video_rec = video_rec[0]
else:
#if student, needs to be an easy way to check if member of group
user_groups = request.user.groups.all()
for group in user_groups:
if group == common_page_data['course'].student_group:
video_rec = VideoActivity(student=request.user, course=common_page_data['course'], video=video)
video_rec.save()
break
return render_to_response('videos/view.html', {'common_page_data': common_page_data, 'video': video, 'video_rec':video_rec}, context_instance=RequestContext(request))
def save_exercises(request):
#Function should only be accessed from submitting a form
if request.method != 'POST':
return redirect(request.META['HTTP_REFERER'])
course_prefix = request.POST['course_prefix']
course_suffix = request.POST['course_suffix']
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
#don't catch video DoesNotExist here because we want some tangible error action to happen if
#the video id changes in form submission, like mailing us
video = Video.objects.get(id=request.POST['video_id'])
action = request.POST['action']
if action == 'Reset to Ready':
video.revert()
return HttpResponseRedirect(reverse('courses.videos.views.manage_exercises', args=(request.POST['course_prefix'], request.POST['course_suffix'], video.slug,)))
else:
videoToExs = VideoToExercise.objects.getByVideo(video)
for videoToEx in videoToExs:
videoToEx.video_time = request.POST[videoToEx.exercise.fileName]
videoToEx.save()
if action == 'Save and Set as Ready':
video.commit()
return HttpResponseRedirect(reverse('courses.videos.views.list', args=(request.POST['course_prefix'], request.POST['course_suffix'],)))
def main(request, course_prefix, course_suffix, slug):
try:
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
page = AdditionalPage.objects.get(course=common_page_data['course'], slug=slug)
except:
raise Http404
if not common_page_data['is_course_admin']:
visit_log = PageVisitLog(
course = common_page_data['ready_course'],
user = request.user,
page_type = 'additional_page',
object_id = str(page.id),
)
visit_log.save()
contentgroup_info = None # Empty for view mode
if common_page_data['is_course_admin'] and common_page_data['course_mode'] == 'draft' and common_page_data['view_mode'] == 'edit':
template = 'additional_pages/edit.html'
grouppable_page = page.image
parent_info = grouppable_page.contentgroup_set.all()
if parent_info: # fill contentgroup_info for edit mode
parent_info = parent_info[0] # not necessarily true, but gets us the group_id
group_id = parent_info.group_id
parent_info = ContentGroup.objects.get(group_id=group_id, level=1) # this is the parent for real
parent_type = parent_info.get_content_type()
parent = getattr(parent_info, parent_type)
parent_id = parent.id
is_child = False
if parent_info.additional_page != grouppable_page.id:
is_child = True
child_list = ContentGroup.objects.filter(group_id=group_id, level=2)
contentgroup_info = {
'contentgroup_parent': parent_info,
'contentgroup_children': child_list,
'parent_type': parent_type,
'parent_id': parent_id,
'parent': parent,
'is_child': is_child,
}
else:
template = 'additional_pages/view.html'
course = common_page_data['course']
ready_section = page.section
if ready_section and ready_section.mode == "draft":
ready_section = ready_section.image
return render_to_response(template,
{
'common_page_data': common_page_data,
'page': page,
'ready_section': ready_section,
'contentgroup_info': contentgroup_info,
},
context_instance=RequestContext(request))
def save(request):
def redirectWithError(warn_msg):
url = request.get_full_path()
messages.add_message(request,messages.ERROR, warn_msg)
return redirect(request.META['HTTP_REFERER'])
common_page_data = get_common_page_data(request, request.POST.get("course_prefix"), request.POST.get("course_suffix"))
if not common_page_data['is_course_admin']:
return redirect('courses.views.main', common_page_data['course_prefix'],common_page_data['course_suffix'])
page = AdditionalPage.objects.get(id=request.POST.get("page_id"))
if request.POST.get("revert") == '1':
page.revert()
else:
#Validate manually, b/c we didn't use django forms here since we missed it
try:
validate_slug(request.POST.get("slug"))
except ValidationError:
return redirectWithError("The url descriptor cannot be empty and can only contain numbers, letters, underscores, and hyphens")
if (not page.slug==request.POST.get("slug")) and AdditionalPage.objects.filter(course=common_page_data['course'], slug=request.POST.get("slug")).exists():
return redirectWithError("A page with this URL identifier already exists")
if len(request.POST.get("title")) == 0:
return redirectWithError("The title cannot be empty")
if len(request.POST.get("title")) > AdditionalPage._meta.get_field("title").max_length:
return redirectWithError("The title length was too long")
new_section = request.POST.get("section")
old_section = page.section
if new_section == "null": # Topbar pages
page.section = None
page.menu_slug = "course_info" # normal pages
else:
page.section = ContentSection.objects.get(id=new_section)
page.menu_slug = None
page.title = request.POST.get("title")
page.description = request.POST.get("description")
page.slug = request.POST.get("slug")
page.save()
##Also save the production slug per Issue #685, basically slugs are not stageable.
page.image.slug = request.POST.get("slug")
page.image.save()
create_contentgroup_entries_from_post(request, 'parent', page.image, 'additional_page', display_style='list')
if request.POST.get("commit") == '1':
page.commit()
# This has to happen last of all
if old_section or new_section != "null":
ContentGroup.reassign_parent_child_sections('additional_page', page.image.id, new_section)
return redirect('courses.additional_pages.views.main', common_page_data['course_prefix'],common_page_data['course_suffix'], page.slug)
def save_announcement_order(request):
try:
common_page_data = get_common_page_data(request, request.POST.get("course_prefix"), request.POST.get("course_suffix"))
except:
raise Http404
if not common_page_data['is_course_admin']:
return redirect('courses.views.main', request.POST.get("course_prefix"), request.POST.get("course_suffix"))
def email_announcement(request):
try:
common_page_data = get_common_page_data(request, request.POST.get("course_prefix"), request.POST.get("course_suffix"))
except:
raise Http404
if not common_page_data['is_course_admin']:
return redirect('courses.views.main', course_prefix, course_suffix)
def edit(request):
course_prefix = request.POST.get("course_prefix")
course_suffix = request.POST.get("course_suffix")
file_id = request.POST.get("file_id", "-1")
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
try:
file = File.objects.get(id=int(file_id), course=common_page_data["draft_course"])
except File.DoesNotExist:
raise Http404
if request.method == "POST":
form = FileEditForm(request.POST, course=common_page_data["draft_course"], instance=file)
if form.is_valid():
form.save()
file.commit()
parent_type = request.POST.get("parent")
if parent_type and parent_type[:4] != "none":
parent_type, parent_id = parent_type.split(",")
else:
parent_type, parent_id = None, None
if parent_type:
parent_ref = ContentGroup.groupable_types[parent_type].objects.get(id=long(parent_id))
content_group_groupid = ContentGroup.add_parent(file.image.course, parent_type, parent_ref.image)
ContentGroup.add_child(
content_group_groupid, "file", file.image, display_style=request.POST.get("display_style", "list")
)
else: # file should have no parents, so delete its place in a contentgroup if it's a child
try:
cgobj = file.image.contentgroup_set.get()
if cgobj.level != 1:
cgobj.delete()
except ContentGroup.DoesNotExist: # nothing to do if the file is not in a contentgroup
pass
return redirect("courses.views.course_materials", course_prefix, course_suffix)
else:
form = FileEditForm(instance=file, course=common_page_data["course"])
reverseview = "courses.files.actions.edit"
cg_info = ContentGroup.groupinfo_by_id("file", file.image.id)
parent = cg_info.get("__parent", None)
if not parent:
parent_val = "none,none"
else:
parent_val = "%s,%d" % (cg_info["__parent_tag"], parent.image.id)
return render(
request,
"files/upload.html",
{
"file": file,
"parent_val": parent_val,
"reverseview": reverseview,
"common_page_data": common_page_data,
"form": form,
},
)
def save(request):
def redirectWithError(warn_msg):
url = request.get_full_path()
messages.add_message(request, messages.ERROR, warn_msg)
return redirect(request.META['HTTP_REFERER'])
common_page_data = get_common_page_data(request,
request.POST.get("course_prefix"),
request.POST.get("course_suffix"))
if not common_page_data['is_course_admin']:
return redirect('courses.views.main',
common_page_data['course_prefix'],
common_page_data['course_suffix'])
page = AdditionalPage.objects.get(id=request.POST.get("page_id"))
if request.POST.get("revert") == '1':
page.revert()
else:
#Validate manually, b/c we didn't use django forms here since we missed it
try:
validate_slug(request.POST.get("slug"))
except ValidationError:
return redirectWithError(
"The url descriptor cannot be empty and can only contain numbers, letters, underscores, and hyphens"
)
if (not page.slug
== request.POST.get("slug")) and AdditionalPage.objects.filter(
course=common_page_data['course'],
slug=request.POST.get("slug")).exists():
return redirectWithError(
"A page with this URL identifier already exists")
if len(request.POST.get("title")) == 0:
return redirectWithError("The title cannot be empty")
if len(request.POST.get("title")) > AdditionalPage._meta.get_field(
"title").max_length:
return redirectWithError("The title length was too long")
page.title = request.POST.get("title")
page.description = request.POST.get("description")
page.slug = request.POST.get("slug")
page.save()
##Also save the production slug per Issue #685, basically slugs are not stageable.
page.image.slug = request.POST.get("slug")
page.image.save()
if request.POST.get("commit") == '1':
page.commit()
return redirect('courses.additional_pages.views.main',
common_page_data['course_prefix'],
common_page_data['course_suffix'], page.slug)
def admin(request, course_prefix, course_suffix):
try:
common_page_data = get_common_page_data(request, course_prefix,
course_suffix)
except:
raise Http404
return render_to_response('courses/admin.html',
{'common_page_data': common_page_data},
context_instance=RequestContext(request))
def manage_nav_menu(request, course_prefix, course_suffix):
try:
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
except:
raise Http404
if not common_page_data['is_course_admin']:
return redirect('courses.views.main', course_prefix, course_suffix)
return render_to_response('additional_pages/manage_nav_menu.html', {'common_page_data':common_page_data, 'mode':'nav_menu'}, context_instance=RequestContext(request))
def manage_nav_menu(request, course_prefix, course_suffix):
try:
common_page_data = get_common_page_data(request,
course_prefix,
course_suffix,
use_cache=False)
except e, msg:
# Remark to console exception characterization so we can make this clause more specific
print "Error in manage_nav_menu getting common_page_data, exception caught: %s" % msg
raise Http404
def add_section_page(request, course_prefix, course_suffix):
try:
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
except:
raise Http404
if not common_page_data['is_course_admin']:
return redirect('courses.views.main', course_prefix, course_suffix)
sections = ContentSection.objects.getByCourse(course=common_page_data['course'])
return render_to_response('additional_pages/add_section_page.html', {'common_page_data':common_page_data, 'mode':'section', 'sections':sections}, context_instance=RequestContext(request))
def upload(request):
course_prefix = request.POST.get("course_prefix")
course_suffix = request.POST.get("course_suffix")
common_page_data = get_common_page_data(request, course_prefix,
course_suffix)
data = {'common_page_data': common_page_data}
if request.method == 'POST':
request.session['video_privacy'] = request.POST.get("video_privacy")
# Need partial instance with course for form slug validation
new_video = Video(course=common_page_data['course'])
form = S3UploadForm(request.POST,
request.FILES,
course=common_page_data['course'],
instance=new_video)
if form.is_valid():
new_video.index = new_video.section.getNextIndex()
new_video.mode = 'draft'
new_video.handle = course_prefix + "--" + course_suffix
# Bit of jiggery pokery to so that the id is set when the upload_path function is called.
# Now storing file with id appended to the file path so that thumbnail and associated manifest files
# are easily associated with the video by putting them all in the same directory.
new_video.file = None
new_video.save()
new_video.file = form.cleaned_data['file']
new_video.save()
new_video.create_ready_instance()
#print new_video.file.url
# kick off remote jobs
kelvinator.tasks.kelvinate.delay(new_video.file.name)
kelvinator.tasks.resize.delay(new_video.file.name, "large")
kelvinator.tasks.resize.delay(new_video.file.name, "small")
if new_video.url:
return redirect('courses.videos.views.list', course_prefix,
course_suffix)
authUrl = GetOAuth2Url(request, new_video)
#eventually should store an access token, so they don't have to give permission everytime
return redirect(authUrl)
# return redirect("http://" + request.META['HTTP_HOST'])
else:
form = S3UploadForm(course=common_page_data['course'])
data['form'] = form
return render_to_response('videos/s3upload.html',
data,
context_instance=RequestContext(request))
def rename(request, course_prefix, course_suffix, section_id):
try:
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
except:
raise Http404
if not common_page_data['is_course_admin']:
return redirect('courses.views.main', course_prefix, course_suffix)
section = ContentSection.objects.get(id=section_id)
return render_to_response('content_sections/draft/rename.html', {'common_page_data': common_page_data, 'section':section}, context_instance=RequestContext(request))
def upload(request):
course_prefix = request.POST.get("course_prefix")
course_suffix = request.POST.get("course_suffix")
common_page_data = get_common_page_data(request, course_prefix,
course_suffix)
data = {'common_page_data': common_page_data}
if request.method == 'POST':
# Need partial instance with course for form slug validation
new_video = Video(course=common_page_data['course'])
form = S3UploadForm(request.POST,
request.FILES,
course=common_page_data['course'],
instance=new_video)
if form.is_valid():
new_video.index = new_video.section.getNextIndex()
new_video.mode = 'draft'
new_video.handle = course_prefix + "--" + course_suffix
# Bit of jiggery pokery to so that the id is set when the upload_path function is called.
# Now storing file with id appended to the file path so that thumbnail and associated manifest files
# are easily associated with the video by putting them all in the same directory.
new_video.file = None
new_video.save()
new_video.file = form.cleaned_data['file']
new_video.save()
new_video.create_ready_instance()
print new_video.file.url
# TODO: don't hardcode the AWS location
s3_path = "https://s3-us-west-2.amazonaws.com/" + common_page_data[
'aws_storage_bucket_name'] + "/" + urllib.quote_plus(
new_video.file.name, "/")
# TODO: make these parameters settable
kelvinator.tasks.run.delay(s3_path, "1", "1000")
if new_video.url:
return redirect('courses.videos.views.list', course_prefix,
course_suffix)
authUrl = GetOAuth2Url(request, new_video)
#eventually should store an access token, so they don't have to give permission everytime
return redirect(authUrl)
# return redirect("http://" + request.META['HTTP_HOST'])
else:
form = S3UploadForm(course=common_page_data['course'])
data['form'] = form
return render_to_response('videos/s3upload.html',
data,
context_instance=RequestContext(request))
def upload(request, course_prefix, course_suffix):
try:
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
except:
raise Http404
form = FileUploadForm(course=common_page_data['course'])
return render(request, 'files/upload.html',
{'common_page_data': common_page_data,
'form': form,
})
def add(request):
def redirectWithError(warn_msg):
url = request.get_full_path()
messages.add_message(request,messages.ERROR, warn_msg)
return redirect(request.META['HTTP_REFERER'])
course_prefix = request.POST.get("course_prefix")
course_suffix = request.POST.get("course_suffix")
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
if not common_page_data['is_course_admin']:
return redirect('courses.views.view', course_prefix, course_suffix)
menu_slug = None
if request.POST.get("menu_slug") != "":
menu_slug = request.POST.get("menu_slug")
section = None
if request.POST.get("section_id") != "":
section = ContentSection.objects.get(id=request.POST.get("section_id"))
if request.POST.get("menu_slug") != "":
index = len(AdditionalPage.objects.filter(course=common_page_data['course'],menu_slug=request.POST.get("menu_slug")))
else:
index = section.getNextIndex()
#Validate manually, b/c we didn't use django forms here since we missed it
try:
validate_slug(request.POST.get("slug"))
except ValidationError:
return redirectWithError("The url descriptor cannot be empty and can only contain numbers, letters, underscores, and hyphens")
if AdditionalPage.objects.filter(course=common_page_data['course'], slug=request.POST.get("slug")).exists():
return redirectWithError("A page with this URL identifier already exists")
if len(request.POST.get("title")) == 0:
return redirectWithError("The title cannot be empty")
if len(request.POST.get("title")) > AdditionalPage._meta.get_field("title").max_length:
return redirectWithError("The title length was too long")
draft_page = AdditionalPage(course=common_page_data['draft_course'], menu_slug=menu_slug, section=section, title=request.POST.get("title"), slug=request.POST.get("slug"), index=index, mode='draft')
draft_page.save()
draft_page.create_ready_instance()
if request.POST.get("menu_slug") == "":
return redirect('courses.views.course_materials', course_prefix, course_suffix)
else:
return redirect(request.META['HTTP_REFERER'])
def load_problem_set(request, course_prefix, course_suffix, pset_slug):
try:
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
except:
raise Http404
pset = ProblemSet.objects.get(course=common_page_data['course'], slug=pset_slug)
psetToExs = ProblemSetToExercise.objects.getByProblemset(pset).select_related('exercise', 'problemSet')
file_names = []
for psetToEx in psetToExs:
#Remove the .html from the end of the file name
file_names.append(psetToEx.exercise.fileName[:-5])
return render_to_response('problemsets/load_problem_set.html',{'file_names': file_names, 'assessment_type': pset.assessment_type},context_instance=RequestContext(request))
def request_and_search(self, viewname):
# import pdb; pdb.set_trace();
request = self.factory.get(self.course_url)
# TODO - not working
request.user = self.client.login(username="******", password="******")
request.common_page_data=get_common_page_data(request,
self.course_prefix, self.course_suffix)
request.session = {}
response = viewname(request, self.course_prefix, self.course_suffix)
self.assertRegexpMatches(response.content,
self.course_title_search_string,
msg="Couldn't find course name in from view '%s'" % viewname.__name__)
def delete_exam(request):
try:
common_page_data = get_common_page_data(
request, request.POST.get("course_prefix"),
request.POST.get("course_suffix"))
except:
raise Http404
exam = Exam.objects.get(id=request.POST.get("exam_id"))
exam.delete()
exam.image.delete()
return redirect(request.META['HTTP_REFERER'])
def main(request, course_prefix, course_suffix, slug):
try:
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
page = AdditionalPage.objects.get(course=common_page_data['course'], slug=slug)
except:
raise Http404
if common_page_data['is_course_admin'] and common_page_data['course_mode'] == 'draft' and common_page_data['view_mode'] == 'edit':
template = 'additional_pages/edit.html'
else:
template = 'additional_pages/view.html'
return render_to_response(template,{'common_page_data': common_page_data, 'page':page},context_instance=RequestContext(request))
def edit_form(request, course_prefix, course_suffix, pset_slug):
try:
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
except:
raise Http404
pset = ProblemSet.objects.get(course=common_page_data['course'], slug=pset_slug)
data = {'common_page_data': common_page_data}
form = CreateProblemSet(course=common_page_data['course'], instance=pset)
data['form'] = form
data['pset'] = pset
data['course_prefix'] = course_prefix
data['course_suffix'] = course_suffix
return render_to_response('problemsets/edit.html', data, context_instance=RequestContext(request))
def delete_file(request):
try:
common_page_data = get_common_page_data(
request, request.POST.get("course_prefix"),
request.POST.get("course_suffix"))
except:
raise Http404
file = File.objects.get(id=request.POST.get("file_id"))
file.delete()
file.image.delete()
return redirect(request.META['HTTP_REFERER'])
def upload(request, course_prefix, course_suffix):
try:
common_page_data = get_common_page_data(request, course_prefix, course_suffix)
except:
raise Http404
data = {'common_page_data': common_page_data}
form = S3UploadForm(course=common_page_data['course'])
data['form'] = form
return render_to_response('videos/s3upload.html',
data,
context_instance=RequestContext(request))
