Example #1
0
def page(request, slug, template="pages/page.html"):
    """
    Display content for a page. First check for any matching page processors
    and handle them. Secondly, build the list of template names to choose
    from given the slug and type of page being viewed.
    """
    page = get_object_or_404(Page.objects.published(request.user), slug=slug)
    if page.login_required and not request.user.is_authenticated():
        return redirect("%s?%s=%s" % (settings.LOGIN_URL, REDIRECT_FIELD_NAME, 
            urlquote(request.get_full_path())))
    context = {"page": page}
    for processor in page_processors.processors[page.content_model]:
        response = processor(request, page)
        if isinstance(response, HttpResponse):
            return response
        elif response:
            if isinstance(response, dict):
                context.update(response)
            else:
                raise ValueError("The page processor %s.%s returned %s but "
                    "must return HttpResponse or dict." % (
                    processor.__module__, processor.__name__, type(response)))
    templates = ["pages/%s.html" % slug]
    if page.content_model is not None:
        templates.append("pages/%s.html" % page.content_model)
    templates.append(template)
    request_context = RequestContext(request, context)
    t = select_template(templates, request_context)
    return HttpResponse(t.render(request_context))
Example #2
0
def page(request, slug, template="pages/page.html"):
    """
    Display content for a page. First check for any matching page processors
    and handle them. Secondly, build the list of template names to choose
    from given the slug and type of page being viewed.
    """
    page = get_object_or_404(Page.objects.published(request.user), slug=slug)
    if page.login_required and not request.user.is_authenticated():
        return redirect("%s?%s=%s" % (settings.LOGIN_URL, REDIRECT_FIELD_NAME,
            urlquote(request.get_full_path())))
    context = {"page": page}
    for processor in page_processors.processors[page.content_model]:
        response = processor(request, page)
        if isinstance(response, HttpResponse):
            return response
        elif response:
            if isinstance(response, dict):
                context.update(response)
            else:
                raise ValueError("The page processor %s.%s returned %s but "
                    "must return HttpResponse or dict." % (
                    processor.__module__, processor.__name__, type(response)))
    templates = ["pages/%s.html" % slug]
    if page.content_model is not None:
        templates.append("pages/%s.html" % page.content_model)
    templates.append(template)
    request_context = RequestContext(request, context)
    t = select_template(templates, request_context)
    return HttpResponse(t.render(request_context))
Example #3
0
def page(request, slug, template="pages/page.html", extra_context=None):
    """
    Display content for a page. First check for any matching page processors
    and handle them. Secondly, build the list of template names to choose
    from given the slug and type of page being viewed.
    """
    page = get_object_or_404(Page.objects.published(request.user), slug=slug)
    if page.login_required and not request.user.is_authenticated():
        path = urlquote(request.get_full_path())
        url = "%s?%s=%s" % (settings.LOGIN_URL, REDIRECT_FIELD_NAME, path)
        return redirect(url)
    context = {"page": page}
    if extra_context is not None:
        context.update(extra_context)
    model_processors = page_processors.processors[page.content_model]
    slug_processors = page_processors.processors["slug:%s" % page.slug]
    for processor in model_processors + slug_processors:
        response = processor(request, page)
        if isinstance(response, HttpResponse):
            return response
        elif response:
            try:
                context.update(response)
            except (TypeError, ValueError):
                name = "%s.%s" % (processor.__module__, processor.__name__)
                error = ("The page processor %s returned %s but must return "
                         "HttpResponse or dict." % (name, type(response)))
                raise ValueError(error)
    templates = [u"pages/%s.html" % slug]
    if page.content_model is not None:
        templates.append(u"pages/%s.html" % page.content_model)
    templates.append(template)
    request_context = RequestContext(request, context)
    t = select_template(templates, request_context)
    return HttpResponse(t.render(request_context))
Example #4
0
def page(request, slug, template="pages/page.html", extra_context=None):
    """
    Display content for a page. First check for any matching page processors
    and handle them. Secondly, build the list of template names to choose
    from given the slug and type of page being viewed.
    """
    page = get_object_or_404(Page.objects.published(request.user), slug=slug)
    if page.login_required and not request.user.is_authenticated():
        path = urlquote(request.get_full_path())
        url = "%s?%s=%s" % (settings.LOGIN_URL, REDIRECT_FIELD_NAME, path)
        return redirect(url)
    context = {"page": page}
    if extra_context is not None:
        context.update(extra_context)
    model_processors = page_processors.processors[page.content_model]
    slug_processors = page_processors.processors["slug:%s" % page.slug]
    for processor in model_processors + slug_processors:
        response = processor(request, page)
        if isinstance(response, HttpResponse):
            return response
        elif response:
            try:
                context.update(response)
            except (TypeError, ValueError):
                name = "%s.%s" % (processor.__module__, processor.__name__)
                error = ("The page processor %s returned %s but must return "
                         "HttpResponse or dict." % (name, type(response)))
                raise ValueError(error)
    templates = [u"pages/%s.html" % slug]
    if page.content_model is not None:
        templates.append(u"pages/%s.html" % page.content_model)
    templates.append(template)
    request_context = RequestContext(request, context)
    t = select_template(templates, request_context)
    return HttpResponse(t.render(request_context))
Example #5
0
def blog_post_list(request, tag=None, year=None, month=None, username=None,
                   category=None, template="blog/blog_post_list.html"):
    """
    Display a list of blog posts that are filtered by tag, year, month,
    author or category. Custom templates are checked for using the name
    ``blog/blog_post_list_XXX.html`` where ``XXX`` is either the
    category slug or author's username if given.
    """
    settings.use_editable()
    templates = []
    blog_posts = BlogPost.objects.published(for_user=request.user)
    if tag is not None:
        tag = get_object_or_404(Keyword, slug=tag)
        blog_posts = blog_posts.filter(keywords__in=tag.assignments.all())
    if year is not None:
        blog_posts = blog_posts.filter(publish_date__year=year)
        if month is not None:
            blog_posts = blog_posts.filter(publish_date__month=month)
            month = month_name[int(month)]
    if category is not None:
        category = get_object_or_404(BlogCategory, slug=category)
        blog_posts = blog_posts.filter(categories=category)
        templates.append("blog/blog_post_list_%s.html" % category.slug)
    author = None
    if username is not None:
        author = get_object_or_404(User, username=username)
        blog_posts = blog_posts.filter(user=author)
        templates.append("blog/blog_post_list_%s.html" % username)
    # Create dicts mapping blog post IDs to lists of categories and
    # keywords, and assign these to each blog post, to avoid querying
    # the database inside the template loop for posts.
    blog_posts = list(blog_posts.select_related("user"))
    categories = defaultdict(list)
    for cat in BlogCategory.objects.raw(
        "SELECT * FROM blog_blogcategory "
        "JOIN blog_blogpost_categories "
        "ON blog_blogcategory.id = blog_blogpost_categories.blogcategory_id "
        "WHERE blogpost_id IN (%s)" % ",".join([str(p.id) for p in blog_posts])):
        categories[cat.blogpost_id].append(cat)
    keywords = defaultdict(list)
    blogpost_type = ContentType.objects.get(app_label="blog", model="blogpost")
    assigned = AssignedKeyword.objects.filter(blogpost__in=blog_posts,
                          content_type=blogpost_type).select_related("keyword")
    for a in assigned:
        keywords[a.object_pk].append(a.keyword)
    for i, post in enumerate(blog_posts):
        setattr(blog_posts[i], "category_list", categories[post.id])
        setattr(blog_posts[i], "keyword_list", keywords[post.id])
    blog_posts = paginate(blog_posts,
                          request.GET.get("page", 1),
                          settings.BLOG_POST_PER_PAGE,
                          settings.BLOG_POST_MAX_PAGING_LINKS)
    context = {"blog_page": blog_page(), "blog_posts": blog_posts,
               "year": year, "month": month, "tag": tag,
               "category": category, "author": author}
    templates.append(template)
    request_context = RequestContext(request, context)
    t = select_template(templates, request_context)
    return HttpResponse(t.render(request_context))
Example #6
0
def news_post_detail(request, slug, template="news/news_post_detail.html"):
    """
    Display a news post.
    """
    news_posts = NewsPost.objects.published(for_user=request.user)
    news_post = get_object_or_404(news_posts, slug=slug)
    settings.use_editable()
    context = {"news_post": news_post, "news_page": news_page(),}
    request_context = RequestContext(request, context)
    t = select_template(["news/%s.html" % slug, template], request_context)
    return HttpResponse(t.render(request_context))
Example #7
0
def podcast_detail(request, slug, template="podcast/podcast_detail.html"):
    """
    Display a particular podcast and handle comment submission. Custom
    templates are checked for using the name
    ``podcast_detail_XXX.html`` where ``XXX`` is the podcast's slug.
    """
    podcasts = Podcast.objects.published(for_user=request.user)
    pc = get_object_or_404(podcasts, slug=slug)
    context = {"podcast": pc}
    templates = [u"podcast/podcast_detail_%s.html" % slug, template]
    request_context = RequestContext(request, context)
    t = select_template(templates, request_context)
    return HttpResponse(t.render(request_context))
Example #8
0
def podcast_detail(request, slug, template="podcast/podcast_detail.html"):
    """
    Display a particular podcast and handle comment submission. Custom
    templates are checked for using the name
    ``podcast_detail_XXX.html`` where ``XXX`` is the podcast's slug.
    """
    podcasts = Podcast.objects.published(for_user=request.user)
    pc = get_object_or_404(podcasts, slug=slug)
    context = {"podcast": pc}
    templates = [u"podcast/podcast_detail_%s.html" % slug, template]
    request_context = RequestContext(request, context)
    t = select_template(templates, request_context)
    return HttpResponse(t.render(request_context))
Example #9
0
def podcast_list(
    request, tag=None, year=None, month=None, username=None, category=None, template="podcast/podcast_list.html"
):
    """
    Provide a listing of podcasts
    """
    templates = []
    podcasts = Podcast.objects.published()
    context = {"page": podcast_page(), "podcasts": podcasts}
    templates.append(template)
    request_context = RequestContext(request, context)
    t = select_template(templates, request_context)
    return HttpResponse(t.render(request_context))
Example #10
0
def blog_post_list(request,
                   tag=None,
                   year=None,
                   month=None,
                   username=None,
                   category=None,
                   template="blog/blog_post_list.html"):
    """
    Display a list of blog posts that are filtered by tag, year, month, 
    author or category. Custom templates are checked for using the name
    ``blog/blog_post_list_XXX.html`` where ``XXX`` is either the 
    category slug or author's username if given.
    """
    settings.use_editable()
    templates = []
    blog_posts = BlogPost.objects.published(for_user=request.user)
    if tag is not None:
        tag = get_object_or_404(Keyword, slug=tag)
        blog_posts = blog_posts.filter(keywords=tag)
    if year is not None:
        blog_posts = blog_posts.filter(publish_date__year=year)
        if month is not None:
            blog_posts = blog_posts.filter(publish_date__month=month)
            month = month_name[int(month)]
    if category is not None:
        category = get_object_or_404(BlogCategory, slug=category)
        blog_posts = blog_posts.filter(categories=category)
        templates.append("blog/blog_post_list_%s.html" % category.slug)
    author = None
    if username is not None:
        author = get_object_or_404(User, username=username)
        blog_posts = blog_posts.filter(user=author)
        templates.append("blog/blog_post_list_%s.html" % username)
    blog_posts = paginate(blog_posts, request.GET.get("page", 1),
                          settings.BLOG_POST_PER_PAGE,
                          settings.BLOG_POST_MAX_PAGING_LINKS)
    context = {
        "blog_page": blog_page(),
        "blog_posts": blog_posts,
        "year": year,
        "month": month,
        "tag": tag,
        "category": category,
        "author": author
    }
    templates.append(template)
    request_context = RequestContext(request, context)
    t = select_template(templates, request_context)
    return HttpResponse(t.render(request_context))
Example #11
0
 def render(self, context):
     if not getattr(self, "nodelist", False):
         if not isinstance(file_name, basestring) and \
             is_iterable(file_name):
             t = select_template(file_name, context)
         else:
             t = get_template(file_name, context)
         self.nodelist = t.nodelist
     parts = [template.Variable(part).resolve(context) 
              for part in token.split_contents()[1:]]
     if takes_context:
         parts.insert(0, context)
     result = tag_func(*parts)
     autoescape = context.autoescape
     context = context_class(result, autoescape=autoescape)
     return self.nodelist.render(context)
Example #12
0
 def render(self, context):
     if not getattr(self, "nodelist", False):
         if not isinstance(file_name, basestring) and \
             is_iterable(file_name):
             t = select_template(file_name, context)
         else:
             t = get_template(file_name, context)
         self.nodelist = t.nodelist
     parts = [template.Variable(part).resolve(context) 
              for part in token.split_contents()[1:]]
     if takes_context:
         parts.insert(0, context)
     result = tag_func(*parts)
     autoescape = context.autoescape
     context = context_class(result, autoescape=autoescape)
     return self.nodelist.render(context)
Example #13
0
def render_to_response(template_name, dictionary=None, context_instance=None,
                       mimetype=None):
    """
    Mimics ``django.shortcuts.render_to_response`` but uses Mezzanine's
    ``get_template`` which handles device specific template directories.
    """
    dictionary = dictionary or {}
    if context_instance:
        context_instance.update(dictionary)
    else:
        context_instance = Context(dictionary)
    if isinstance(template_name, (list, tuple)):
        t = select_template(template_name, context_instance)
    else:
        t = get_template(template_name, context_instance)
    return HttpResponse(t.render(context_instance), mimetype=mimetype)
Example #14
0
def podcast_list(request,
                 tag=None,
                 year=None,
                 month=None,
                 username=None,
                 category=None,
                 template="podcast/podcast_list.html"):
    """
    Provide a listing of podcasts
    """
    templates = []
    podcasts = Podcast.objects.published()
    context = {"page": podcast_page(), "podcasts": podcasts}
    templates.append(template)
    request_context = RequestContext(request, context)
    t = select_template(templates, request_context)
    return HttpResponse(t.render(request_context))
Example #15
0
def render_to_response(template_name,
                       dictionary=None,
                       context_instance=None,
                       mimetype=None):
    """
    Mimics ``django.shortcuts.render_to_response`` but uses Mezzanine's 
    ``get_template`` which handles device specific template directories.
    """
    dictionary = dictionary or {}
    if context_instance:
        context_instance.update(dictionary)
    else:
        context_instance = Context(dictionary)
    if isinstance(template_name, (list, tuple)):
        t = select_template(template_name, context_instance)
    else:
        t = get_template(template_name, context_instance)
    return HttpResponse(t.render(context_instance), mimetype=mimetype)
Example #16
0
def blog_post_detail(request, slug, template="blog/blog_post_detail.html"):
    """
    Display a blog post.
    """
    # Create two comment forms - one with posted data and errors that will be
    # matched to the form submitted via comment_id, and an empty one for all
    # other instances.
    commenter_cookie_prefix = "mezzanine-blog-"
    commenter_cookie_fields = ("name", "email", "website")
    comment_data = {}
    for f in commenter_cookie_fields:
        comment_data[f] = request.COOKIES.get(commenter_cookie_prefix + f, "")
    blog_posts = BlogPost.objects.published(for_user=request.user)
    blog_post = get_object_or_404(blog_posts, slug=slug)
    posted_comment_form = CommentForm(request.POST or None, 
                                      initial=comment_data)
    unposted_comment_form = CommentForm(initial=comment_data)
    if request.method == "POST" and posted_comment_form.is_valid():
        comment = posted_comment_form.save(commit=False)
        comment.blog_post = blog_post
        comment.by_author = (request.user == blog_post.user and
                             request.user.is_authenticated)
        comment.ip_address = request.META.get("HTTP_X_FORWARDED_FOR",
                                              request.META["REMOTE_ADDR"])
        comment.replied_to_id = request.POST.get("replied_to")
        comment.save()
        response = HttpResponseRedirect(comment.get_absolute_url())
        # Store commenter's details in a cookie for 90 days.
        cookie_expires = 60 * 60 * 24 * 90
        for f in commenter_cookie_fields:
            cookie_name = commenter_cookie_prefix + f
            cookie_value = request.POST.get(f, "")
            set_cookie(response, cookie_name, cookie_value, cookie_expires)
        return response
    settings.use_editable()
    context = {"blog_post": blog_post, "blog_page": blog_page(),
               "use_disqus": bool(settings.COMMENTS_DISQUS_SHORTNAME),
               "posted_comment_form": posted_comment_form,
               "unposted_comment_form": unposted_comment_form}
    request_context = RequestContext(request, context)
    t = select_template(["blog/%s.html" % slug, template], request_context)
    return HttpResponse(t.render(request_context))
Example #17
0
def blog_post_detail(request, slug, template="blog/blog_post_detail.html"):
    """
    Display a blog post and handle comment submission. Custom 
    templates are checked for using the name
    ``blog/blog_post_detail_XXX.html`` where ``XXX`` is the blog 
    posts's slug.
    """
    blog_posts = BlogPost.objects.published(for_user=request.user)
    blog_post = get_object_or_404(blog_posts, slug=slug)
    # Handle comments
    comment_parts = handle_comments(blog_post, request)
    posted_comment_form, unposted_comment_form, response = comment_parts
    if response is not None:
        return response
    context = {"blog_page": blog_page(), "blog_post": blog_post, 
               "posted_comment_form": posted_comment_form,
               "unposted_comment_form": unposted_comment_form}
    templates = ["blog/blog_post_detail_%s.html" % slug, template]
    request_context = RequestContext(request, context)
    t = select_template(templates, request_context)
    return HttpResponse(t.render(request_context))
Example #18
0
def blog_post_list(request, tag=None, year=None, month=None, username=None,
                   category=None, template="blog/blog_post_list.html"):
    """
    Display a list of blog posts that are filtered by tag, year, month, 
    author or category. Custom templates are checked for using the name
    ``blog/blog_post_list_XXX.html`` where ``XXX`` is either the 
    category slug or author's username if given.
    """
    settings.use_editable()
    templates = []
    blog_posts = BlogPost.objects.published(for_user=request.user)
    if tag is not None:
        tag = get_object_or_404(Keyword, slug=tag)
        blog_posts = blog_posts.filter(keywords=tag)
    if year is not None:
        blog_posts = blog_posts.filter(publish_date__year=year)
        if month is not None:
            blog_posts = blog_posts.filter(publish_date__month=month)
            month = month_name[int(month)]
    if category is not None:
        category = get_object_or_404(BlogCategory, slug=category)
        blog_posts = blog_posts.filter(categories=category)
        templates.append("blog/blog_post_list_%s.html" % category.slug)
    author = None
    if username is not None:
        author = get_object_or_404(User, username=username)
        blog_posts = blog_posts.filter(user=author)
        templates.append("blog/blog_post_list_%s.html" % username)
    blog_posts = paginate(blog_posts, request.GET.get("page", 1),
                          settings.BLOG_POST_PER_PAGE,
                          settings.BLOG_POST_MAX_PAGING_LINKS)
    context = {"blog_page": blog_page(), "blog_posts": blog_posts, 
               "year": year, "month": month, "tag": tag, 
               "category": category, "author": author}
    templates.append(template)
    request_context = RequestContext(request, context)
    t = select_template(templates, request_context)
    return HttpResponse(t.render(request_context))
Example #19
0
def blog_post_detail(request, slug, template="blog/blog_post_detail.html"):
    """
    Display a blog post and handle comment submission. Custom 
    templates are checked for using the name
    ``blog/blog_post_detail_XXX.html`` where ``XXX`` is the blog 
    posts's slug.
    """
    blog_posts = BlogPost.objects.published(for_user=request.user)
    blog_post = get_object_or_404(blog_posts, slug=slug)
    # Handle comments
    comment_parts = handle_comments(blog_post, request)
    posted_comment_form, unposted_comment_form, response = comment_parts
    if response is not None:
        return response
    context = {
        "blog_page": blog_page(),
        "blog_post": blog_post,
        "posted_comment_form": posted_comment_form,
        "unposted_comment_form": unposted_comment_form
    }
    templates = ["blog/blog_post_detail_%s.html" % slug, template]
    request_context = RequestContext(request, context)
    t = select_template(templates, request_context)
    return HttpResponse(t.render(request_context))
Example #20
0
def blog_post_list(request,
                   tag=None,
                   year=None,
                   month=None,
                   username=None,
                   category=None,
                   template="blog/blog_post_list.html"):
    """
    Display a list of blog posts that are filtered by tag, year, month,
    author or category. Custom templates are checked for using the name
    ``blog/blog_post_list_XXX.html`` where ``XXX`` is either the
    category slug or author's username if given.
    """
    settings.use_editable()
    templates = []
    blog_posts = BlogPost.objects.published(for_user=request.user)
    if tag is not None:
        tag = get_object_or_404(Keyword, slug=tag)
        blog_posts = blog_posts.filter(keywords__in=tag.assignments.all())
    if year is not None:
        blog_posts = blog_posts.filter(publish_date__year=year)
        if month is not None:
            blog_posts = blog_posts.filter(publish_date__month=month)
            month = month_name[int(month)]
    if category is not None:
        category = get_object_or_404(BlogCategory, slug=category)
        blog_posts = blog_posts.filter(categories=category)
        templates.append(u"blog/blog_post_list_%s.html" % category.slug)
    author = None
    if username is not None:
        author = get_object_or_404(User, username=username)
        blog_posts = blog_posts.filter(user=author)
        templates.append(u"blog/blog_post_list_%s.html" % username)
    # Create dicts mapping blog post IDs to lists of categories and
    # keywords, and assign these to each blog post, to avoid querying
    # the database inside the template loop for posts.
    blog_posts = list(blog_posts.select_related("user"))
    categories = defaultdict(list)
    if blog_posts:
        ids = ",".join([str(p.id) for p in blog_posts])
        for cat in BlogCategory.objects.raw(
                "SELECT * FROM blog_blogcategory "
                "JOIN blog_blogpost_categories "
                "ON blog_blogcategory.id = blogcategory_id "
                "WHERE blogpost_id IN (%s)" % ids):
            categories[cat.blogpost_id].append(cat)
    keywords = defaultdict(list)
    blogpost_type = ContentType.objects.get(app_label="blog", model="blogpost")
    assigned = AssignedKeyword.objects.filter(
        blogpost__in=blog_posts,
        content_type=blogpost_type).select_related("keyword")
    for a in assigned:
        keywords[a.object_pk].append(a.keyword)
    for i, post in enumerate(blog_posts):
        setattr(blog_posts[i], "category_list", categories[post.id])
        setattr(blog_posts[i], "keyword_list", keywords[post.id])
    blog_posts = paginate(blog_posts, request.GET.get("page", 1),
                          settings.BLOG_POST_PER_PAGE,
                          settings.BLOG_POST_MAX_PAGING_LINKS)
    context = {
        "blog_page": blog_page(),
        "blog_posts": blog_posts,
        "year": year,
        "month": month,
        "tag": tag,
        "category": category,
        "author": author
    }
    templates.append(template)
    request_context = RequestContext(request, context)
    t = select_template(templates, request_context)
    return HttpResponse(t.render(request_context))