def sandboxed_content(request, content_slug, **kwargs):
try:
content = ContentPage.objects.get(slug=content_slug)
except ContentPage.DoesNotExist:
return HttpResponseNotFound(
"Content {} does not exist!".format(content_slug))
user = request.user
if not user.is_authenticated or not user.is_active or not user.is_staff:
return HttpResponseForbidden(
"Only logged in admins can view pages in sandbox!")
content_type = content.content_type
question = blockparser.parseblock(escape(content.question))
choices = answers = content.get_choices(content)
rendered_content = content.rendered_markup(request)
c = {
'content': content,
'content_name': content.name,
'content_type': content_type,
'rendered_content': rendered_content,
'embedded': False,
'question': question,
'choices': choices,
'user': user,
'sandboxed': True,
}
if "frontpage" in kwargs:
return c
else:
t = loader.get_template("courses/contentpage.html")
return HttpResponse(t.render(c, request))
def block(cls, block, settings, state):
yield '<div class="paragraph">'
paragraph = ""
paragraph_lines = []
for line in block:
paragraph_lines.append(escape(line))
paragraph = "<br>\n".join(paragraph_lines)
paragraph = blockparser.parseblock(paragraph, state["context"])
yield paragraph
yield '</div>\n'
def block(cls, block, settings, state):
if not state["table"]:
yield '<table>'
state["table"] = True
for line in block:
row = line.split("||")[1:-1]
yield '<tr>'
yield '\n'.join(
"<td>%s</td>" %
blockparser.parseblock(escape(cell), state["context"])
for cell in row)
yield '</tr>'
def settings(cls, matchobj, state):
settings = {"image_name": escape(matchobj.group("image_name"))}
try:
settings["alt_text"] = escape(matchobj.group("alt_text"))
except AttributeError:
pass
try:
settings["caption_text"] = blockparser.parseblock(
escape(matchobj.group("caption_text")), state["context"])
except AttributeError:
pass
try:
settings["align"] = escape(matchobj.group("align"))
except AttributeError:
pass
return settings
def block(cls, block, settings, state):
tag = settings["tag"]
if len(state["list"]) < settings["level"]:
for new_lvl in range(settings["level"] - len(state["list"])):
state["list"].append(tag)
yield '<%s>' % tag
elif len(state["list"]) > settings["level"]:
for new_lvl in range(len(state["list"]) - settings["level"]):
top_tag = state["list"].pop()
yield '</%s>' % top_tag
if len(state["list"]) == settings["level"]:
if state["list"][-1] != tag:
top_tag = state["list"].pop()
yield '</%s>' % top_tag
state["list"].append(tag)
yield '<%s>' % tag
for line in block:
yield '<li>%s</li>' % blockparser.parseblock(
escape(line.strip("*#").strip()), state["context"])
def content(request, course, instance, content, **kwargs):
content_graph = None
revision = None
#if "frontpage" not in kwargs:
try:
content_graph = ContentGraph.objects.get(instance=instance,
content=content)
except ContentGraph.DoesNotExist:
return HttpResponseNotFound(
"Content {} is not linked to course {}!".format(
content.slug, course.slug))
else:
if content_graph is None:
return HttpResponseNotFound(
"Content {} is not linked to course {}!".format(
content.slug, course.slug))
evaluation = None
answer_count = None
enrolled = False
course_staff = False
if request.user.is_authenticated:
if request.user.is_active and content.is_answerable(
) and content.get_user_answers(content, request.user, instance):
answer_count = content.get_user_answers(content, request.user,
instance).count()
if content_graph and (
content_graph.publish_date is None
or content_graph.publish_date < datetime.datetime.now()):
try:
evaluation = content.get_user_evaluation(
content, request.user, instance)
except NotImplementedError:
evaluation = None
try:
if CourseEnrollment.objects.get(
instance=instance, student=request.user).is_enrolled():
enrolled = True
except CourseEnrollment.DoesNotExist:
pass
if is_course_staff(request.user, instance):
course_staff = True
revision = content_graph.revision
content_type = content.content_type
context = {
'course': course,
'course_slug': course.slug,
'instance': instance,
'instance_slug': instance.slug,
'content_page': content,
'enrolled': enrolled,
'course_staff': course_staff
}
termbank_contents = cache.get('termbank_contents_{instance}_{lang}'.format(
instance=context['instance_slug'], lang=translation.get_language()))
term_div_data = cache.get('term_div_data_{instance}_{lang}'.format(
instance=context['instance_slug'], lang=translation.get_language()))
if termbank_contents is None or term_div_data is None:
term_context = context.copy()
term_context['tooltip'] = True
term_links = TermToInstanceLink.objects.filter(
instance__slug=context["instance_slug"])
term_div_data = []
termbank_contents = {}
#terms = Term.objects.filter(course=course).exclude(Q(description__isnull=True) | Q(description__exact='')).order_by('name')
terms = []
for link in term_links:
if link.revision is None:
term = link.term
else:
term = Version.objects.get_for_object(link.term).get(
revision=link.revision)._object_version.object
if term.description:
terms.append(term)
def sort_by_name(item):
return item.name
terms.sort(key=sort_by_name)
for term in terms:
slug = slugify(term.name, allow_unicode=True)
description = "".join(
markupparser.MarkupParser.parse(term.description, request,
term_context)).strip()
tabs = [(tab.title, "".join(
markupparser.MarkupParser.parse(tab.description, request,
term_context)).strip())
for tab in term.termtab_set.all().order_by('id')]
tags = term.tags
final_links = []
for link in term.termlink_set.all():
try:
server_side, client_side = link.url.split('#', 1)
except ValueError:
server_side = link.url
client_side = None
try:
target_content = ContentPage.objects.get(slug=server_side)
except ContentPage.DoesNotExist:
final_address = link.url
else:
final_address = reverse('courses:content',
args=[
context['course'],
context['instance'],
target_content
])
if client_side is not None:
final_address = final_address.rstrip(
'/') + '#' + client_side
final_links.append({
"url": final_address,
"text": link.link_text
})
term_div_data.append({
'slug': slug,
'description': description,
'tabs': tabs,
'links': final_links,
})
term_data = {
'slug': slug,
'name': term.name,
'tags': tags,
'alias': False,
}
def get_term_initial(term):
try:
first_char = term.upper()[0]
except IndexError:
first_char = "#"
else:
if not first_char.isalpha():
first_char = "#"
return first_char
first_char = get_term_initial(term.name)
if first_char in termbank_contents:
termbank_contents[first_char].append(term_data)
else:
termbank_contents[first_char] = [term_data]
for alias in term.aliases:
alias_data = {
'slug': slug,
'name': term.name,
'alias': alias,
}
first_char = get_term_initial(alias)
if first_char in termbank_contents:
termbank_contents[first_char].append(alias_data)
else:
termbank_contents[first_char] = [alias_data]
cache.set('termbank_contents_{instance}_{lang}'.format(
instance=context['instance_slug'],
lang=translation.get_language()),
termbank_contents,
timeout=None)
cache.set('term_div_data_{instance}_{lang}'.format(
instance=context['instance_slug'],
lang=translation.get_language()),
term_div_data,
timeout=None)
rendered_content = ""
# TODO: Admin link should point to the correct version!
# TODO: Warn admins if the displayed version is not the current version!
# Get the other things based on the rev. if set
if revision is not None:
# This seems unoptimal. Maybe create a patch to django-reversions?
# reversion.get_revision_for_object or sth. would be nice...
#version_list = reversion.get_for_object(content).order_by('revision_id')
# TODO: New form? Version.objects.get_for_object(term)[0].revision.
version = Version.objects.get_for_object(content).get(
revision_id=revision).field_dict
old_content = version["content"]
question = version["question"]
# Render the old version of the page
markup_gen = markupparser.MarkupParser.parse(old_content, request,
context)
for chunk in markup_gen:
rendered_content += chunk
else:
question = blockparser.parseblock(escape(content.question),
{"course": course})
choices = answers = content.get_choices(content, revision=revision)
if not rendered_content:
rendered_content = content.rendered_markup(request, context)
c = {
'course': course,
'course_slug': course.slug,
'course_name': course.name,
"instance": instance,
'instance_name': instance.name,
'instance_slug': instance.slug,
'content': content,
'rendered_content': rendered_content,
'embedded': False,
'content_name': content.name,
'content_type': content_type,
'question': question,
'choices': choices,
'evaluation': evaluation,
'answer_count': answer_count,
'sandboxed': False,
'termbank_contents': sorted(list(termbank_contents.items())),
'term_div_data': term_div_data,
'revision': revision,
'enrolled': enrolled,
'course_staff': course_staff
}
if "frontpage" in kwargs:
return c
else:
t = loader.get_template("courses/contentpage.html")
return HttpResponse(t.render(c, request))
def settings(cls, matchobj, state):
settings = {"page_slug": matchobj.group("page_slug")}
revision = None
instance = state["context"]["instance"]
try:
revision = int(matchobj.group("revision"))
except AttributeError:
pass
except TypeError:
pass #raise something about invalid revision? dunno
try:
try:
link = courses.models.EmbeddedLink.objects.get(
embedded_page__slug=settings["page_slug"],
instance=instance,
parent=state["context"]["content_page"])
except courses.models.EmbeddedLink.DoesNotExist as e:
# link does not exist yet, get by page slug instead
page = courses.models.ContentPage.objects.get(
slug=settings["page_slug"])
else:
page = link.embedded_page
revision = link.revision
#revision = link.revision
#page = courses.models.ContentPage.objects\
#.get(slug=settings["page_slug"])
except courses.models.ContentPage.DoesNotExist as e:
raise EmbeddedObjectNotFoundError(
"embedded page '%s' couldn't be found" % settings["page_slug"])
else:
if revision is not None:
try:
page = Version.objects.get_for_object(page).get(revision=revision)\
._object_version.object
except Version.DoesNotExist as e:
raise EmbeddedObjectNotFoundError(
"revision '%d' of embedded page '%s' couldn't be found"
% (revision, settings["page_slug"]))
state["embedded_pages"].append((settings["page_slug"], revision))
# TODO: Prevent recursion depth > 2
#embedded_content = page.rendered_markup()
embedded_content = ""
markup_gen = MarkupParser.parse(page.content, state["request"],
state["context"])
for chunk in markup_gen:
embedded_content += chunk
choices = page.get_choices(page, revision=revision)
question = blockparser.parseblock(escape(page.question),
state["context"])
c = {
"emb_content": embedded_content,
"embedded": True,
"content": page,
"content_slug": page.slug,
"question": question,
"choices": choices,
"revision": revision,
}
try:
user = state["request"].user
except AttributeError:
c["sandboxed"] = False
c["evaluation"] = "unanswered"
c["answer_count"] = 0
else:
sandboxed = state["request"].path.startswith("/sandbox/")
if sandboxed and user.is_authenticated and user.is_active and user.is_staff:
c["sandboxed"] = True
elif sandboxed and (not user.is_authenticated or
not user.is_active or not user.is_staff):
settings["rendered_content"] = ""
return settings
else:
c["sandboxed"] = False
if user.is_active and page.is_answerable() and not sandboxed:
c["evaluation"] = page.get_user_evaluation(
page, user, instance)
c["answer_count"] = page.get_user_answers(
page, user, instance).count()
else:
c["evaluation"] = "unanswered"
c["answer_count"] = 0
c.update(state["context"])
t = loader.get_template("courses/{page_type}.html".format(
page_type=page.get_dashed_type()))
rendered_content = t.render(c, state["request"])
settings["rendered_content"] = rendered_content or embedded_content
return settings