def post_create_view(request, slug):
"""
Renders view to create a new post.
:param request: http request
:param slug: slug of blog to append post to.
:return: rendered post creation form(GET) or redirect to post's associated blog(POST).
If user does not own blog then 403's.
"""
blog = get_object_or_404(Blog, slug=slug)
if blog.isOwnedBy(request.user):
post_form = PostCreateForm(request.POST or None)
if request.method == "POST":
if post_form.is_valid():
post = post_form.save(commit=False)
post.blog = blog
post.root = None
post.save()
post.root = post
post.tags = Tag.find_or_create_tags(post_form.data["tags_field"])
post.save()
Activity.create_activity(blog, post, POST)
return redirect(blog.get_absolute_url())
context = {"post_form":post_form}
context.update(csrf(request))
return render(request, "post_create.html", context)
return HttpResponseForbidden()
def data_for_all(request):
"""This data is used for all normal pages where no blog is selected."""
data = common_data(request)
data.update({"tags": Tag.used_tags(),
"archive_qualifier": "",
"recent_active_months": Blog.recent_active_months()})
return data
def data_for_selected_blog(request, user):
data = common_data(request)
active_blog = get_object_or_404(Blog, owner__id = user.id)
data.update({"active_blog": active_blog,
"tags": Tag.used_tags(user.id),
"archive_qualifier": "/%s" % user.username,
"recent_active_months": active_blog.last_active_months()})
return data
def tagged_view(request, tag):
"""
Renders view for the tag passed in.
:param request: http request
:param tag: tag to view
:return: rendered tag template
"""
posts = Tag.find_posts_for_tag(tag) #TODO: pass tag as GET parameter so spaces in url are not an issue(as opposed to slugifying tags)
display_info_list=[]
for post in posts:
display_info_list.append(PostDisplayInfo(request.user.blog,
post,
Activity.find_activity_for_object(post.pk,
ContentType.objects.get_for_model(Post)).activity_type))
context = {"tag":tag, "display_info_list":display_info_list}
return render(request, "tagged.html", context)
def handle_error(request, response, template):
"""Display an error page."""
response.write(
loader.render_to_string(
template,
None,
RequestContext(
request,
dict = {"blogs": Blog.objects.select_related(),
"tags": Tag.used_tags(),
"archive_qualifier": "",
"recent_active_months": Blog.recent_active_months()}
)
)
)
return response
def load_more_tagged_posts(request, tag):
"""
Asynchronously loads NUM_POSTS_TO_RETRIEVE more posts onto the current tag being viewed.
:param request: xml http request
:param tag: tag for which to retrieve posts
:return: rendered posts template
"""
offset = int(request.GET["offset"])
NUM_POSTS_TO_RETRIEVE = int(request.GET["NUM_POSTS_TO_RETRIEVE"])
posts = Tag.find_posts_for_tag(tag)[offset:offset+NUM_POSTS_TO_RETRIEVE]
display_info_list=[]
for post in posts:
display_info_list.append(PostDisplayInfo(request.user.blog,
post,
Activity.find_activity_for_object(post.pk,
ContentType.objects.get_for_model(Post)).activity_type))
context = {"display_info_list": display_info_list}
raw_template = loader.get_template("posts.html")
rendered_template = raw_template.render(context)
return HttpResponse(rendered_template, content_type='text/html')
def reblog_post(request, post_id):
"""
Renders view for rebloging a post.
:param request: http request
:param post_id: id of post to be rebloged
:return: rendered post creation form populated with post instance(belonging to post_id)
"""
post = get_object_or_404(Post, pk=post_id)
if request.method == "POST":
form = PostCreateForm(request.POST)
if form.is_valid():
new_post = form.save(commit=False)
new_post.root = post.root
new_post.blog = request.user.blog
if post.is_root():
if blockquotify(post.blog, post) == new_post.content:
pass #if user has not changed content, do not blockquotify
else:
new_post.content = blockquotify(request.user.blog, new_post)
else:
if new_post.content != post.content: #if user has not changed content, do not blockquotify
new_post.content = blockquotify(request.user.blog, new_post)
new_post.save()##must persist prior to setting tags field
new_post.tags = Tag.find_or_create_tags(form.data["tags_field"])
new_post.save()
Activity.create_activity(request.user.blog, new_post, REBLOG)
return redirect(request.user.blog.get_absolute_url())
form = PostCreateForm()
form.fields["title"].initial = post.title
if post.is_root():#if post is a root post blockquotify before post creation form is rendered
form.fields["content"].initial = blockquotify(post.blog, post)
else:
form.fields["content"].initial = post.content
context = {"post_form": form}
context.update(csrf(request))
return render(request, "post_create.html", context)
