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